Görev

• Giriş dizesini boşlukla ayırarak alın.
• Kelimeleri alfabetik olarak sıralayın.
• Bunları boşluklarla ayrılmış 3 sütuna dikey olarak yazdırın.

Meydan okuma

• Her üç sütunun yüksekliği de mümkün olduğunca eşit ağırlıkta olmalıdır.
• Üç sütunun da sola hizalanması gerekir.

Bu kod golf , bu yüzden en kısa kod kazanır!

Misal

Giriş şuysa:

"cat caterpillar pie frog elephant pizza", 

Çıktı şöyle olmalıdır:

cat         elephant pie
caterpillar frog     pizza

Giriş ise lütfen aşağıdaki durumlara dikkat edin:

"a b c d e f g" 

Aşağıdaki gibi basılmalıdır:

a c e
b d f
    g

# or

a d f
b e g
c

# and not

a d g
b e
c f

Kabuk , 24 17 bayt

TmoTT' §CȯmLTC3Ow

Çevrimiçi deneyin!

açıklama

Husk şu anda belirli bir sayıda parçaya bir liste kırmak için bir yerleşikten yoksun olduğu için bu şaşırtıcı derecede zor bir mücadeleydi.

TmoTT' §CȯmLTC3Ow  Implicit input, say s="bbb a cc ddd e"
                w  Split at spaces: x=["bbb","a","cc","ddd","e"]
             C3    Cut into slices of length 3: [["bbb","a","cc"],["ddd","e"]]
            T      Transpose: [["bbb","ddd"],["a","e"],["cc"]]
         ȯmL       Map length: [2,2,1]
                   These are the correct lengths of the columns.
       §C      O   Sort x and split into these lengths: [["a","bbb"],["cc","ddd"],["e"]]
                   These are the columns of the correct output, without padding.
 mo                For each column,
    T'             transpose and pad with spaces: [["ab"," b"," b"],["cd","cd"," d"],["e"]]
   T               then transpose back: [["a  ","bbb"],["cc ","ddd"],["e"]]
T                  Transpose the whole list: [["a  ","cc ","e"],["bbb","ddd"]]
                   Implicitly join each row by spaces,
                   join the resulting strings by newlines and print.

Jöle , 6 bayt

Ṣœs3ZG

Çevrimiçi deneyin!

Python 3 , 148 bayt

OV sayesinde -6 bayt.

l=sorted(input().split())
n=-~len(l)//3
f=lambda l:[i.ljust(max(map(len,l)))for i in l+['']]
for i in zip(f(l[:n]),f(l[n:n*2]),f(l[n*2:])):print(*i)

Çevrimiçi deneyin!

Üzerinde çalışıyorum. Denediğim her şey çıktıyı ters çeviriyor ...

Mathematica, 115 bayt

