Sagen Sie, ich habe Text wie diesen (jedes Wort in einer Zeile, ohne Leerzeichen)

Programming
Puzzles
&
Code
Golf

Das macht keinen Sinn! Es widerspricht völlig den Gesetzen der Physik.

Ihre Herausforderung besteht darin, diese unmögliche Situation zu beheben und den Text wie folgt zu reduzieren:

P
Prog
&uzz
Coderam
Golflesming

Damit unter keinem Zeichen ein Leerzeichen steht, behalten die Zeichen ihre vertikale Reihenfolge bei.

Ziel ist es, die Anforderungen zu erfüllen, aber möglichst wenige Byte Quellcode zu verwenden.

Pyth, 10 Bytes

jb_.T.T_.z

Versuchen Sie es online im Pyth Compiler / Executor .

Idee

Wir können die gewünschte Ausgabe erzielen, indem wir vier einfache Transformationen anwenden:

1. Kehre die Reihenfolge der Zeilen um:

   Golf
   Code
   &
   Puzzles
   Programming
   

2. Zeilen und Spalten transponieren:

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

   Diese Spitze rechtfertigt das Reduzieren der ursprünglichen Spalten.

3. Zeilen und Spalten transponieren:

   Golflesming
   Coderam
   &uzz
   Prog
   P
   

4. Kehre die Reihenfolge der Zeilen um:

   P
   Prog
   &uzz
   Coderam
   Golflesming
   

Code

        .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 Bytes

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

Ich bin sehr reif.

Python 2, 104 Bytes

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)

Ein iterativer One-Pass-Algorithmus. Wir gehen jede Zeile der Reihe nach durch und aktualisieren die Liste lder auszugebenden Zeilen. Das neue Wort wird effektiv von unten gedrückt, wobei alle darüber stehenden Buchstaben um ein Leerzeichen verschoben werden. Zum Beispiel im Testfall

Programming
Puzzles
&
Code
Golf

Nachdem wir fertig sind Code, haben wir

P
Prog
&uzzram
Codelesming

und dann GolfErgebnisse hinzufügen in

P
Prog
&uzz
Coderam
Golflesming

was wir als die Kombination von zwei Stücken sehen können

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

wo das erste Stück durch verschoben wurde golf. Wir führen diese Verschiebung mit einem zipElement in der Ausgabeliste am Ende (linke Seite) und mit einer Leerzeile (rechte Seite) durch, wobei jeder Teil an der Länge des neuen Elements abgeschnitten wird.

Es mag natürlicher erscheinen, stattdessen rückwärts zu iterieren und neue Buchstaben von oben fallen zu lassen, aber mein Versuch, dies zu tun, wurde länger.

Zum Vergleich ist hier ein zip/ filter-Ansatz mit map(None,*x)verwendet für iziplongest(109 Bytes):

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 Bytes

qN/W%zzW%N*

Probieren Sie es online im CJam-Interpreter aus .

Wie es funktioniert

Die Idee ist die gleiche wie in meiner Pyth-Antwort .

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

(Die 2 Zeilenumbrüche in den Vorlagenzeichenfolgen sind signifikant und werden gezählt.)

Die Idee von @Dennis in JavaScript umgesetzt. Die langwierige S-Funktion transponiert Zeile für Zeile und Zeichen für Zeichen. Das Ergebnis verbleibt im tArray.

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

Weniger Golf im Snippet (versuchen Sie es 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 Bytes

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="")}

Dies ist eine absurd lange, naive Methode.

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 = "")
    }
}

Sie können es online ausprobieren .

Matlab / Octave, 99 Bytes

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

Beispiel :

Definieren Sie beispielsweise eine Eingabezeichenfolge in einer Variablen s. 10ist das Zeilenvorschubzeichen:

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

Aufruffunktion fmit Eingabe s:

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

Oder probieren Sie es online aus (danke an @beaker für die Hilfe beim Online-Octave-Interpreter)

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

Hier ist es ungolfed und in ES5 mit Kommentaren, die erklären, wie es funktioniert:

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 mit meinen Erweiterungen zu Dyalog APL.

Anonyme implizite Funktion, die eine Zeichenmatrix aufnimmt und zurückgibt.

