Di 'che ho un testo come questo (ogni parola su una riga, senza spazi)

Programming
Puzzles
&
Code
Golf

Non ha senso! Sfida totalmente le leggi della fisica.

La tua sfida è porre rimedio a questa situazione impossibile e comprimere il testo in questo modo:

P
Prog
&uzz
Coderam
Golflesming

In modo che non vi sia spazio vuoto sotto alcun personaggio ma i personaggi mantengono il loro ordine verticale.

L'obiettivo è soddisfare i requisiti ma utilizzare il minor numero di byte di codice sorgente possibile.

Pyth, 10 byte

jb_.T.T_.z

Provalo online nel compilatore / Executor Pyth .

Idea

Siamo in grado di ottenere l'output desiderato applicando quattro semplici trasformazioni:

1. Invertire l'ordine delle linee:

   Golf
   Code
   &
   Puzzles
   Programming
   

2. Trasporre righe e colonne:

   GC&PP
   oour
   ldzo
   fezg
   lr
   ea
   sm
   m
   i
   n
   g
   

   Questo top giustifica, comprimendo le colonne originali.

3. Trasporre righe e colonne:

   Golflesming
   Coderam
   &uzz
   Prog
   P
   

4. Invertire l'ordine delle linee:

   P
   Prog
   &uzz
   Coderam
   Golflesming
   

Codice

        .z  Read the input as a list of strings, delimited by linefeeds.
       _    Reverse the list.
   .T.T     Transpose the list twice.
  _         Reverse the list.
jb          Join its strings; separate with linefeeds.

Haskell, 62 byte

import Data.List
p=reverse;o=transpose
f=unlines.p.o.o.p.lines

Sono molto maturo

Python 2, 104 byte

l=[]
for x in input().split('\n'):n=len(x);l=[a[:n]+b[n:]for a,b in zip(l+[x],['']+l)]
print'\n'.join(l)

Un algoritmo iterativo one-pass. Esaminiamo ogni riga in ordine, aggiornando l'elenco ldelle righe per l'output. La nuova parola spinge efficacemente dal basso, spostando tutte le lettere sopra di essa di uno spazio. Ad esempio, nel caso di test

Programming
Puzzles
&
Code
Golf

dopo aver fatto fino a Code, abbiamo

P
Prog
&uzzram
Codelesming

e quindi aggiungendo Golfrisultati in

P
Prog
&uzz
Coderam
Golflesming

che possiamo vedere come la combinazione di due pezzi

P     |
Prog  |
&uzz  |
Code  | ram
Golf  | lesming

dove è stato spostato il primo pezzo golf. Eseguiamo questo spostamento con una zipdell'elenco di output con l'elemento alla fine (lato sinistro) e la precedenza dell'elenco di output con una riga vuota (lato destro), tagliando ogni parte alla lunghezza del nuovo elemento.

Potrebbe invece sembrare più naturale iterare all'indietro, lasciando cadere nuove lettere dall'alto, ma il mio tentativo è risultato più lungo.

Per un confronto, ecco un approccio zip/ filter, map(None,*x)usato per iziplongest(109 byte):

f=lambda z:[''.join(filter(None,x))for x in map(None,*z)]
lambda x:'\n'.join(f(f(x.split('\n')[::-1]))[::-1])

CJam, 11 byte

qN/W%zzW%N*

Provalo online nell'interprete CJam .

Come funziona

L'idea è la stessa della mia risposta Pyth .

q           e# Read from STDIN.
 N/         e# Split at linefeeds.
   W%       e# Reverse the resulting array.
     zz     e# Transpose it twice.
       W%   e# Reverse the resulting array.
         N* e# Join its strings; separate with linefeeds.

JavaScript (ES6), 146

