Il tuo compito è prendere una stringa di input di caratteri ASCII e produrre la stringa come una serie di parole verticali separate da spazi. Di seguito è mostrato un esempio:

Data la stringa:

Hello, World! My name is Foo.

l'output dovrebbe essere:

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

Verranno assegnati 10 punti bonus se il tuo programma gestisce correttamente le stringhe che devono avvolgere il terminale, che imposteremo a 80 caratteri.

50 punti se il tuo programma può fare anche il contrario!

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

Il mio primo codice golf :)

APL, 22

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

Spiegazione

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

Esempio

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

Evviva, ho battuto Perl! : D

Rubino, bonus 150-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

Rileva solo le nuove righe e applica una gestione speciale se vengono rilevate.

Eseguilo come

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

Con la stringa di esempio definita:

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

È possibile copiare la seconda istruzione sulla console del browser.

Unminified:

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

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

Il mio primo post di golf in codice: P

Perl - 92 97

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

Fa il lavoro in un modo abbastanza semplice.

K, 33

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

Esempio di input e output:

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

Pitone:

Una riga di codice per elaborare la puntura:

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

Sono sicuro che questo può essere giocato di più, ma ecco una soluzione iniziale in 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

miglioramenti:

• split ("") => split ()
• rimosso alcuni spazi extra

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 anni

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

L'algoritmo è molto semplice; solo golf. Il codice è lungo 61 byte, più 2 byte per le -naopzioni di cui ha bisogno per funzionare. Da ruby -h:

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

Esecuzione di esempio:

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

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

Qualcun altro ha già fatto meglio, ma potrei anche vomitare. Aggiunge spazi a ciascuna parola nell'input fino a quando non ha la stessa lunghezza della più lunga (per evitare errori di indice per la parte successiva), quindi stampa la clettera th di ogni parola mentre cva da 0 alla lunghezza di ogni stringa.

Ho trovato un modo molto migliore per farlo e ho eliminato 25 byte. Invece di riempire le stringhe con spazi per evitare l'errore dell'indice, gestisco direttamente l'errore! Ogni volta che non c'è niente da stampa, stampa un unico spazio al suo posto con try:print w[c],, except:print' ',. Ho anche ricordato che non ho bisogno di uno spazio tra un'istruzione print e una stringa letterale, che ha salvato un byte.

Si noti che Python 2 consente di mescolare schede e spazi e li considera livelli di rientro separati. L'interprete Markdown di SE sostituisce un carattere di tabulazione con quattro spazi, ma ogni riga di questo programma tranne il primo ha esattamente un byte di rientro.

La formattazione è stata piuttosto semplice, poiché le print 'something',stampe 'something 'anziché 'something\n'. L'ho fatto per ogni personaggio e ho usato un'istruzione vuota printper ottenere la nuova riga dove ne avevo bisogno.

C, 111 110 95 90 byte

Questa soluzione utilizza i codici di controllo VT-100 per spostare il cursore sul terminale

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