~∘' '⍤1⍢⍉⍢⊖

Probieren Sie es online!

~ Entfernen Sie
∘ die
' ' Leerzeichen
⍤ von
1 Zeilen (lit. 1D-Subarrays),
⍢ während Sie sie
⍉ transponieren,
⍢ während Sie sie
⊖ spiegeln

R 190 178 175 Bytes

Vermutlich noch etwas Platz zum Golfen dabei. Wahrscheinlich ein paar unnötige Operationen

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 und erklärte

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

Testlauf. Es ist interessant festzustellen, dass aufgrund der Funktionsweise des Scans der gesamte Satz mit Leerzeichen eingegeben werden kann und trotzdem die angegebene Ausgabe erfolgt.

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

Übernimmt die Eingabe in eine Datei mit dem Namen ab. Funktioniert jetzt nur für bis zu 24 Zeichen. Wird später aktualisiert, damit es mit mehr funktioniert. Funktioniert auch nicht im Online-Compiler. Benötigt den unfreien Compiler.

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
}

Bearbeiten: Verschiebt die leise (um die Ausgabe zu unterdrücken) aus jeder Anweisung in der Schleife in die Schleife selbst und spart 8 Byte.

R, 171 Bytes

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

Mit Zeilenumbrüchen und Einrückung:

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

Verwendungszweck:

> 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

Gelee , 6 Bytes (nicht konkurrierend)

ỴṚZZṚY

Probieren Sie es online!

Wie es funktioniert

Die Idee ist die gleiche wie in meiner Pyth-Antwort .

ỴṚ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 Bytes, nicht konkurrierend

Ziemlich sicher, dass ich den Ansatz ändern könnte, um Bytes zu sparen, aber später.

: p Nicht-Golf-Esolang schlägt regelmäßig langs: p

Das Seltsame an Turtlèd ist, dass es ursprünglich nach einer Diskussion über ascii art langs gemacht wurde, aber es scheint tatsächlich das Beste für diese Art von Herausforderungen zu sein

Turtlèd kann keine Zeilenumbrüche, sondern mehrere Eingaben vornehmen, und dies erfordert nur eine Eingabe: Beenden Sie jedes Wort mit einem Leerzeichen, einschließlich des letzten.

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

Probieren Sie es online!

Erläuterung:

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

Dies war eine dieser Herausforderungen, die sich in meinem Kopf von zu schwierig, zu einfach, zu viel mehr Code als erwartet änderten. Ich bin nicht besonders zufrieden mit dem Ansatz, ich bin mir sicher, dass es einen gibt viel besserer Weg, um das print pop@F...Bit zu reduzieren, vielleicht mit -noder einfach nur mit regulärem Ausdruck, aber ich komme gerade nicht dahin ... Ursprünglich habe ich verwendet say, aber ich denke, ich müsste das höher bewerten ( use 5.01), weil $'.

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

Verwendungszweck

Speichern unter vertically-collapse-text.pl.

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

SmileBASIC, 90 Bytes

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

Wendet die Schwerkraft auf den gesamten Text in der Konsole an. Ich bin nicht sicher, ob dies gültig ist oder ob ich ein String-Array verwenden muss.

Rubin, 99 82 Bytes

Dahin kommen...

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

Eine versuchte Erklärung:

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

Führen Sie es so aus:

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"

Erläuterung

x@\:!|/#:'x Erweitert jede Zeichenfolge, um eine quadratische Zeichenmatrix zu erstellen.

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

+ transponiert es

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} Entfernt Leerzeichen aus einer Zeichenfolge und füllt die Zeichenfolge mit der ursprünglichen Länge auf

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

Wenden Sie diese Funktion auf jede der transponierten Saiten an und drehen Sie die Ausgabe, um das Ergebnis zu erhalten

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

pb - 310 Bytes

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

Was für eine Katastrophe. Ich kann mich kaum daran erinnern, wie es funktioniert.

Aufgrund der Art und Weise, wie die Eingabe von pb funktioniert (eine einzelne Zeile auf einmal), müssen Sie Leerzeichen anstelle von Zeilenumbrüchen in der Eingabe verwenden. Wenn der Interpreter kein Müll wäre und Sie könnten Zeilenumbrüche in die Eingabe aufnehmen, wäre die einzige Änderung die [B=32]am Anfang stehende[B=10] .