(Le 2 nuove righe all'interno delle stringhe del modello sono significative e contate)

L'idea di @Dennis implementata in JavaScript. La lunga funzione S esegue la trasposizione riga per riga e carattere per carattere, lasciando il risultato nella tmatrice.

a=>(S=z=>{for(t=[];z.join``;t.push(w))for(w='',n=z.length;n--;z[n]=z[n].slice(1))w+=z[n][0]||''},S(a.split`
`),S(t.reverse()),t.reverse().join`
`)

Meno golf all'interno dello snippet (prova in Firefox)

F=a=>(
  S=z=>{
    for(t=[];z.join``;t.push(w))
      for(w='',n=z.length;n--;z[n]=z[n].slice(1))
        w+=z[n][0]||''
  },
  S(a.split`\n`),
  S(t.reverse()),
  t.reverse().join`\n`
)

#I,#O { margin:0; width: 200px; height:100px; border: 1px solid #ccc }

<table><tr><td>
Input<br><textarea id=I>Programming
Puzzles
&
Code
Golf
</textarea></td><td>
Output<pre id=O></pre>
</td></tr></table>  
<button onclick='O.innerHTML=F(I.value)'>go</button>

R, 223 byte

function(x){a=apply(do.call(rbind,lapply(p<-strsplit(strsplit(x,"\n")[[1]],""),function(x)c(x,rep(" ",max(lengths(p))-length(x))))),2,function(x)c(x[x==" "],x[x!=" "]));for(i in 1:nrow(a))cat(a[i,][a[i,]!=" "],"\n",sep="")}

Questo è un modo assurdamente lungo e ingenuo di farlo.

Ungolfed:

f <- function(x) {
    # Start by spliting the input into a vector on newlines
    s <- strsplit(x, "\n")[[1]]

    # Create a list consisting of each element of the vector
    # split into a vector of single characters
    p <- strsplit(s, "")

    # Pad each vector in p to the same length with spaces
    p <- lapply(p, function(x) c(x, rep(" ", max(lengths(p)) - length(x))))

    # Now that the list has nice dimensions, turn it into a matrix
    d <- do.call(rbind, p)

    # Move the spaces to the top in each column of d
    a <- apply(d, 2, function(x) c(x[x == " "], x[x != " "]))

    # Print each row, omitting trailing whitespace
    for (i in 1:nrow(a)) {
        cat(a[i, ][a[i, ] != " "], "\n", sep = "")
    }
}

Puoi provarlo online .

Matlab / Octave, 99 byte

function f(s)
c=char(strsplit(s,[10 '']));[~,i]=sort(c>32);[m,n]=size(c);c(i+repmat((0:n-1)*m,m,1))

Esempio :

Definisci una stringa di input in una variabile, ad esempio s. 10è il carattere di avanzamento riga:

>> s = ['Programming' 10 'Puzzles' 10 '&' 10 'Code' 10 'Golf'];

Funzione di chiamata fcon input s:

>> f(s)
ans =
P          
Prog       
&uzz       
Coderam    
Golflesming

Oppure provalo online (grazie a @beaker per aiuto con l'interprete Octave online)

JavaScript ES6, 119 byte

F=s=>(C=o=>--a.length?C(a.reduce((p,c,i)=>c+p.slice((a[i-1]=p.slice(0,c.length)).length)))+`
`+o:o)(a=(s+`
`).split`
`)

Qui è ungolfed e in ES5 con commenti che spiegano come funziona:

function F(s) {
  var arr = (s+'\n').split('\n'); // Create an array of words and append an empty member
  return (function C(output) {
    return --arr.length ? // Remove the last item from the array
      C(arr.reduce(function(p,c,i) { // If the array still has length reduce it to a string and recurse
        var intersection = (arr[i-1] = p.slice(0, c.length)) // Overwrite the previous word with the part that intersects the current word
        return c + p.slice(intersection.length) // Add the part of the previous word that doesn't intersect to the current value
      })) + '\n' + output : output // Add the last level of recursions output on to the end of this
  })(arr);
}

input.addEventListener('input', updateOutput, false);

function updateOutput() {
  var oldLength = input.value.length;
  var start = this.selectionStart;
  var end = this.selectionEnd;
  input.value = input.value.split(/ +/).join('\n');
  var newLength = input.value.length;
  input.setSelectionRange(start, end + (newLength - oldLength));
  output.value = F(input.value).trim();
}

updateOutput();

textarea {
  width: 50%;
  box-sizing: border-box;
  resize: none;
  float: left;
  height: 10em;
}

label {
  width: 50%;
  float: left;
}

<p>Type in the input box below, spaces are automatically converted to newlines and the output updates as you type</p>
<label for="input">Input</label>
<label for="output">Output</label>
<textarea id="input">
Type inside me :)
</textarea>
<textarea id="output" disabled>
</textarea>

APL (Dyalog Extended) , 13 11 byte ^SBCS

-2 con le mie estensioni a Dyalog APL.

Funzione tacita anonima, acquisizione e restituzione di una matrice di caratteri.

~∘' '⍤1⍢⍉⍢⊖

Provalo online!

~ rimuove
∘ gli
' ' spazi
⍤ dalle
1 righe (lit. sotto-array 1D)
⍢ mentre
⍉ trasposti
⍢ mentre
⊖ capovolti

R, 190 178 175 byte

Probabilmente c'è ancora spazio per giocare a golf in questo. Probabilmente un paio di operazioni inutili lì dentro

l=lapply;s=substring;C=rbind;d=do.call;cat(C(d(C,l(apply(d(C,l(a<-scan(,''),s,1:(w=max(nchar(a))),1:w))[(h=length(a)):1,],2,paste0,collapse=''),s,1:h,1:h))[,h:1],'\n'),sep='')

Ungolfed e spiegato

a<-scan(,'')    # get STDIN
h<-length(a)    # number of lines
w=max(nchar(a)) # length of longest line
M<-lapply(a,substring,1:w,1:w)   # create a list of split strings with empty chars
M<-do.call(rbind,M)[h:1,]        # turn it into a matrix with line order reversed
M<-apply(M,1,paste0,collapse='') # paste together the columns
M<-lapply(M,substring,1:h,1:h)   # split them back up
M<-do.call(rbind,M)[,h:1]        # reform a matrix
M<-rbind(M,'\n')                 # add some carriage returns
cat(M,sep='')   # output with seperators

Prova. È interessante notare che a causa del modo in cui funziona la scansione, l'intera frase può essere inserita con spazi e dare comunque l'output come specificato.

> l=lapply;s=substring;C=rbind;d=do.call;cat(C(d(C,l(apply(d(C,l(a<-scan(,''),s,1:(w=max(nchar(a))),1:w))[(h=length(a)):1,],2,paste0,collapse=''),s,1:h,1:h))[,h:1],'\n'),sep='')
1: Programming
2: Puzzles
3: &
4:     Code
5: Golf
6: 
Read 5 items
P
Prog
&uzz
Coderam
Golflesming
> l=lapply;s=substring;C=rbind;d=do.call;cat(C(d(C,l(apply(d(C,l(a<-scan(,''),s,1:(w=max(nchar(a))),1:w))[(h=length(a)):1,],2,paste0,collapse=''),s,1:h,1:h))[,h:1],'\n'),sep='')
1: Programming Puzzles & Code Golf beta
7: 
Read 6 items
P
Prog
&uzz
Code
Golfram
betalesming
>   

STATA, 323 byte

Accetta input in un file chiamato ab Funziona solo per un massimo di 24 caratteri ora. Si aggiornerà più tardi per farlo funzionare con più. Inoltre, non funziona nel compilatore online. Richiede il compilatore non libero.

gl l=24/
forv x=1/$l{
gl a="$a str a`x' `x'"
}
infix $a using a.b
gl b=_N
forv k=1/$l{
gen b`k'=0
qui forv i=$b(-1)1{
forv j=`i'/$b{
replace b`k'=1 if _n==`j'&a`k'==""
replace a`k'=a`k'[_n-1] if _n==`j'&a`k'==""
replace a`k'="" if _n==`j'-1&b`k'[_n+1]==1
replace b`k'=0
}
}
}
forv i=1/$b{
forv k=1/$l{
di a`k'[`i'] _c
}
di
}

