Sua tarefa é pegar uma sequência de caracteres de entrada de caracteres ascii e produzir a sequência como uma série de palavras verticais separadas por espaços. Um exemplo é mostrado abaixo:

Dada a sequência:

Hello, World! My name is Foo.

a saída deve ser:

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

10 pontos de bônus serão concedidos se o seu programa manipular corretamente as strings que precisam envolver o terminal, que definiremos com 80 caracteres.

50 pontos se o seu programa também puder fazer o contrário!

J, 15

|:>'\S+| 'rxall

Uso:

   |:>'\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";}

Meu primeiro código de golfe :)

APL, 22

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

Explicação

{              ⍵=' '}   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

Exemplo

      {⍉⊃⍵⊂⍨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        
, !        

Ruby, 91 87

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

Viva, eu venci o Perl! : D

Rubi, bônus de 150 a 50 = 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

Ele apenas detecta novas linhas e aplica tratamento especial se elas forem detectadas.

Execute como

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);

Com a sequência de exemplo definida:

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);

Você pode copiar a segunda instrução no console do seu navegador.

Desminificado:

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);

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

Meu primeiro post de código de golfe: P

Perl - 92 97

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

Faz o trabalho de uma maneira bastante direta.

K, 33

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

Exemplo de entrada e saída:

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        "
", !        "

Pitão:

Uma linha de código para processar a picada:

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

Tenho certeza de que isso pode ser mais eficaz, mas aqui está uma solução inicial em 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

Melhorias:

