Tâche

• Prenez la chaîne d'entrée séparée par un espace.
• Triez les mots par ordre alphabétique.
• Imprimez-les verticalement en 3 colonnes séparées par des espaces.

Défi

• Les hauteurs des trois colonnes doivent être pondérées aussi uniformément que possible.
• Les trois colonnes doivent être alignées à gauche.

C'est le code-golf , donc le code le plus court gagne!

Exemple

Si l'entrée est:

"cat caterpillar pie frog elephant pizza", 

La sortie doit être:

cat         elephant pie
caterpillar frog     pizza

Veuillez vous méfier des cas, si la saisie est:

"a b c d e f g" 

Doit être imprimé comme:

a c e
b d f
    g

# or

a d f
b e g
c

# and not

a d g
b e
c f

Husk , 24 17 octets

TmoTT' §CȯmLTC3Ow

Essayez-le en ligne!

Explication

C'était un défi étonnamment délicat, car Husk n'a actuellement pas de fonction intégrée pour diviser une liste en un certain nombre de pièces.

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.

Gelée , 6 octets

Ṣœs3ZG

Essayez-le en ligne!

Python 3 , 148 octets

-6 octets grâce aux 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)

Essayez-le en ligne!

Je travaille dessus. Tout ce que j'ai essayé rend la sortie déséquilibrée ...

Mathematica, 115 octets

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

essayez-le sur wolfram sandbox

collez le code suivant et appuyez sur Maj + Entrée

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 octets

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

Essayez-le en ligne!

05AB1E , 8 octets

#{.B3äζ»

Essayez-le en ligne!

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

Javascript 181 175 octets

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 octets

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

Je peux expliquer ce gâchis plus tard si quelqu'un est intéressé.

Essayez-le en ligne!

Charbon de bois , 65 64 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Économisez 2 octets si je n'ai pas à gérer le cas de moins de 3 mots. Il y a probablement un "eval" de tri que je devrais utiliser ... Explication:

≔⪪θ η

Divisez l'entrée sur les espaces.

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

Triez le tableau.

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

Faites une boucle sur trois tranches approximativement égales du tableau. ( Ｉ1devrait vraiment l'être ¦¹.)

Ｐ⪫ι¶

Joignez la tranche avec des nouvelles lignes et imprimez-la sans déplacer le curseur.

¿ιＭ⊕⌈ＥιＬκ→

Si la tranche n'est pas vide, déplacez-vous d'un cran vers la droite de la longueur du mot le plus long de la tranche.

358 octets de JS minifié:

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 octets

+1 octet pour l' -rindicateur.

Je n'ai pas joué au golf du tout, mais cela s'est avéré beaucoup plus simple que ce à quoi je m'attendais.

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

Essayez-le en ligne!

Shell Bourne, 172 octets

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

Il est plus lisible s'il est formaté de manière conventionnelle:

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

Au prix de l'analyse de l'entrée une fois par colonne, elle n'utilise aucun tableau. Un programme awk plus complexe pourrait ouvrir 3 fichiers (un pour chaque Nième mot), traitant l'entrée en une seule passe. Ensuite, ils pourraient être concaténés et imprimés en utilisant la même dernière ligne.

La variable Nn'est pas strictement nécessaire non plus; pour le prix de 4 octets, nous économisons l'analyse de l'entrée 3 fois de plus.