Modifica: spostato silenziosamente (per sopprimere l'output) nel loop stesso da ciascuna istruzione nel loop, salvando 8 byte.

R, 171 byte

S=scan(,"");while(any((D<-diff(N<-sapply(S,nchar)))<0)){n=max(which(D<0));S[n+1]=paste0(S[n+1],substr(S[n],N[n]+D[n]+1,N[n]));S[n]=substr(S[n],1,N[n]+D[n])};cat(S,sep="\n")

Con newline e rientro:

S=scan(,"") #Takes input from stdin
while(any((D<-diff(N<-sapply(S,nchar)))<0)){
    n=max(which(D<0))
    S[n+1]=paste0(S[n+1],substr(S[n],N[n]+D[n]+1,N[n]))
    S[n]=substr(S[n],1,N[n]+D[n])
}
cat(S,sep="\n")

Uso:

> S=scan(,"");while(any((D<-diff(N<-sapply(S,nchar)))<0)){n=max(which(D<0));S[n+1]=paste0(S[n+1],substr(S[n],N[n]+D[n]+1,N[n]));S[n]=substr(S[n],1,N[n]+D[n])};cat(S,sep="\n")
1: Programming
2: Puzzles
3: &
4: Code
5: Golf
6: 
Read 5 items
P
Prog
&uzz
Coderam
Golflesming

Gelatina , 6 byte (non competitiva)

ỴṚZZṚY

Provalo online!

Come funziona

L'idea è la stessa della mia risposta Pyth .

ỴṚZZṚY  Main link. Argument: s (string)

Ỵ       Split at linefeeds.
 Ṛ      Reverse the order of the lines.
  ZZ    Zip/transpose twice.
    Ṛ   Reverse the order of the lines.
     Y  Join, separating by linefeeds.

Turtlèd , 72 byte, non competitivo

Abbastanza sicuro che potrei cambiare approccio per salvare byte, ma più tardi.

: p Esolang non golf batte battute regolari: p

La cosa strana di Turtlèd è che è stato originariamente realizzato dopo una discussione sulle lingue di ASCII, ma in realtà sembra essere il migliore in questo tipo di sfide

Turtlèd non può accettare input newline ma per input multipli, e questo richiede un solo input: termina ogni parola con uno spazio, incluso l'ultimo.

!l[*,+r_][ l]ur[*,[ -.]+.[ r{ d}u+.]-.[ -.]{ l}[ l]r[ u]_]' d[ d]u[ ' r]