la ^[sequenza è un segnaposto per il singolo carattere ESCII ASCII, che non può essere visualizzato qui.

• ^[7 salva la posizione attuale del puntatore
• ^[8 ripristina la posizione del cursore nella posizione salvata
• ^[[2C sposta 2 passi a destra
• ^[[B si sposta di 1 passo verso il basso

modifica 1: il ^[[Dcodice VT-100 (1 passaggio a sinistra) è stato sostituito da un backspace (mostrato come ^Hqui, ma è solo un carattere ASCII); dimenticato anche l'istruzione "separato da spazi", ora risolto

modifica 2:

7 caratteri salvati utilizzando un forciclo anziché whilee 32invece di ' ':

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

Altri 8 caratteri salvati chiamando uno in meno printf: l' ?:operatore ternario viene ora utilizzato nei printfparametri

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

modifica 3:

Sbarazzarsi della variabile locale s, lavorando direttamente con argvaka v. Questo è totalmente orribile. Ma ho salvato 4 caratteri. Sostituito anche ==con ^e quindi commutato gli ?:operandi, per salvare 1 carattere in più.

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

Versione senza golf (prima versione)

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

Versione senza golf (ultima versione)

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

Ho risposto a questa domanda molto tempo fa. È stato uno dei miei primi contributi al sito, in realtà. Di recente l'ho trovato di nuovo ed ero un po 'imbarazzato. 112 byte ?! Inaccettabile. Quindi gli ho dato un altro colpo:

Python 3 - 92 byte

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

Nei 109 giorni da quando ho pubblicato la prima risposta, mi piace pensare di aver fatto molta strada. Anche qualcosa come usare Python 3 su 2.7 ¹ non mi sarebbe venuto in mente. Con questo codice ridotto a meno di 100 byte, la mia anima può finalmente riposare e posso procedere all'aldilà.

Spiegazione

s=input().split()

Questo ottiene una linea stdine crea un elenco suddividendolo in caratteri di spazi bianchi. L'unico spazio bianco probabilmente presente nell'input sono gli spazi, quindi questa riga ottiene un elenco di parole.

Prendiamo la seconda riga dall'interno:

                                           max(map(len,s))

mapaccetta una funzione e un iterabile come argomenti. Applica la funzione a ciascun elemento dell'iterabile e restituisce un nuovo iterabile dei risultati. Qui, creo un iterabile con le lunghezze di ogni parola di input. maxottiene il valore massimo da un iterabile. Questo ci porta la parola più lunga nell'input.

                                  [a.ljust(              )for a in s]

Una comprensione dell'elenco è simile a map. Fa qualcosa per ogni elemento di un iterabile e restituisce un elenco dei risultati. Per ogni parola nell'input, faccio un that_word.ljust(po 'di codice ). ljustè l'abbreviazione di "giustificazione a sinistra". Prende un numero intero come argomento e aggiunge spazi alla stringa fino a quando non è così lungo.

                             zip(*                                    )

Questo è un trucco pulito. In questo contesto, *significa "decomprimere questo iterabile come più argomenti". In questo modo, zippuò essere utilizzato per trasporre una matrice (ad es. zip(*[(1,2),(3,4)])-> [(1,3),(2,4)]). L'unica limitazione è che tutte le righe nella matrice devono avere la stessa lunghezza, oppure gli elementi di tutte le righe ma i più corti vengono tagliati per abbinarli.

                map(' '.join,                                          )

Sappiamo già cosa mapfa. L'unica cosa nuova qui è join, che prende un iterabile di stringhe e lo rende una singola stringa usando il delimitatore a cui è collegata. Ad esempio, 'a'.join(['I', 'can', 'play', 'the', 'saxophone'])² diventa Iacanaplayatheasaxophone.

print('\n'.join(                                                        ))

Questo joinrichiede un sacco di stringhe e le separa da newline. Tutto quello che resta da printfare è stdoute abbiamo finito!

Tutti insieme ora:

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

Trova la lunghezza della parola più lunga dall'input, aggiungi spazi ad ogni parola fino a quando sono della stessa lunghezza, trasponi con il trucco zip(*³ , usa joinper separare ogni carattere in una riga con spazi, di joinnuovo per separare ogni riga con una nuova riga, e stampa! Non male per l'unica linea di gestione senza input in un programma a 92 byte.

<sup>1. I caratteri extra spesi print()tra parentesi sono superati dai 4 caratteri che cado da raw_input()-> input().
2. In realtà non so suonare il sassofono.
3 ). Prego.</sup>

05AB1E , segnare 8 -20 -21 ( 30 29 byte - 50 bonus):

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

Provalo online (normale input a riga singola).
Provalo online (ingresso invertito multilinea).

Spiegazione:

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

Risposta originale a 8 byte:

#ζεSðý}»

Provalo online.

Spiegazione:

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

Chiaramente Mathematica non è la migliore per questo:

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

Nota ^T(trasporre) è solo un carattere (non riesco a trovare il codice carattere giusto ora)

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

Campione

hello, world! this is code golf

hwticg
eohsoo
lri dl
lls ef
od    
,! 

GolfScript [41 byte]

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

Come funziona:

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

Puoi vedere la demo online qui .

PS: Questo è il mio primo codice GolfScript di sempre, quindi non giudicarmi rigorosamente;)

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

Produzione:

$ ./transpose.sh Ciao, mondo! Mi chiamo Foo.
HWM ni F
eoyaso
lrmo
Lle.
od       
,!       
$ 

APL: 18

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

Spiegazione:

a ← '', metti uno spazio davanti alla stringa e assegna a a

'' = trova spazi, produce un valore booleano

1 ↓ ¨ a⊂⍨ crea sottostringhe a partire da dove il booleano ha 1 e rilascia il primo elemento di ciascuno (quindi lo spazio)

↑ ↑ Crea matrice dalle sottostringhe risultanti e invertila lungo la diagonale

R , 81 byte

Salvare un byte memorizzando una nuova riga come e, che può essere utilizzata in entrambe le scanchiamate, la chiamata di confronto e cat.

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

Provalo online!

K (oK) , 26 byte

Soluzione:

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

Provalo online!

Spiegazione:

`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

Prendi 1 - 166. L'inversione delle liste era necessaria per far funzionare il pop nell'ordine che desideravo, ma questo sembrava dispendioso. E quando ho provato a combinare in un'unica comprensione per divertimento, il pop ha rovinato tutto.

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)

Prendi 2 - 119. Quindi sono passato alla semplice indicizzazione dell'elenco. Sembra comunque goffo, soprattutto l'imbottitura di spazi e nuove linee.

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

Prendi 3 - grazie 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

golfed:

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

Ha spiegato:

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

Esempio:

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

JavaScript, 139 (156 con output 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);

Penso che questo sia il più golfato possibile. Ho appena diviso, trovato la parola più grande e trasposto di conseguenza, aggiungendo spazi se il carattere non esiste nelle parole più brevi. Più della precedente risposta JavaScript inviata, ma quella risposta non sembra funzionare?

Japt -R , 5 byte

¸y¬m¸

Provalo

Spiegazione

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

Pyth, 8 byte

jbjL\ Cc

Provalo online!

Abbastanza diretto. Prende l'input racchiuso tra virgolette, ad es"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 caratteri, 158 byte

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

test:

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

La vecchia funzione ha un output non perfetto:

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