Votre tâche consiste à prendre une chaîne d'entrée de caractères ascii et à sortir la chaîne sous la forme d'une série de mots verticaux séparés par des espaces. Un exemple est illustré ci-dessous:

Étant donné la chaîne:

Hello, World! My name is Foo.

la sortie doit être:

H W M n i F
e o y a s o
l r   m   o
l l   e   .
o d
, !

10 points bonus seront attribués si votre programme gère correctement les chaînes qui doivent entourer le terminal, que nous définirons à 80 caractères.

50 points si votre programme peut aussi faire l'inverse!

J, 15

|:>'\S+| 'rxall

Usage:

   |:>'\S+| 'rxall 'Hello, World! My name is Foo.'
H W M n i F
e o y a s o
l r   m   o
l l   e   .
o d        
, !        

Javascript - 228 172 145 126

A=prompt().split(" "),B="",N=A;for(y=0;y<N.length;y++){for(i=0;i<N.length;i++){if(A[i][y]){B+=A[i][y];}else{B+=" ";}}B+="\n";}

Mon premier code golf :)

APL, 22

{⍉⊃⍵⊂⍨1+0,+\2≠/⍵=' '}

Explication

{              ⍵=' '}   A. check which chars are spaces           
            2≠/         B. of that vector, which consecutive pairs are different  
          +\            C. compute the partial sums                           
      1+0,              D. insert 0 at the front and add 1 to every item
   ⍵⊂⍨                     use this vector to split the original string
 ⍉⊃                        disclose into a matrix and transpose

    'W o w   S u c h   D o g e'
A.   0 0 0 1 0 0 0 0 1 0 0 0 0
B.    0 0 1 1 0 0 0 1 1 0 0 0
C.    0 0 1 2 2 2 2 3 4 4 4 4
D.  1 1 1 2 3 3 3 3 4 5 5 5 5

Exemple

      {⍉⊃⍵⊂⍨1+0,+\2≠/⍵=' '} 'Hello, World! My name is Foo.'
H W M n i F
e o y a s o
l r   m   o
l l   e   .
o d        
, !        

Rubis, 91 87

s=gets.split
puts s.map{|x|x.ljust(s.map(&:size).max,' ').split''}.transpose.map &:join

Hourra, j'ai battu Perl! :RÉ

Rubis, 150 - 50 bonus = 100

s=$<.read
n=s.index"
"
s=s.split n ?'
':' '
o=s.map{|x|x.ljust(s.map(&:size).max,' ').split''}.transpose.map &:join
puts n ?o.map(&:strip).join(' '):o

Il détecte simplement les nouvelles lignes et applique une gestion spéciale si elles sont détectées.

Exécutez-le comme

ruby transposegolf.rb < transposegolfinput.txt

Javascript 184 149 123

var a=s.split(" "),b="",c;for(c in a)b+="<div style='float:left'>"+a[c].split("").join("<br>")+"</div>";document.write(b);

Avec l'exemple de chaîne défini:

var s = "Hello, World! My name is Foo.";
var a=s.split(" "),b="",c;for(c in a)b+="<div style='float:left'>"+a[c].split("").join("<br>")+"</div>";document.write(b);

Vous pouvez copier la deuxième instruction sur la console de votre navigateur.

Non minifié:

var res = "Hello, World! My name is Foo.";
var t=res.split(" ");
var s ="";
for (var word in t){
    s+="<div style='float:left'>" + t[word].split("").join("<br />") + "</div>";
}
document.write(s);

Lien JsFiddle: http://jsfiddle.net/FzMvK/

Mon premier post de golf à code: P

Perl - 92 97

$_=<>;chop;@x=split$";do{print((substr$_,$q,1or$").$")for@x;$q++,print$/}while/@{['\S'x$q]}/

Fait le travail d'une manière assez simple.

K, 33