Provalo online!

Spiegazione:

!                          Take string input
 l                         Move left, off the asterisk at the start of grid
  [*    ]                  Until cell is *
    ,+r_       write *, string pointer+=1, move right, write * if pointed char is last char
         [ l]ur    move left until finding a space, move up and right
               [*                                        ]     Until cell is *
                 ,                               write *
                  [   ]             until cell is [space]
                    -.               decrement string pointer, write pointed char
                       +.           increment and write string pointer
                         [         ] until cell is [space]
                           r{ d}     move right, move down until finding nonspace
                                u+.  move up, string pointer+=1 and write pointed char
                                    -.      decrement string pointer and write pointed char
                                      [   ]  until cell is [space]
                                        -.  string pointer-=1 and write pointed char
                                           { l}   move left until finding nonspace
                                               [ l]   move left until finding space
                                                   r   move right
                                                    [ u]  move up until finding space
                                                        _  write * if pointed char is last char
                                                          (if it is written, loop ends)

                                                          ' d[ d]u[ ' r] just cleanup

Perl, 133 byte

Questa è stata una di quelle sfide che sono cambiate nella mia testa da essere troppo difficile, ad essere facile, ad essere molto più codice di quanto mi aspettassi ... Non sono particolarmente soddisfatto dell'approccio, sono sicuro che ci sia un modo molto migliore per ridurre il print pop@F...bit forse usando -no solo regex puro, ma non riesco ad arrivarci proprio ora ... Inizialmente stavo usando say, ma penso che dovrei segnare un punteggio più alto ( use 5.01) a causa di $'.