Grid[Transpose@PadRight@TakeList[#,Last@IntegerPartitions[Tr[1^#],3]]&@Sort@StringSplit@#/. 0->"",Alignment->Left]&

wolfram kum havuzunda dene

aşağıdaki kodu yapıştırın ve shift + enter tuşlarına basın

Grid[Transpose@PadRight@TakeList[#,Last@IntegerPartitions[Tr[1^#],3]]&@Sort@StringSplit@#/. 0->"",Alignment->Left]&["cat caterpillar pie frog elephant pizza"]

Perl 5 , 134 + 1 ( -a) = 135 bayt

$.=(sort{$b=~y///c-length$a}(@F=sort@F))[0]=~y///c;@a=splice@F,0,@F/3;@b=splice@F,0,@F/2;printf"%-$.s "x3 .$/,shift@a,shift@b,$_ for@F

Çevrimiçi deneyin!

05AB1E , 8 bayt

#{.B3äζ»

Çevrimiçi deneyin!

#        | Split on spaces.
 {       | Sort aphabetically.
  .B     | Pad to max string length.
    3ä   | Split into columns.
      ζ  | Transpose.
       » | Print with newlines.

Javascript 181175 bayt

f=a=>(a=a.split` `).sort().map(c=>(t[y]=[...t[y]||[],c],M[x]>(l=c.length)?0:M[x]=l,a[++y*3+x]?y:y=x++*0),M=[t=[x=y=0]])&&t.map(x=>x.map((c,y)=>c.padEnd(M[y])).join` `).join`
`

console.log(f("cat caterpillar pie frog elephant pizza"))
console.log("-------------------")
console.log(f("cat caterpillar pie frog frog123123 pizza"))
console.log("-------------------")
console.log(f("a b c d e f g"))
console.log("-------------------")
console.log(f("a b c d e f"))
console.log("-------------------")
console.log(f("a b c d e"))
console.log("-------------------")
console.log(f("a b c d"))

/*
f=a=>(a=a.split` `).sort().map(c=>((t[y] =t[y]||[])[x]=c,M[x]>(l=c.length)?0:M[x]=l,++y*3+x<a.length?0:y=x++*0),M=[t=[x=y=0]])&&t.map(x=>x.map((c,y)=>c.padEnd(M[y])).join` `).join`\n`

f=a=>(a=a.split` `).sort().map(c=>(t[y]=[...t[y]||[],c],M[x]>(l=c.length)?0:M[x]=l,++y*3+x<a.length?0:y=x++*0),M=[t=[x=y=0]])&&t.map(x=>x.map((c,y)=>c.padEnd(M[y])).join` `).join`\n`

*/

J , 73 bayt

,.@(' ',"1[:>|:)@((](s,(s=.]{.1:),(1:{.~[-2*]))([:<.0.5+%&3))@#];.1])@/:~

Birisi ilgilenirse bu karışıklığı daha sonra açıklayabilirim.

Çevrimiçi deneyin!

Kömür , 65 64 bayt

≔⪪θ ηＦη«⊞υ⌊η≔⟦⟧ηＦ⪪θ ¿¬№υκ⊞ηκ»ＦＥ³✂υ÷×ιＬυ³÷×⊕ιＬυ³Ｉ1«Ｐ⪫ι¶¿ιＭ⊕⌈ＥιＬκ→

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. 3 kelimeden daha azını ele almam gerekmiyorsa 2 bayt kaydet. Muhtemelen kullanmam gereken bir sıralama "eval" var ... Açıklama:

≔⪪θ η

Girişi boşluklara ayırın.

Ｆη«⊞υ⌊η≔⟦⟧ηＦ⪪θ ¿¬№υκ⊞ηκ»

Diziyi sıralayın.

ＦＥ³✂υ÷×ιＬυ³÷×⊕ιＬυ³Ｉ1«

Dizinin yaklaşık üç eşit dilimi üzerinde döngü yapın. ( Ｉ1gerçekten olmalı ¦¹.)

Ｐ⪫ι¶

Yeni satırlarla dilime katılın ve imleci hareket ettirmeden yazdırın.

¿ιＭ⊕⌈ＥιＬκ→

Dilim boş değilse, dilimdeki en uzun kelimenin uzunluğundan bir sağ daha fazla hareket edin.

358 bayt küçültülmüş JS:

function f(b){let d=[,,,],e=b.split(" ").sort(),g=[],h=[];for(var j in e){var k=Math.min(2,Math.floor(j/Math.floor(e.length/3)));d[k]||(d[k]=[],g[k]=e[j].length),d[k].push(e[j]),2==k&&h.push(""),g[k]=Math.max(e[j].length,g[k])}for(var o in g)for(var p=0;p<g[o]+1;p++)for(var q in h)h[q]+=q>=d[o].length||p>=d[o][q].length?" ":d[o][q][p];return h.join("\n")}

function f(b){let d=[,,,],e=b.split(" ").sort(),g=[],h=[];for(var j in e){var k=Math.min(2,Math.floor(j/Math.floor(e.length/3)));d[k]||(d[k]=[],g[k]=e[j].length),d[k].push(e[j]),2==k&&h.push(""),g[k]=Math.max(e[j].length,g[k])}for(var o in g)for(var p=0;p<g[o]+1;p++)for(var q in h)h[q]+=q>=d[o].length||p>=d[o][q].length?" ":d[o][q][p];return h.join("\n")}

console.log(f("cat caterpillar pie frog elephant pizza"));
console.log(f("a b c d e f g"));

GNU sed , 92 + 1 = 93 bayt

-rBayrak için +1 bayt .

Ben hiç golf değil, ama beklediğimden çok daha basit olduğu ortaya çıktı.

s/$/ /
s/(\S+ ){1,3}/:&\n/g
:
s/:(\S)/\1:/g
/:\S/!bZ
s/: / &/g
t
:Z
s/: / :/g
t
s/ *:.*$//gm

Çevrimiçi deneyin!

Bourne kabuğu, 172 bayt

F=/tmp/t
<$1 tr \  \\n|sort>$F
N=$(wc -w $F|awk '{print $1/3}')
for i in 0 1 2
do
awk 'NR%N==C {print}' N=$N C=$i $F 
done|awk '{printf "%s%s",$1,NR%3?" ":"\n"}'|column -t

Geleneksel olarak biçimlendirilirse daha okunabilir:

#! /bin/sh
F=/tmp/t
<$1 tr \  \\n | sort > $F
N=$(wc -w $F | awk '{print $1/3}')

for i in 0 1 2
do    
    awk -v N=$N -v C=$i 'NR % N == C {print}' $F 
done |
    awk '{printf "%s%s", $1, NR % 3 == 0? "\n" : " " }' | column -t

Girdiyi sütun başına bir kez taramak pahasına, diziler kullanmaz. Daha karmaşık bir awk programı, girişi bir geçişte işleyerek 3 dosyayı (her Nth kelimesi için bir tane) açabilir. Sonra aynı son satır kullanılarak birleştirilebilir ve yazdırılabilir.

Değişken Nde kesinlikle gerekli değildir; 4 baytlık fiyat için, girişi 3 kez daha taramayı kaydediyoruz.