• split ("") => split ()
• removeu alguns espaços extras

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"""

Ruby, 63

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

O algoritmo é muito direto; só jogava golfe. O código tem 61 bytes, mais 2 bytes para as -naopções necessárias para o trabalho. De ruby -h:

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

Exemplo de execução:

$ 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 bytes

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

Alguém já fez isso melhor, mas é melhor que eu vomite isso. Adiciona espaços a cada palavra na entrada até que ela tenha o mesmo comprimento que a mais longa (para evitar erros de índice para a próxima parte) e, em seguida, imprime a cletra da cada palavra enquanto cpassa de 0 ao comprimento de cada sequência.

Eu vim com uma maneira muito melhor de fazer isso e recortei 25 bytes. Em vez de preencher cadeias de caracteres com espaços para evitar o erro de índice, eu trato o erro diretamente! Sempre que não há nada para impressão, imprimo um único espaço em seu lugar com try:print w[c],, except:print' ',. Lembrei-me também de que não preciso de um espaço entre uma instrução print e uma string literal, que salvou um byte.

Observe que o Python 2 permite combinar guias e espaços e os considera níveis separados de indentação. O intérprete Markdown do SE substitui um caractere de tabulação por quatro espaços, mas todas as linhas deste programa, exceto a primeira, têm exatamente um byte de recuo.

A formatação foi bem fácil, pois print 'something',imprime 'something 'e não 'something\n'. Fiz isso para cada personagem e usei uma printdeclaração vazia para obter a nova linha onde eu precisava.

C, 111 110 95 90 bytes

Esta solução usa códigos de controle VT-100 para mover o cursor no terminal

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

a ^[sequência é um espaço reservado para o único caractere ASCII ESC, que não pode ser exibido aqui.

• ^[7 salva a posição atual do ponteiro
• ^[8 restaura a posição do cursor na posição salva
• ^[[2C move 2 passos para a direita
• ^[[B move-se 1 passo para baixo

edit 1: o ^[[Dcódigo VT-100 (1 passo à esquerda) foi substituído por um backspace (mostrado ^Haqui, mas é apenas um caractere ASCII); também esqueceu a instrução "separados por espaços", agora corrigida

editar 2:

7 caracteres salvos usando um forloop em vez de whilee em 32vez de ' ':

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

Mais 8 caracteres salvos chamando um a menos printf: o ?:operador ternário agora é usado nos printfparâmetros

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

editar 3:

Livre-se da variável local s, trabalhando diretamente com o argvaka v. Isso é totalmente hediondo. Mas salvou 4 caracteres. Também substituído ==por ^e, portanto, comutado os ?:operandos, para economizar mais 1 caractere.

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

Uso

$ 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
, !

Versão sem golfe (primeira versão)

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 */
}

Versão sem golfe (última versão)

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 */
} 

Eu respondi a essa pergunta há muito tempo. Foi uma das minhas primeiras contribuições ao site, na verdade. Recentemente, me deparei com isso novamente e fiquei meio envergonhada. 112 bytes ?! Inaceitável. Então eu dei outra chance:

Python 3-92 bytes

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

Nos 109 dias desde que publiquei a primeira resposta, gosto de pensar que percorri um longo caminho. Mesmo algo como usar Python 3 acima de 2,7 ¹ não teria me ocorrido. Com esse código abaixo de 100 bytes, minha alma pode finalmente descansar e eu posso prosseguir para a vida após a morte.

Explicação

s=input().split()

Isso obtém uma linha stdine cria uma lista dividindo-a em caracteres de espaço em branco. O único espaço em branco que provavelmente está na entrada são os espaços, portanto essa linha obtém uma lista de palavras.

Vamos pegar a segunda linha de dentro para fora:

                                           max(map(len,s))

mapassume uma função e um iterável como argumentos. Aplica a função a cada elemento do iterável e retorna uma nova iterável dos resultados. Aqui, crio um iterável com os comprimentos de cada palavra de entrada. maxobtém o valor máximo de um iterável. Isso nos dá a palavra mais longa na entrada.

                                  [a.ljust(              )for a in s]

Uma compreensão de lista é semelhante a map. Faz algo para todos os elementos de uma iterável e retorna uma lista dos resultados. Para cada palavra na entrada, eu faço that_word.ljust(um código ). ljusté a abreviação de "justificar à esquerda". Ele usa um número inteiro como argumento e adiciona espaços à string até que ela seja longa.

                             zip(*                                    )

Este é um truque legal. Nesse contexto, *significa "descompacte este iterável como vários argumentos". Dessa forma, zippode ser usado para transpor uma matriz (por exemplo, zip(*[(1,2),(3,4)])-> [(1,3),(2,4)]). A única restrição é que todas as linhas da matriz precisam ter o mesmo comprimento ou elementos de todas as linhas, mas os menores são cortados para corresponder.

                map(' '.join,                                          )

Nós já sabemos o que mapfaz. A única coisa nova aqui é join, que pega uma iterável de strings e a transforma em uma única string usando o delimitador ao qual está anexado. Por exemplo, 'a'.join(['I', 'can', 'play', 'the', 'saxophone'])² se torna Iacanaplayatheasaxophone.

print('\n'.join(                                                        ))

Isso joinpega um monte de strings e os separa por novas linhas. Tudo o que resta é printfazer stdoute pronto!

Todos juntos agora:

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

Encontre o comprimento da palavra mais longa da entrada, acrescente espaços a cada palavra até que tenham o mesmo comprimento, transponha com o truque zip(*³ , use joinpara separar cada caractere em uma linha de espaços, joinnovamente para separar cada linha com uma nova linha, e imprima! Nada mal para a única linha sem manipulação de entrada em um programa de 92 bytes.

<sup>1. Os caracteres extras gastos print()entre parênteses são superados pelos 4 caracteres que eu solto de raw_input()-> input().
2. Na verdade, não consigo tocar saxofone.
3 ). Seja bem-vindo.</sup>

05AB1E , pontuação 8 -20 -21 ( 30 29 bytes - bônus 50):

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

Experimente on-line (entrada comum de linha única).
Experimente on-line (entrada reversa de várias linhas).

Explicação:

|                     # 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)

Resposta original de 8 bytes:

#ζεSðý}»

Experimente online.

Explicação:

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

Claramente, o Mathematica não é o melhor para este:

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

A nota ^T(transposição) é apenas um caractere (não consigo encontrar o código correto agora)

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);}

Amostra

hello, world! this is code golf

hwticg
eohsoo
lri dl
lls ef
od    
,! 

GolfScript [41 bytes]

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

Como funciona:

' '%: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

Você pode ver a demonstração online aqui .

PS: Este é o meu primeiro código GolfScript de todos os tempos, então não me julgue estritamente;)

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

Resultado:

$ ./transpose.sh Olá, mundo! Meu nome é Foo.
HWM ni F
eoyaso
lrmo
lle.
od       
,!       
$ 

APL: 18

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

Explicação:

a ← '', coloque um espaço na frente da string e atribua a um

'' = encontrar espaços, produz um valor booleano

1 ↓ ¨a⊂⍨ cria substrings começando onde o booleano tem 1's e solta o primeiro elemento de cada um (assim o espaço)

Make ↑ Faça a matriz com as substrings resultantes e inverta-a ao longo da diagonal

R , 81 bytes

Salve um byte armazenando uma nova linha como e, que pode ser usada nas duas scanchamadas, na chamada de comparação e cat.

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

Experimente online!

K (oK) , 26 bytes

Solução:

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

Experimente online!

Explicação:

`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

Pegue 1 - 166. A reversão das listas era necessária para fazer o pop funcionar na ordem que eu queria, mas isso parecia um desperdício. E quando tentei combinar em uma única compreensão por diversão, o pop estragou tudo.

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)

Pegue 2 - 119. Então mudei para uma indexação de lista simples. Ainda parece desajeitado, especialmente o preenchimento de espaços e novas linhas.

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]])

Tome 3 - graças a @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

Golfe:

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

Explicado:

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

Exemplo:

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

JavaScript, 139 (156 com saída 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);

Eu acho que isso é o mais golfe possível. Acabei de dividir, encontrar a maior palavra e transpor de acordo, adicionando espaços se o caractere não existir nas palavras mais curtas. Mais do que a resposta JavaScript enviada anteriormente, mas essa resposta parece não funcionar?

Japonês -R , 5 bytes

¸y¬m¸

Tente

Explicação

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

Pitão, 8 bytes

jbjL\ Cc

Experimente online!

Bem direto. Pega a entrada entre aspas, ou seja,"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 caracteres, 158 bytes

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

teste:

  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         
, !         

A função antiga possui saída não perfeita:

  {⍪¨(' '≠⍵)⊂,⍵}'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             
 ,  !