@F=(/.+/g,@F)for<>;$_%=$#F,($x=length$F[$_++])<length$F[$_]&&($F[$_]=~/.{$x}/,$F[$_-1].=$',$F[$_]=$&)for 0..1e2;print pop@F,$/while@F

uso

Salva come vertically-collapse-text.pl.

perl vertically-collapse-text.pl <<< 'Programming
Puzzles
&
Code
Golf'
P
Prog
&uzz
Coderam
Golflesming

SmileBASIC, 90 byte

X=RND(50)Y=RND(20)G=CHKCHR(X,Y+1)<33LOCATE X,Y+G?CHR$(CHKCHR(X,Y));
LOCATE X,Y?" "*G
EXEC.

Applica la gravità a tutto il testo nella console. Non sono sicuro se questo sia valido o se devo usare un array di stringhe.

Rubino, 99 82 byte

Arrivarci...

f=->a,i=-1{a.map{|l|i+=1;(0...l.size).map{|c|a.map{|x|x[c]}.join[~i]}*''}.reverse}

Una tentata spiegazione:

f=->a,i=-1{a.map{|l|i+=1; # For each line `l` with index `i` in string array `a`
(0...l.size).map{|c|        # For each column `c` in `l`
a.map{|x|x[c]}.join           # Make a string of non-nil characters `c` across `a`...
[~i]                          # ...and grap the `i`th character *from the end*, if any
}*''}.reverse}              # Join the characters grabbed from each column and reverse the result

Eseguilo in questo modo:

a = %w[
  Programming
  Puzzles
  &
  Code
  Golf
]
puts f[a]

K, 30

