Dites que j'ai un texte comme celui-ci (chaque mot sur une ligne, sans espace)

Programming
Puzzles
&
Code
Golf

Ça n'a aucun sens! Il défie totalement les lois de la physique.

Votre défi est de remédier à cette situation impossible et de réduire le texte de la manière suivante:

P
Prog
&uzz
Coderam
Golflesming

Il n'y a donc aucun espace vide sous aucun caractère, mais les personnages conservent leur ordre vertical.

L'objectif est de satisfaire les exigences mais d'utiliser le moins d'octets de code source possible.

Pyth, 10 octets

jb_.T.T_.z

Essayez-le en ligne dans le compilateur / exécuteur Pyth .

Idée

Nous pouvons obtenir le résultat souhaité en appliquant quatre transformations simples:

1. Inverser l'ordre des lignes:

   Golf
   Code
   &
   Puzzles
   Programming
   

2. Transposer des lignes et des colonnes:

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

   Ce sommet justifie la réduction des colonnes d'origine.

3. Transposer des lignes et des colonnes:

   Golflesming
   Coderam
   &uzz
   Prog
   P
   

4. Inverser l'ordre des lignes:

   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 octets

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

Je suis très mature.

Python 2, 104 octets

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 algorithme itératif à une passe. Nous parcourons chaque ligne dans l'ordre, en mettant à jour la liste ldes lignes à afficher. Le nouveau mot pousse efficacement à partir du bas, en déplaçant toutes les lettres au-dessus d'un espace. Par exemple, dans le cas de test

Programming
Puzzles
&
Code
Golf

après avoir fait jusqu'à Code, nous avons

P
Prog
&uzzram
Codelesming

puis en ajoutant les Golfrésultats dans

P
Prog
&uzz
Coderam
Golflesming

que nous pouvons voir comme la combinaison de deux pièces

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

où le premier morceau a été déplacé vers le haut golf. Nous effectuons ce décalage avec un zipélément de la liste de sortie avec l'élément à la fin (côté gauche) et la priorité de la liste de sortie par une ligne vide (côté droit), en coupant chaque partie à la longueur du nouvel élément.

Il peut sembler plus naturel d’itérer à la place les nouvelles lettres, mais ma tentative a été plus longue.

Pour la comparaison, voici une approche zip/ filter, avec map(None,*x)utilisé pour iziplongest(109 octets):

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 octets

qN/W%zzW%N*

Essayez-le en ligne dans l' interprète CJam .

Comment ça fonctionne

L'idée dans le même que dans ma réponse 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

(Les 2 nouvelles lignes à l'intérieur des chaînes de modèle sont significatives et comptées)

L'idée de @Dennis implémentée en JavaScript. La fonction S longue effectue la transposition ligne par ligne et caractère par caractère, en laissant le résultat dans le ttableau.

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

Moins joué dans l'extrait de code (essayez dans 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 octets

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

C'est une manière absurde et naïve de le faire.

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

Vous pouvez l' essayer en ligne .

Matlab / Octave, 99 octets

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

Exemple :

Définir une chaîne d'entrée dans une variable, par exemple s. 10est le caractère de saut de ligne:

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

Fonction d'appel favec entrée s:

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

Ou essayez-le en ligne (merci à @beaker de l'aide pour l'interprète en ligne Octave)

JavaScript ES6, 119 octets

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

Ici, il est non-golfé et dans ES5 avec des commentaires expliquant son fonctionnement:

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) , ^{SBCS de} 13 11 octets

-2 avec mes extensions à Dyalog APL.

Fonction tacite anonyme, prenant et renvoyant une matrice de caractères.

~∘' '⍤1⍢⍉⍢⊖

Essayez-le en ligne!

~ supprime
∘ les
' ' espaces
⍤ des
1 lignes (sous-tableaux 1D allumés)
⍢ lors de la
⍉ transposition
⍢ lors du
⊖ retournement

R, 190 178 175 Octets

Probablement encore de la place pour jouer au golf. Probablement quelques opérations inutiles là-bas

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 et expliqué

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

Essai. Il est intéressant de noter qu'en raison de la manière dont l'analyse fonctionne, la phrase entière peut être entrée avec des espaces tout en donnant la sortie spécifiée.

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

Prend la saisie dans un fichier appelé ab Seulement fonctionne maintenant pour 24 caractères maximum. Mettra à jour plus tard pour le faire fonctionner avec plus. En outre, ne fonctionne pas dans le compilateur en ligne. Nécessite le compilateur non libre.

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
}

Éditer: déplacé silencieusement (pour supprimer la sortie) vers la boucle elle-même à partir de chaque instruction de la boucle, en économisant 8 octets.

R, 171 octets

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

Avec nouvelles lignes et indentation:

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

Usage:

> 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

Gelée , 6 octets (non concurrente)

ỴṚZZṚY

Essayez-le en ligne!

Comment ça fonctionne

L'idée dans le même que dans ma réponse 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 bytes, non compétitif

Plutôt sûr de pouvoir changer d’approche pour économiser des octets, mais plus tard.

: p non-golf esolang bat langs régulière: p

Ce qui est étrange à propos de Turtlèd, c’est qu’il a été créé à l’origine après une discussion sur les arts ascii, mais elle semble en fait être la meilleure pour ce genre de défis.