{" "/:',:''x@'/:!max@#:'x:" "\:x}

Exemple d'entrée et de sortie:

k){" "/:',:''x@'/:!max@#:'x:" "\:x}"Hello, World! My name is Foo."
"H W M n i F"
"e o y a s o"
"l r   m   o"
"l l   e   ."
"o d        "
", !        "

Python:

Une ligne de code pour traiter la piqûre:

import sys
m = "Hello, World! My name is Foo."

map(lambda y: sys.stdout.write(' '.join(y)+'\n'), zip(*map(lambda x: x.ljust(max(map(len,m.split()))), m.split())))

Python 2.7, 108 103

Je suis sûr que cela peut être joué plus, mais voici une première solution en python.

w=raw_input().split();m=max(map(len,w));i=0
while i<m:print" ".join(map(lambda x:x.ljust(m)[i],w));i+=1

Améliorations:

• split ("") => split ()
• supprimé des espaces supplémentaires

F #, 187

let o=Console.ReadLine()
let s=o.Split(' ')
let m=s|>Seq.map String.length|>Seq.max
for l=0 to m-1 do
 for w in s|>Seq.map(fun x->x.PadRight(m,' ').[l])do printf"%c "w
 printfn"%s"""

Rubis, 63

$F.map(&:size).max.times{|i|puts$F.map{|s|s[i]||' '}.join' '}

L'algorithme est très simple; seulement joué au golf. Le code fait 61 octets de long, plus 2 octets pour les -naoptions dont il a besoin pour fonctionner. De ruby -h:

-n   assume 'while gets(); ... end' loop around your script
-a   autosplit mode with -n or -p (splits $_ into $F)

Exemple d'exécution:

$ echo 'This sentence is false' | ruby -na cols.rb
T s i f
h e s a
i n   l
s t   s
  e   e
  n    
  c    
  e

Python 2.7 - 137 112 octets

s=raw_input().split()
for c in range(max(map(len,s))):
 for w in s:
    try:print w[c],
    except:print' ',
 print''

Quelqu'un d'autre l'a déjà fait mieux, mais je ferais aussi bien de vomir. Ajoute des espaces à chaque mot dans l'entrée jusqu'à ce qu'il ait la même longueur que le plus long (pour éviter les erreurs d'index pour la partie suivante), puis imprime la ce lettre de chaque mot tout en callant de 0 à la longueur de chaque chaîne.

J'ai trouvé une bien meilleure façon de le faire et j'ai supprimé 25 octets. Plutôt que de remplir les chaînes avec des espaces pour éviter l'erreur d'index, je gère l'erreur directement! Chaque fois à sa place il n'y a rien à imprimer, imprimer un seul espace avec try:print w[c],, except:print' ',. Je me suis également souvenu que je n'avais pas besoin d'espace entre une instruction print et un littéral de chaîne, ce qui permettait d'économiser un octet.

Notez que Python 2 vous permet de mélanger les tabulations et les espaces et les considère comme des niveaux d'indentation distincts. L'interpréteur Markdown de SE remplace un caractère de tabulation par quatre espaces, mais chaque ligne de ce programme, à l'exception du premier, a exactement un octet d'indentation.

Le formatage était assez facile, car les print 'something',impressions 'something 'plutôt que 'something\n'. Je l'ai fait pour chaque personnage et j'ai utilisé une printinstruction vide pour obtenir la nouvelle ligne là où j'en avais besoin.

C, 111 110 95 90 octets

Cette solution utilise des codes de contrôle VT-100 pour déplacer le curseur sur le terminal

main(int _,char**v){char*s=*++v;printf("^[7");while(*s)' '==*s?(s++,printf("^[8^[[2C^[7")):printf("%c^[[B^H",*s++);}

la ^[séquence est un espace réservé pour le seul caractère ASCII ESC, qui ne peut pas être affiché ici.

• ^[7 enregistre la position actuelle du pointeur
• ^[8 restaure la position du curseur à la position enregistrée
• ^[[2C se déplace de 2 pas vers la droite
• ^[[B se déplace d'un pas vers le bas

modifier 1: le ^[[Dcode (1 étape à gauche) VT-100 a été remplacé par un retour arrière (montré comme ^Hici, mais n'est qu'un caractère ASCII); a également oublié l'instruction "séparé par des espaces", maintenant corrigé

modifier 2:

7 caractères enregistrés en utilisant une forboucle au lieu de whileet 32au lieu de ' ':

main(int _,char**v){printf("^[7");for(char*s=*++v;*s;s++)32==*s?printf("^[8^[[2C^[7"):printf("%c^[[B^H",*s);}

8 caractères de plus enregistrés en appelant un de moins printf: l' ?:opérateur ternaire est désormais utilisé dans les printfparamètres

main(int _,char**v){printf("^[7");for(char*s=*++v;*s;s++)printf(32==*s?"^[8^[[2C^[7":"%c^[[B^H",*s);}

modifier 3:

Débarrassé de la variable locale s, travaillant directement avec argvaka v. C'est totalement hideux. Mais j'ai sauvé 4 caractères. Également remplacé ==par ^et donc changé les ?:opérandes, pour économiser 1 caractère de plus.

main(int c,char**v){printf("^[7");for(v++;**v;)printf(32^*(*v)++?"%c^[[B^H":"^[8^[[2C^[7",**v);}

Usage

$ gcc transpose.c -o transpose --std=c99
$ ./transpose 'Hello, World! My name is Foo.'
H W M n i F
e o y a s o
l r   m   o
l l   e   .
o d
, !

Version sans golf (première version)

main (int _,char**v) {
    char*s=*++v; // init s with the address of the first letter
    printf("^[7"); // save the current cursor position
    while(*s) 
        ' '==*s ? ( /* if current char is a space */
            s++,printf("^[8^[[2C^[7") /* return to the saved location, move right, save position */
        ) : /* kind of else */
            printf("%c^[[B^H",*s++); /* print the current char, move down, move left */
}

Version sans golf (dernière version)

main(int c,char**v) {
    printf("^[7");
    for(v++;**v;) /* v++: make v point to argv[1] */
        printf(     
            32^*(*v)++? /* test if **v is different from ' ', and make *v point to
                           the next char */
                "%c^[[B^H":         
                "^[8^[[2C^[7",      
            **v); /* this undefined behaviour (using *v and (*v)++ in the same expression)
                     works as "expected" with gcc 4.7.2 */
} 

J'ai répondu à cette question il y a longtemps. En fait, c'était l'une de mes premières contributions au site. Je l'ai récemment revu et j'étais un peu gêné. 112 octets?! Inacceptable. Je lui ai donc donné un autre coup:

Python 3 - 92 octets

s=input().split()
print('\n'.join(map(' '.join,zip(*[a.ljust(max(map(len,s)))for a in s]))))

Dans les 109 jours qui ont suivi la publication de cette première réponse, j'aime penser que j'ai parcouru un long chemin. Même quelque chose comme l'utilisation de Python 3 sur 2.7 ¹ ne me serait pas venu à l'esprit. Avec ce code descendu à moins de 100 octets, mon âme peut enfin se reposer et je peux passer à l'au-delà.

Explication

s=input().split()

Cela obtient une ligne stdinet crée une liste en la divisant en caractères d'espacement. Les seuls espaces susceptibles d'être dans l'entrée sont les espaces, donc cette ligne obtient une liste de mots.

Prenons la deuxième ligne de l'intérieur:

                                           max(map(len,s))

mapprend une fonction et un itérable comme arguments. Il applique la fonction à chaque élément de l'itérable et renvoie un nouvel itérable des résultats. Ici, je crée un itérable avec les longueurs de chaque mot d'entrée. maxobtient la valeur maximale d'un itérable. Cela nous donne le mot le plus long dans l'entrée.

                                  [a.ljust(              )for a in s]

Une compréhension de liste est similaire à map. Il fait quelque chose à chaque élément d'un itérable et renvoie une liste des résultats. Pour chaque mot dans l'entrée, je fais that_word.ljust(du code ). ljustest l'abréviation de "gauche justifier". Il prend un entier comme argument et ajoute des espaces à la chaîne jusqu'à ce qu'il soit aussi long.

                             zip(*                                    )

Ceci est une astuce intéressante. Dans ce contexte, *signifie "décompressez cet itérable comme arguments multiples". De cette façon, zippeut être utilisé pour transposer une matrice (par exemple zip(*[(1,2),(3,4)])-> [(1,3),(2,4)]). La seule restriction est que toutes les lignes de la matrice doivent avoir la même longueur, ou les éléments de toutes les lignes, mais les plus courts sont coupés pour correspondre.

                map(' '.join,                                          )

Nous savons déjà ce que mapça fait. La seule nouveauté ici est join, qui prend un itérable de chaînes et en fait une chaîne unique en utilisant le délimiteur auquel il est attaché. Par exemple, 'a'.join(['I', 'can', 'play', 'the', 'saxophone'])² devient Iacanaplayatheasaxophone.

print('\n'.join(                                                        ))

Cela joinprend un tas de chaînes et les sépare par des sauts de ligne. Il ne reste plus qu'à printfaire stdoutet c'est fait!

Tous ensemble maintenant:

print('\n'.join(map(' '.join,zip(*[a.ljust(max(map(len,s)))for a in s]))))

Trouver la longueur du mot le plus long de l'entrée, ajouter des espaces à chaque mot jusqu'à ce qu'ils soient de la même longueur, transposer avec l' astuce zip(*³ , utiliser joinpour séparer chaque caractère d'une ligne avec des espaces, joinencore une fois pour séparer chaque ligne avec une nouvelle ligne, et imprimez! Pas mal pour la seule ligne qui ne gère pas les entrées dans un programme de 92 octets.

<sup>1. Les caractères supplémentaires dépensés sur print()les parenthèses sont compensés par les 4 caractères que je laisse tomber de raw_input()-> input().
2. Je ne peux pas jouer du saxophone.
3 ).. Je vous en prie.</sup>

05AB1E , score 8 -20 -21 ( 30 29 octets - 50 Bonus):

|Dgi#ζεSðý}»}ë¹ε2ô€¬}ζJεðÜ}ðý

Essayez-le en ligne (entrée régulière sur une seule ligne).
Essayez-le en ligne (entrée inversée sur plusieurs lignes).

Explication:

|                     # Take the input split on newlines:
                      #  i.e. 'This is a test' → ['This is a test']
                      #  i.e. 'T i a t\nh s   e\ni     s\ns     t'
                      #    → ['T i a t','h s   e','i     s','s     t']
 Dg                   #  Duplicate this list, and take the length
                      #   i.e. ['This is a test'] → 1
                      #   i.e. ['T i a t','h s   e','i     s','s     t'] → 4
   i         }        # If the length is exactly 1:
    ¹                 #  Take the input again 
     #                #  Split the input-string by spaces
                      #   i.e. 'This is a test' → ['This','is','a','test']
      ζ               #  Zip with space-filler: Swap all rows and columns
                      #   i.e. ['This','is','a','test'] → ['Tiat','hs e','i  s','s  t']
       ε   }          #  For each item:
        S             #   Convert the item to a list of characters
                      #    i.e. 'Tiat' → ['T','i','a','t']
         ðý           #   Join them by a single space
                      #    i.e. ['T','i','a','t'] → 'T i a t'
            »         #  Join the result by newlines (and output implicitly)
    ë                 # Else:
     ε    }           #  For each item:
      2ô              #   Split it into chunks of two characters
                      #    i.e. 'h s   e' → ['h ','s ','  ','e']
        €¬            #   Take the head (first character) of each:
                      #    i.e. ['h ','s ','  ','e'] → ['h','s',' ','e']
           ζ          #  Zip with space-filler: Swap all rows and columns
                      #   i.e. [['T','i','a','t'],['h','s',' ','e'],['i',' ',' ','s'],['s',' ',' ','t']]
                      #     → [['T','h','i','s'],['i','s',' ',' '],['a',' ',' ',' '],['t','e','s','t']]
            J         #  Join each inner list to a single string
                      #   i.e. [['T','h','i','s'],['i','s',' ',' '],['a',' ',' ',' '],['t','e','s','t']]
                      #     → ['This','is  ','a   ','test']
             ε  }     #  For each item:
              ðÜ      #   Remove any trailing spaces
                      #    i.e. 'is  ' → 'is'
                 ðý   #  Join the items by a single space (and output implicitly)

Réponse originale de 8 octets:

#ζεSðý}»

Essayez-le en ligne.

Explication:

#           # Split the input-string by spaces
            #  i.e. 'This is a test' → ['This','is','a','test']
 ζ          # Zip with space-filler: Swap all rows and columns
            #  i.e. ['This','is','a','test'] → ['Tiat','hs e','i  s','s  t']
  ε   }     # For each item:
   S        #  Convert the item to a list of characters
            #   i.e. 'Tiat' → ['T','i','a','t']
    ðý      #  Join them by a single space
            #   i.e. ['T','i','a','t'] → 'T i a t'
       »    # Join the result by newlines (and output implicitly)

Mathematica 49

De toute évidence, Mathematica n'est pas le meilleur pour celui-ci:

Grid[PadRight@Characters@StringSplit@s^T]/. 0->" "

Remarque ^T(transposer) n'est qu'un seul caractère (je ne trouve pas le bon code de caractère maintenant)

Javascript, 141

a=prompt().split(' '),c=0,d=a.map(function(a){b=a.length;c=c<b?b:c});for(j=0;j<c;j++){b='';for(i in a)b+=a[i][j]?a[i][j]:' ';console.log(b);}

Échantillon

hello, world! this is code golf

hwticg
eohsoo
lri dl
lls ef
od    
,! 

GolfScript [41 octets]

' '%:x{.,x{,}%$-1=-abs' '*+}%zip{' '*}%n*

Comment ça fonctionne:

' '%:x          split text into words and store array in 'x'
{               for each word in the array:
    .,              from word's length
    x{,}%$-1=-      substract the length of the longest word in 'x'
    abs             get absolute value (maybe there is a shorter way?)
    ' '*+           add corresponding number of spaces
}%
zip{' '*}%      transpose array of words and add spaces between letters
n*              join words with a new line character

Vous pouvez voir la démo en ligne ici .

PS: Ceci est mon premier code GolfScript jamais, alors ne me jugez pas strictement;)

R, 116

z=t(plyr::rbind.fill.matrix(lapply(strsplit(scan(,""),""),t)));z[is.na(z)]=" ";invisible(apply(cbind(z,"\n"),1,cat))

Bash + coreutils, 54

eval paste `printf " <(fold -w1<<<%s)" $@`|expand -t2

Production:

$ ./transpose.sh Bonjour tout le monde! Je m'appelle Foo.
HWM ni F
eoyaso
lrmo
lle.
od       
,!       
$ 

APL: 18

⍉↑1↓¨a⊂⍨' '=a←' ',

Explication:

a ← '', placez un espace devant la chaîne et attribuez à un

'' = trouver des espaces, produit un booléen

1 ↓ ¨a⊂⍨ faire des sous-chaînes en commençant là où le booléen a 1 et déposer le premier élément de chaque (donc l'espace)

⍉ ↑ Créer une matrice à partir des sous-chaînes résultantes et l'inverser le long de la diagonale

R , 81 octets

Enregistrez un octet en stockant une nouvelle ligne sous e, qui peut être utilisée dans les deux scanappels, l'appel de comparaison et cat.

w=scan(,e,t=scan(,e<-"
"));while(any((s=substr(w,F<-F+1,F))>e))cat(pmax(" ",s),e)

Essayez-le en ligne!

K (oK) , 26 octets

Solution:

`0:{" "/'+(|/#:'x)$x}@" "\

Essayez-le en ligne!

Explication:

`0:{" "/'+(|/#:'x)$x}@" "\ / the solution
                      " "\ / split input on whitespace
   {                }@     / apply (@) lambda
                  $x       / pad ($) input (x)
          (      )         / do this together
             #:'x          / count (#:) each (')
           |/              / max
         +                 / transpose / flip
    " "/'                  / join each with whitespace
`0:                        / print to stdout

Python 2.7 - 119 106

Prise 1 - 166. L'inversion des listes était nécessaire pour faire fonctionner la pop dans l'ordre que je voulais, mais cela semblait inutile. Et quand j'ai essayé de combiner en une seule compréhension pour le plaisir, la pop a foiré les choses.

w=raw_input().split(' ');l=max([len(l) for l in w]);
q=[list(p)[::-1]for p in w]+[['\n']*l]
t=[' '+(v.pop() if v else' ')for i in range(l)for v in q]
print ''.join(t)

Prenez 2 - 119. J'ai donc changé pour l'indexation de liste simple. Cela semble toujours maladroit, en particulier le rembourrage des espaces et de nouvelles lignes.

w=raw_input().split(' ');l=max([len(l)for l in w]);print''.join([' '+(v+' '*l)[i]for i in range(l)for v in w+['\n'*l]])

Take 3 - merci à @grc

w=raw_input().split();l=max(map(len,w));print''.join(' '+(v+' '*l)[i]for i in range(l)for v in w+['\n'*l])

Python 3, 124

a=input().split()
l=max(map(len,a))
print("\n".join(" ".join(c[i] for c in [i+" "*(l-len(i)) for i in a]) for i in range(l)))

Haskell, 112

Golfé:

import Data.List
r s=unlines$transpose$p$words s
p w=m(\s->s++replicate(maximum(m l w)-l s)' ')w
m=map
l=length

Expliqué:

import Data.List

-- Break on spaces, then pad, then transpose, then join with newlines
r s=unlines$transpose$p$words s

-- Pads each String in a list of String to have the same length as the longest String
p w=m(\s->s++replicate(maximum(m l w)-l s)' ')w

-- Aliases to save space
m=map
l=length

Exemple:

*Main Data.List> putStrLn $ r "Hello Doge"
HD
eo
lg
le
o

JavaScript, 139 (156 avec sortie console.log)

s=" ",b="",a=prompt().split(s),l=0;for(var i in a){m=a[i].length;l=(l<m)?m:l;}for(i=0;i<l;i++){for(var j in a)b+=((x=a[j][i])?x:s)+s;b+="\n"}console.log(b);

Je pense que c'est aussi golfique que possible. Je viens de diviser, de trouver le plus grand mot et de transposer en conséquence, en ajoutant des espaces si le caractère n'existe pas dans les mots plus courts. Plus que la réponse JavaScript soumise précédemment, mais cette réponse ne semble pas fonctionner?

Japt -R , 5 octets

¸y¬m¸

Essayez-le

Explication

¸         :Split on spaces
 y        :Transpose
  ¬       :Split columns
   m      :Map rows
    ¸     :  Join with spaces
          :Implicitly join with newlines and output

Pyth, 8 octets

jbjL\ Cc

Essayez-le en ligne!

Assez simple. Prend les entrées entre guillemets, c.-à-d."Hello World"

jbjL\ CcQ
---------
       cQ    Chop the input Q on spaces
      C      Matrix transpose
  jL\        Join each element by spaces,
             i.e. interleave spaces between the characters of each element
jb           Join by newlines

APL (NARS), 79 caractères, 158 octets

{m←⌈/↑∘⍴¨z←(' '≠⍵)⊂,⍵⋄v←∊m{⍵\⍨∊(k⍴1)(0⍴⍨⍺-k←↑⍴⍵)}¨z⋄((2×↑⍴z)⍴1 0)\[2]⍉(↑⍴z)m⍴v}

tester:

  f←{m←⌈/↑∘⍴¨z←(' '≠⍵)⊂,⍵⋄v←∊m{⍵\⍨∊(k⍴1)(0⍴⍨⍺-k←↑⍴⍵)}¨z⋄((2×↑⍴z)⍴1 0)\[2]⍉(↑⍴z)m⍴v}
  f 'Hello, World! My name is Foo.'
H W M n i F 
e o y a s o 
l r   m   o 
l l   e   . 
o d         
, !         

Les anciennes fonctions ont une sortie non parfaite:

  {⍪¨(' '≠⍵)⊂,⍵}'Hello, World! My name is Foo.'
 H  W  M  n  i  F 
 e  o  y  a  s  o 
 l  r     m     o 
 l  l     e     . 
 o  d             
 ,  !