{+{(-#x)$x@&~^x}'+x@\:!|/#:'x}

.

k){+{(-#x)$x@&~^x}'+x@\:!|/#:'x}("Programming";"Puzzles";,"&";"Code";"Golf")
"P          "
"Prog       "
"&uzz       "
"Coderam    "
"Golflesming"

Spiegazione

x@\:!|/#:'x estende ogni stringa per creare una matrice quadrata di caratteri.

k){x@\:!|/#:'x}("Programming";"Puzzles";,"&";"Code";"Golf")
"Programming"
"Puzzles    "
"&          "
"Code       "
"Golf       "

+ lo traspone

k){+x@\:!|/#:'x}("Programming";"Puzzles";,"&";"Code";"Golf")
"PP&CG"
"ru oo"
"oz dl"
"gz ef"
"rl   "
"ae   "
"ms   "
"m    "
"i    "
"n    "
"g    "

{(-#x)$x@&~^x} rimuoverà tutti gli spazi da una stringa e quindi riempirà la stringa della sua lunghezza originale

k){(-#x)$x@&~^x}"a  b  c   de  f"
"         abcdef"

Applicare quella funzione a ciascuna delle stringhe trasposte, quindi capovolgere l'output per ottenere il risultato

k){+{(-#x)$x@&~^x}'+x@\:!|/#:'x}("Programming";"Puzzles";,"&";"Code";"Golf")
"P          "
"Prog       "
"&uzz       "
"Coderam    "
"Golflesming"

pb - 310 byte

^w[B!0]{w[B=32]{vb[1]^b[0]}>}b[1]vb[1]>b[2]<[X]w[B!2]{t[T+B]b[0]>}b[0]v[T]w[X!-1]{b[1]<}b[1]vb[1]w[B!0]{w[B!0]{^w[B!0]{>}<<<<^[Y+1]w[B!0]{<}>t[B]b[0]w[B!1]{v}v<[X]w[B!0]{>}b[T]}b[0]vb[1]^w[X!0]{<vb[1]^t[B]b[0]^w[B!0]{^}b[T]w[B!0]{v}}vw[B!0]{^^w[B!0]{>}<b[0]vvw[B=0]{<}b[0]<[X]}^^>w[B=0]{vb[1]}v<<}>>^b[0]^<b[0]

Che disastro. Ricordo a malapena qualcosa su come funziona.

A causa del modo in cui funziona l'input di pb (una singola riga tutta in una volta), è necessario utilizzare spazi anziché newline nell'input. Se l'interprete non fosse spazzatura e potessi includere newline nell'input, l'unica modifica sarebbe [B=32]all'inizio diventando [B=10].

Sto lavorando ad un aggiornamento di pbi (l'interprete) che ripulirà gli elementi visivi se vuoi guardare il programma in esecuzione. Ha ancora bisogno di molto lavoro, ma nel frattempo puoi guardare questo programma su YouTube .

J, 17 byte

-.&' '"1&.(|:@|.)

Soluzione abbastanza piacevole.

Spiegazione:

-.&' '"1&.(|:@|.)  input: list of strings y
              |.   reverse lines
           |:@     then transpose
-.&' '"1           remove blanks from columns
        &.         and undo the inside
           |:@|.   (that is, transpose and reverse again.)

Spiegazione del test case

   s
Programming
Puzzles
&
Code
Golf
   |.s
Golf
Code
&
Puzzles
Programming
   |:|.s
GC&PP
oo ur
ld zo
fe zg
   lr
   ea
   sm
    m
    i
    n
    g
   -.&' '"1|:|.s
GC&PP
oour
ldzo
fezg
lr
ea
sm
m
i
n
g
   |.-.&' '"1|:|.s
g
n
i
m
sm
ea
lr
fezg
ldzo
oour
GC&PP
   |.|:-.&' '"1|:|.s
P
Prog
&uzz
Coderam
Golflesming
   (-.&' '"1)&.(|:@|.)s
P
Prog
&uzz
Coderam
Golflesming
   -.&' '"1&.(|:@|.)s
P
Prog
&uzz
Coderam
Golflesming

Casi test

   f =: -.&' '"1&.(|:@|.)
   f
-.&' '"1&.(|:@|.)
   f >'Programming';'Puzzles';'&';'Code';'Golf'
P
Prog
&uzz
Coderam
Golflesming
   g =: [: > [: <;._1 '|'&,
   g 'Programming|Puzzles|&|Code|Golf'
Programming
Puzzles
&
Code
Golf
   f g 'Programming|Puzzles|&|Code|Golf'
P
Prog
&uzz
Coderam
Golflesming
   F =: f @ g
   F &. > 'Programming|Puzzles|&|Code|Golf' ; '1|23|456|7890' ; '1234|567|89|0'
+-----------+----+----+
|P          |1   |1   |
|Prog       |23  |52  |
|&uzz       |456 |863 |
|Coderam    |7890|0974|
|Golflesming|    |    |
+-----------+----+----+

In realtà , 13 byte

Questo utilizza l'algoritmo descritto nella risposta Jelly di Dennis . Input e output sono entrambi elenchi di stringhe. Sfortunatamente, la funzione di trasposizione incorporata non funziona molto bene se le liste o le stringhe interne non sono tutte della stessa lunghezza, il che in un certo senso sconfiggerebbe il punto di collasso verticale. Suggerimenti di golf benvenuti. Provalo online!

R2`;i(lZ♂Σ`nR

Ungolfing

          Implicit input s.
R         Reverse s.
2`...`n   Run the following function twice.
  ;i        Duplicate and flatten onto the stack.
  (l        Get the number of strings in the list.
  Z         Zip len strings together, which results in a list of lists of characters.
  ♂Σ        Sum each list of characters, which essentially joins them together.
           This function essentially transposes
R         Reverse the result.
          Implicit return.

Racchetta 312 byte

(let((lr list-ref)(ls list-set)(sl string-length)(ss substring)(l(string-split s)))(let p((ch #f))
(for((i(-(length l)1)))(define s(lr l i))(define r(lr l(+ 1 i)))(define n(sl s))(define m(sl r))
(when(> n m)(set! l(ls l i(ss s 0 m)))(set! l(ls l(+ 1 i)(string-append r(ss s m n))))(set! ch #t)))(if ch(p #f)l)))

Ungolfed:

(define (f s)
  (let ((lr list-ref)
        (ls list-set)
        (sl string-length)
        (ss substring)
        (l (string-split s)))
    (let loop ((changed #f))
      (for ((i (sub1 (length l))))
        (define s (lr l i))
        (define r (lr l (add1 i)))
        (define n (sl s))
        (define m (sl r))
        (when (> n m)
          (set! l (ls l i (ss s 0 m)))
          (set! l (ls l (add1 i)(string-append r (ss s m n))))
          (set! changed #t)))
      (if changed (loop #f)
          l))))

test:

(f "Programming Puzzles & Code Golf")

Produzione:

'("P" "Prog" "&uzz" "Coderam" "Golflesming")

JavaScript (ES6), 103 byte

v=>(v=v.split`
`).map(_=>v=v.map((x,i)=>v[++i]?x.slice(0,n=v[i].length,v[i]+=x.slice(n)):x))&&v.join`
`

Suddivisa su CR, la mappa esterna ci assicura un numero di cicli sufficiente per consentire alla "gravità" di rilasciare le lettere per quanto devono cadere.

La mappa interna controlla innanzitutto se esiste una riga successiva, in tal caso, ed è più corta, rilascia l'overflow alla riga successiva. vale a dire se la 1a riga ha "ABCD" e la 2a riga ha "FG", rilasciare "CD" dalla 1a riga alla 2a in modo che la 1a riga diventi "AB" e la 2a diventi "FGCD".

Mentre lo facciamo tante volte quante sono le linee, le lettere scendono quanto dovrebbero, lasciandoci con il risultato desiderato.

Japt , 8 byte

y kS ù y

Provalo online!

Come funziona

Uy kS ù y

Uy  Transpose at newline
kS  Replace spaces with nothing
ù   Left-pad to fit the longest line
y   Transpose at newline

C'è anche zche ruota la stringa 2D di un multiplo di 90 gradi, ma in qualche modo tronca la stringa quando height > length.

05AB1E , 10 9 byte

¶¡RζðмζR»

Provalo online.

o con inizio alternativo:

.BRøðмζR»

Provalo online.

Approccio simile a @ Dennis ♦ 'Risposta Pyth .
-1 byte grazie a @Emigna che sostituisce ðõ:con ðм.

Spiegazione:

¶¡       # Split on new-lines
  R      # Reverse the list
   ζ     # Zip/Transpose with unequal-length items (with space filler by default)
ðм       # Remove all spaces
  ζ      # Zip/Transpose unequal-length items (with space filler) again
   R     # Reverse the list again
    »    # Join the list by newlines, and output implicitly

Spiegazione alternativa:

.B      # Box (implicitly splits on new-lines and appends spaces)
   ø    # Zip/Transpose with equal-length items
        # Rest is the same

R, s81 52 byte

function(x)apply(x,2,function(.).[order(!is.na(.))])

#old,longer version did the same but less efficiently
#function(x)apply(x,2,function(x){n<-na.omit(x);c(rep("",length(x)-length(n)),n)}))

Mi sono concesso un po 'di libertà nell'interpretazione della domanda e ho presunto che il testo fosse rappresentato in una matrice con un carattere per cella, quindi:

x <- as.matrix(read.fwf(textConnection("Programming
Puzzles
&
Code
Golf"), widths=rep(1, 11)))

Quindi x diventa:

     V1  V2  V3  V4  V5  V6  V7  V8  V9  V10 V11
[1,] "P" "r" "o" "g" "r" "a" "m" "m" "i" "n" "g"
[2,] "P" "u" "z" "z" "l" "e" "s" NA  NA  NA  NA 
[3,] "&" NA  NA  NA  NA  NA  NA  NA  NA  NA  NA 
[4,] "C" "o" "d" "e" NA  NA  NA  NA  NA  NA  NA 
[5,] "G" "o" "l" "f" NA  NA  NA  NA  NA  NA  NA 

Ora uso ordere [per ordinare le colonne in modo che prima vengano le NA e poi tutti gli altri valori:

     V1  V2  V3  V4  V5  V6  V7  V8  V9  V10 V11
[1,] "P" NA  NA  NA  NA  NA  NA  NA  NA  NA  NA 
[2,] "P" "r" "o" "g" NA  NA  NA  NA  NA  NA  NA 
[3,] "&" "u" "z" "z" NA  NA  NA  NA  NA  NA  NA 
[4,] "C" "o" "d" "e" "r" "a" "m" NA  NA  NA  NA 
[5,] "G" "o" "l" "f" "l" "e" "s" "m" "i" "n" "g"

Diventa più lungo se è necessario che l'output sia parole:

s <- (function(x)apply(x,2,function(.).[order(!is.na(.))]))(x)
s[is.na(s)]<-""
apply(s, 1, paste, collapse="")
# [1] "P"           "Prog"        "&uzz"        "Coderam"     "Golflesming"

R, 196 189 170 byte

function(x){l=nchar;o=function(y)which(diff(l(y))<0)[1];d=function(x,i)"[<-"(x,i:(j<-i+1),c(a<-substr(x[i],1,l(x[j])),sub(a,x[j],x[i])));while(!is.na(o(x)))x=d(x,o(x));x}

Una versione leggibile dall'uomo:

f<-function(x){
  l=nchar;

  # find the first line in x that is longer than the next line
  # if no such line exists o(x) will be NA
  o = function(y) which(diff(l(y))<0)[1]

  # d(x,i) --> clips the line i in x, adding the remainder to x[i+1]
  d = function(x,i) "[<-"(x,i:(j<-i+1),
        c(a<-substr(x[i],1,l(x[j])), sub(a,x[j],x[i])))
         # a --> clipped x[i],      sub(a,x[j],x[i]) --> expanded x[j]

  while(!is.na(o(x)))x=d(x,o(x));x
}                            

Come funziona:

1. Prendi la prima linea "cattiva", cioè la linea che è più lunga della linea successiva, prendi la parte "extra" e aggiungila alla linea successiva
2. Controlla se ci sono righe "cattive" rimaste, se sì vai al numero 1

(O in altre parole, le parti "superflue" cadono fino a quando tutto ciò che può cadere è caduto.)

Input: un carattere vettoriale.

x<-readLines(textConnection("Programming\nPuzzles\n&\nCode\nGolf"))
f(x)
# [1] "P"           "Prog"        "&uzz"        "Coderam"     "Golflesming"

Julia 0.6 , 141 byte

l=length
g(z,i)=(n=z[i];m=z[i+1];(N,M)=l.([n,m]);z[i:i+1]=[n[1:min(N,M)],m*n[M+1:N]])
f(s,w=split(s),d=1:l(w)-1)=(g.([w],[d d]);join(w,"\n"))

Provalo online!

La trasmissione con g.([w], [d d])mi consente di eliminare qualsiasi istruzione della mappa e mi fa risparmiare circa 7 byte.