Tarea

• Tome la cadena de entrada separada por espacio.
• Ordena las palabras alfabéticamente.
• Imprímalos verticalmente en 3 columnas separadas por espacios.

Desafío

• Las alturas de las tres columnas deben tener la mayor ponderación posible.
• Las tres columnas deben dejarse alineadas.

Este es el código de golf , ¡el código más corto gana!

Ejemplo

Si la entrada es:

"cat caterpillar pie frog elephant pizza", 

La salida debe ser:

cat         elephant pie
caterpillar frog     pizza

Tenga cuidado con los casos, si la entrada es:

"a b c d e f g" 

Debe imprimirse como:

a c e
b d f
    g

# or

a d f
b e g
c

# and not

a d g
b e
c f

Casco , 24 17 bytes

TmoTT' §CȯmLTC3Ow

Pruébalo en línea!

Explicación

Este fue un desafío sorprendentemente complicado, ya que Husk actualmente carece de una capacidad para dividir una lista en un número dado de partes.

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.

Jalea , 6 bytes

Ṣœs3ZG

Pruébalo en línea!

Python 3 , 148 bytes

-6 bytes gracias a los 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)

Pruébalo en línea!

Trabajando en eso. Todo lo que he probado hace que la salida sea desigual ...

Mathematica, 115 bytes

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

pruébalo en el sandbox de wolfram

pegue el siguiente código y presione 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

Pruébalo en línea!

05AB1E , 8 bytes

#{.B3äζ»

Pruébalo en línea!

#        | 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])@/:~

Puedo explicar este desastre más tarde si alguien está interesado.

Pruébalo en línea!

Carbón , 65 64 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Ahorre 2 bytes si no tengo que manejar el caso de menos de 3 palabras. Probablemente haya una "evaluación" de clasificación que debería usar ... Explicación:

≔⪪θ η

Dividir la entrada en espacios.

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

Ordenar la matriz.

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

Pase por tres cortes aproximadamente iguales de la matriz. ( Ｉ1realmente debería ser ¦¹)

Ｐ⪫ι¶

Une el corte con líneas nuevas e imprímelo sin mover el cursor.

¿ιＭ⊕⌈ＥιＬκ→

Si el segmento no está vacío, muévase a la derecha uno más que la longitud de la palabra más larga del segmento.

358 bytes de JS minificado:

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 bytes para la -rbandera.

No he jugado al golf en absoluto, pero resultó ser mucho más simple de lo que esperaba.

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

Pruébalo en línea!

Bourne 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 más legible si se formatea de manera convencional:

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

Al precio de escanear la entrada una vez por columna, no utiliza matrices. Un programa awk más complejo podría abrir 3 archivos (uno por cada enésima palabra), procesando la entrada de una sola vez. Luego podrían ser concatenados e impresos utilizando la misma última línea.

La variable Ntampoco es estrictamente necesaria; por el precio de 4 bytes, ahorramos escaneando la entrada 3 veces más.