Turtlèd ne peut prendre une entrée nouvelle ligne mais pour plusieurs entrées, et cela ne prend qu'une entrée: termine chaque mot avec un espace, y compris le dernier.

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

Essayez-le en ligne!

Explication:

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

C’était l’un de ces défis qui, dans ma tête, changeaient: trop difficile, plus facile, plus codé que je ne le pensais ... Je ne suis pas particulièrement heureux de cette approche, je suis sûr qu’il existe un moyen bien meilleur de réduire le print pop@F...bit en utilisant peut-être -nou simplement du regex pur, mais je ne peux pas y aller pour le moment ... À l’origine, j’utilisais say, mais je pense que je devrais obtenir un score plus élevé ( use 5.01) à cause de $'.

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

Usage

Enregistrer sous vertically-collapse-text.pl.

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

SmileBASIC, 90 octets

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

Applique la gravité à tout le texte de la console. Je ne sais pas si cela est valide ou si je dois utiliser un tableau de chaînes.

Ruby, 99 82 octets

Comment y arriver ...

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

Une tentative d'explication:

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

Exécutez-le comme ceci:

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"

Explication

x@\:!|/#:'x étend chaque chaîne pour créer une matrice de caractères carrés.

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

+ le transpose

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} supprimera tous les espaces d'une chaîne, puis complétera la chaîne par sa longueur d'origine

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

Appliquez cette fonction à chacune des chaînes transposées, puis retournez la sortie pour obtenir le résultat.

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

pb - 310 octets

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

Quel désastre. Je me souviens à peine de quoi que ce soit sur la façon dont cela fonctionne.

En raison du fonctionnement de l'entrée de pb (une seule ligne à la fois), vous devez utiliser des espaces au lieu de nouvelles lignes dans l'entrée. Si l'interprète n'était pas un déchet et que vous pouviez inclure des nouvelles lignes dans l'entrée, le seul changement serait [B=32]le début[B=10] .

Je travaille sur une mise à jour de pbi (l'interprète) qui nettoiera les éléments visuels si vous souhaitez visionner le programme. Il faut encore beaucoup de travail, mais en attendant, vous pouvez regarder ce programme sur YouTube .

J, 17 octets

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

Solution assez agréable.

Explication:

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

Cas de test expliqué

   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

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

Réellement , 13 octets

Ceci utilise l'algorithme décrit dans la réponse de Dennis 'Jelly . L'entrée et la sortie sont toutes les deux des listes de chaînes. Malheureusement, la fonction de transposition intégrée ne fonctionne pas très bien si les listes internes ou les chaînes ne sont pas toutes de la même longueur, ce qui ferait en sorte de déjouer le point de s'effondrer verticalement. Les suggestions de golf sont les bienvenues. Essayez-le en ligne!

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.

Raquette 312 octets

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

Essai:

(f "Programming Puzzles & Code Golf")

Sortie:

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

JavaScript (ES6), 103 octets

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

Divisé en CR, la carte externe garantit que nous bouclons suffisamment de temps pour permettre à "la gravité" de supprimer les lettres aussi loin que nécessaire.

Inner map vérifie d'abord s'il existe une ligne suivante. Si c'est le cas, et si elle est plus courte, supprimez le débordement à la ligne suivante. c'est-à-dire que si la 1ère ligne a "ABCD" et que la 2ème ligne a "FG", abandonnez le "CD" de la 1ère ligne à la 2ème pour que la 1ère ligne devienne "AB" et la 2ème devienne "FGCD".

Comme nous le faisons autant de fois qu'il y a de lignes, les lettres tombent aussi loin qu'elles le devraient, nous laissant ainsi le résultat souhaité.

Japt , 8 octets

y kS ù y

Essayez-le en ligne!

Comment ça fonctionne

Uy kS ù y

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

Il y a aussi zqui fait pivoter la chaîne 2D d'un multiple de 90 degrés, mais la tronque quand même height > length.

05AB1E , 10 à 9 octets

¶¡RζðмζR»

Essayez-le en ligne.

ou avec départ alternatif:

.BRøðмζR»

Essayez-le en ligne.

Approche similaire à celle de @ Dennis ♦ 'Pyth .
-1 octet grâce à @Emigna en remplacement ðõ:deðм .

Explication:

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

Explication alternative:

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

R, s81 52 octets

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

J'ai pris une certaine liberté dans l'interprétation de la question et j'ai supposé que le texte était représenté dans une matrice avec un caractère par cellule, ainsi:

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

Donc x devient:

     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 

Maintenant, j'utilise orderet je [trie les colonnes pour que les NA viennent en premier, puis toutes les autres valeurs:

     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"

Il devient plus long s'il est nécessaire que le résultat soit des mots:

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 octets

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}

Une version lisible par l'homme:

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
}                            

Comment ça fonctionne:

1. Prenez la première "mauvaise" ligne, c'est-à-dire la ligne qui est plus longue que la ligne suivante, prenez la partie "extra" et ajoutez-la à la ligne suivante
2. Vérifiez s'il reste des "mauvaises" lignes, si oui, allez à # 1

(Ou en d'autres termes, des parties "superflues" tombent jusqu'à ce que tout ce qui peut tomber soit tombé.)

Entrée: un vecteur de caractère.

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

Julia 0.6 , 141 octets

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

Essayez-le en ligne!

La diffusion avec g.([w], [d d])me permet de me débarrasser de tout relevé de carte et me fait économiser environ 7 octets.