Ich arbeite an einem Update für pbi (den Interpreter), das die Grafiken aufräumt, wenn Sie das Programm laufen lassen möchten. Es braucht noch viel Arbeit, aber in der Zwischenzeit können Sie dieses Programm auf YouTube ansehen .

J, 17 Bytes

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

Ganz angenehme Lösung.

Erläuterung:

-.&' '"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.)

Testfall erklärt

   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

Testfälle

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

Tatsächlich 13 Bytes

Dies verwendet den in Dennis 'Jelly-Antwort beschriebenen Algorithmus . Input und Output sind beide Listen von Strings. Leider funktioniert die eingebaute Transponierungsfunktion nicht sehr gut, wenn die inneren Listen oder Strings nicht alle gleich lang sind, was den Punkt des vertikalen Kollabierens in erster Linie zunichte machen würde. Golfvorschläge sind willkommen. Probieren Sie es 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.

Schläger 312 Bytes

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

Testen:

(f "Programming Puzzles & Code Golf")

Ausgabe:

'("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`
`

Die äußere Karte ist auf CR aufgeteilt und sorgt dafür, dass wir genügend Zeit für eine Schleife haben, damit die "Schwerkraft" die Buchstaben so weit fallen lässt, wie sie fallen müssen.

Die innere Karte prüft zuerst, ob es eine nächste Zeile gibt. Wenn dies der Fall ist und diese kürzer ist, lassen Sie den Überlauf in die nächste Zeile fallen. dh wenn die 1. Zeile "ABCD" und die 2. Zeile "FG" enthält, legen Sie die "CD" von der 1. Zeile in die 2. Zeile ab, sodass die 1. Zeile zu "AB" und die 2. Zeile zu "FGCD" wird.

Wenn wir dies so oft tun, wie es Zeilen gibt, fallen die Buchstaben so weit ab, wie sie sollten, was uns das gewünschte Ergebnis liefert.

Japt , 8 Bytes

y kS ù y

Probieren Sie es online!

Wie es funktioniert

Uy kS ù y

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

Es gibt auch z welche die 2D-Zeichenfolge um ein Vielfaches von 90 Grad dreht, aber es schneidet die Zeichenfolge irgendwie ab, wenn height > length.

05AB1E , 10 9 Bytes

¶¡RζðмζR»

Probieren Sie es online aus.

oder mit alternativem Start:

.BRøðмζR»

Probieren Sie es online aus.

Ähnliches Vorgehen wie bei @ Dennis ♦ 'Pyth-Antwort .
-1 Byte dank @Emigna als Ersatz ðõ:fürðм .

Erläuterung:

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

Alternative Erklärung:

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

R, s81 52 Bytes

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

Bei der Interpretation der Frage habe ich mir etwas Freiheit genommen und angenommen, dass der Text in einer Matrix mit einem Zeichen pro Zelle dargestellt wird.

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

Also wird x:

     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 

Jetzt benutze ich orderund [um die Spalten so zu sortieren, dass die NA's zuerst kommen und dann alle anderen Werte:

     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"

Es wird länger, wenn die Ausgabe Wörter sein muss:

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 Bytes

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}

Eine für Menschen lesbare Version:

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
}                            

Wie es funktioniert:

1. Nehmen Sie die erste "schlechte" Zeile, dh Zeile, die länger als die nächste Zeile ist, nehmen Sie den "zusätzlichen" Teil und fügen Sie ihn zur nächsten Zeile hinzu
2. Überprüfen Sie, ob noch "schlechte" Leitungen vorhanden sind. Wenn ja, fahren Sie mit Schritt 1 fort

(Oder mit anderen Worten, "überflüssige" Teile fallen herunter, bis alles heruntergefallen ist, was herunterfallen kann.)

Eingabe: Ein Zeichenvektor.

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

Julia 0,6 , 141 Bytes

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

Probieren Sie es online!

Wenn g.([w], [d d])ich mit übertrage, kann ich jede Map-Anweisung loswerden und spare mir etwa 7 Bytes.