Aufgabe

• Nehmen Sie die durch Leerzeichen getrennte Eingabezeichenfolge.
• Sortieren Sie die Wörter alphabetisch.
• Drucken Sie sie vertikal in 3 Spalten aus, die durch Leerzeichen voneinander getrennt sind.

Herausforderung

• Alle drei Spaltenhöhen sollten so gleichmäßig wie möglich gewichtet sein.
• Alle drei Spalten sollten linksbündig sein.

Das ist Code-Golf , also gewinnt der kürzeste Code!

Beispiel

Wenn die Eingabe lautet:

"cat caterpillar pie frog elephant pizza", 

Die Ausgabe sollte sein:

cat         elephant pie
caterpillar frog     pizza

Bitte beachten Sie die Fälle, wenn die Eingabe wie folgt lautet:

"a b c d e f g" 

Sollte gedruckt werden als:

a c e
b d f
    g

# or

a d f
b e g
c

# and not

a d g
b e
c f

Schale , 24 17 Bytes

TmoTT' §CȯmLTC3Ow

Probieren Sie es online!

Erläuterung

Dies war eine überraschend knifflige Herausforderung, da Husk derzeit nicht über eine integrierte Funktion zum Aufteilen einer Liste in eine bestimmte Anzahl von Teilen verfügt.

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.

Gelee , 6 Bytes

Ṣœs3ZG

Probieren Sie es online!

Python 3 , 148 Bytes

-6 bytes dank ovs.

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)

Probieren Sie es online!

Ich arbeite daran. Alles, was ich versucht habe, macht die Ausgabe schief ...

Mathematica, 115 Bytes

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

Probieren Sie es auf Wolfram Sandbox

Füge den folgenden Code ein und drücke Shift + Enter

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 Bytes

$.=(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

Probieren Sie es online!

05AB1E , 8 Bytes

#{.B3äζ»

Probieren Sie es online!

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

Javascript 181 175 Bytes

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 Bytes

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

Ich kann dieses Durcheinander später erklären, wenn jemand interessiert ist.

Probieren Sie es online!

Kohle , 65 64 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Sparen Sie 2 Bytes, wenn ich nicht mit weniger als 3 Wörtern umgehen muss. Es gibt wahrscheinlich eine Sortierung "eval", die ich verwenden sollte ... Erläuterung:

≔⪪θ η

Teilen Sie die Eingabe auf Leerzeichen.

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

Sortieren Sie das Array.

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

Schleife über drei ungefähr gleiche Scheiben des Arrays. ( Ｉ1Sollte es wirklich sein ¦¹.)

Ｐ⪫ι¶

Verbinden Sie das Slice mit Zeilenumbrüchen und drucken Sie es aus, ohne den Cursor zu bewegen.

¿ιＭ⊕⌈ＥιＬκ→

Wenn das Slice nicht leer ist, gehen Sie um eins weiter als das längste Wort im Slice.

358 Bytes minimiertes 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 Bytes

+1 Byte für -rFlag.

Ich habe das überhaupt nicht golfen, aber es stellte sich als viel einfacher heraus, als ich erwartet hatte.

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

Probieren Sie es online!

Borowski-Shell, 172 Bytes

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

Es ist besser lesbar, wenn es konventionell formatiert ist:

#! /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

Zum Preis des einmaligen Scannens der Eingabe pro Spalte werden keine Arrays verwendet. Ein komplexeres awk-Programm könnte 3 Dateien (eine für jedes N-te Wort) öffnen und die Eingabe in einem Durchgang verarbeiten. Dann könnten sie verkettet und mit derselben letzten Zeile gedruckt werden.

Die Variable Nwird auch nicht unbedingt benötigt. Für den Preis von 4 Byte sparen wir uns das dreimalige Scannen der Eingabe.