Скажем, у меня есть такой текст (каждое слово в одной строке, без пробелов)

Programming
Puzzles
&
Code
Golf

Это не имеет смысла! Это полностью противоречит законам физики.

Ваша задача - исправить эту невозможную ситуацию и свернуть текст следующим образом:

P
Prog
&uzz
Coderam
Golflesming

Так что под любым символом нет пустого пространства, но символы сохраняют свой вертикальный порядок.

Цель состоит в том, чтобы удовлетворить требования, но использовать как можно меньше байтов исходного кода.

Pyth, 10 байт

jb_.T.T_.z

Попробуйте это онлайн в Pyth Compiler / Executor .

идея

Мы можем достичь желаемого результата, применив четыре простых преобразования:

1. Обратный порядок строк:

   Golf
   Code
   &
   Puzzles
   Programming
   

2. Транспонировать строки и столбцы:

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

   Эта вершина оправдывает, сворачивая оригинальные столбцы.

3. Транспонировать строки и столбцы:

   Golflesming
   Coderam
   &uzz
   Prog
   P
   

4. Обратный порядок строк:

   P
   Prog
   &uzz
   Coderam
   Golflesming
   

Код

        .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 байта

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

Я очень зрелый.

Python 2, 104 байта

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)

Итеративный однопроходный алгоритм. Мы проходим каждую строку по порядку, обновляя список lстрок для вывода. Новое слово эффективно выталкивает снизу, сдвигая все буквы над ним на один пробел. Например, в тестовом случае

Programming
Puzzles
&
Code
Golf

после того, как мы сделали до Code, мы имеем

P
Prog
&uzzram
Codelesming

а затем добавить Golfрезультаты в

P
Prog
&uzz
Coderam
Golflesming

который мы можем рассматривать как комбинацию из двух частей

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

где первая часть была сдвинута вверх golf. Мы выполняем это смещение zipсписка вывода с элементом в конце (слева) и приоритетом списка вывода пустой строкой (справа), обрезая каждую часть по длине нового элемента.

Может показаться более естественным вместо этого выполнять итерацию в обратном направлении, позволяя новым буквам падать сверху, но моя попытка сделать это оказалась более длительной.

Для сравнения вот zip/ filterподход, map(None,*x)используемый для iziplongest(109 байт):

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 байт

qN/W%zzW%N*

Попробуйте онлайн в интерпретаторе CJam .

Как это устроено

Идея такая же, как и в моем 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

(2 строки в шаблонных строках значимы и учитываются)

Идея @Dennis реализована в JavaScript. Длинная функция S выполняет транспонирование строка за строкой и символ за символом, оставляя результат в tмассиве.

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

Меньше гольфа внутри фрагмента (попробуйте в 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 байта

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

Это абсурдно длинный, наивный способ сделать это.

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

Вы можете попробовать это онлайн .

Matlab / Octave, 99 байт

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

Пример :

Определите входную строку в переменной, скажем s. 10символ перевода строки:

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

Вызов функции fс входом s:

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

Или попробуйте онлайн (спасибо @beaker за помощь с онлайн-переводчиком Octave)

JavaScript ES6, 119 байт

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

Вот это и есть в ES5 с комментариями, объясняющими, как это работает:

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 байтов ^SBCS

-2 с моими расширениями для Dyalog APL.

Анонимная молчаливая функция, принимающая и возвращающая символьную матрицу.

~∘' '⍤1⍢⍉⍢⊖

Попробуйте онлайн!

~ удалить
∘ те
' ' пробелы
⍤ из
1 строк (букв 1D суб-массивов) ,
⍢ а
⍉ транспонированная в
⍢ то время как
⊖ перевернутый

R 190 178 175 байт

Вероятно, еще есть место для игры в гольф. Возможно, пара ненужных операций там

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

Разгромил и объяснил

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

Тестовый забег. Интересно отметить, что из-за того, как работает сканирование, все предложение может быть введено с пробелами и по-прежнему выдавать результат, как указано.

> 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 байта

Вводит в файл с именем ab. Теперь работает только до 24 символов. Буду обновлять позже, чтобы заставить его работать больше. Кроме того, не работает в онлайн-компиляторе. Требуется несвободный компилятор.

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
}

Редактировать: тихо (для подавления вывода) перемещается в сам цикл из каждого оператора в цикле, сохраняя 8 байтов.

R 171 байт

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

С переводом строки и отступом:

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

Использование:

> 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

Желе , 6 байт (не конкурирует)

ỴṚZZṚY

Попробуйте онлайн!

Как это устроено

Идея такая же, как и в моем 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 байта, неконкурентный

Я уверен, что смогу изменить подход к экономии байтов, но позже.

: p Не-гольф esolang бьет обычные языки: p

Странная вещь в Turtlèd заключается в том, что она изначально была сделана после обсуждения ascii art langs, но на самом деле кажется, что она лучше всех справляется с подобными задачами

Turtlèd не может принимать ввод новой строки, но для нескольких вводов, и для этого требуется только один ввод: заканчивать каждое слово пробелом, включая последнее.

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

Попробуйте онлайн!

Объяснение:

!                          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 байта

Это была одна из тех проблем, которые изменились в моей голове от того, чтобы быть слишком сложным, чтобы быть легким, чтобы быть намного большим количеством кода, чем я ожидал ... Я не особенно доволен подходом, я уверен, что есть намного лучший способ уменьшить print pop@F...бит, возможно, используя -nили просто регулярное выражение, но я не могу получить это прямо сейчас ... Первоначально я использовал say, но я думаю, что из-за этого я должен был бы выиграть это выше ( use 5.01) $'.

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

использование

Сохранить как vertically-collapse-text.pl.

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

SmileBASIC, 90 байт

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

Применяет гравитацию ко всему тексту в консоли. Я не уверен, является ли это допустимым, или я должен использовать массив строк.

Рубин, 99 82 байта

Попасть туда...

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

Попытка объяснения:

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

Запустите это так:

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

К, 30

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

,

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

объяснение

x@\:!|/#:'x расширяет каждую строку для создания квадратной матрицы символов.

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

+ переносит это

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} удалит все пробелы из строки, а затем дополнит строку ее исходной длиной

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

Примените эту функцию к каждой из транспонированных строк, затем переверните вывод, чтобы получить результат

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

pb - 310 байт

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

Какая катастрофа. Я почти ничего не помню о том, как это работает.

Из-за того, как работает ввод pb (одна строка за раз), вы должны использовать пробелы вместо новых строк во вводе. Если интерпретатор не был мусором, и вы могли бы включить переводы строк во входные данные, единственным изменением было бы [B=32]начало [B=10].

Я работаю над обновлением pbi (интерпретатора), которое будет очищать визуальные эффекты, если вы хотите наблюдать за запуском программы. Это все еще требует большой работы, но пока вы можете посмотреть эту программу на YouTube .

J, 17 байт

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

Довольно приятное решение.

Объяснение:

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

Тестовый пример объяснил

   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

Контрольные примеры

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

На самом деле , 13 байтов

При этом используется алгоритм, описанный в ответе Денниса «Желе» . Вход и выход - оба списка строк. К сожалению, встроенная функция транспонирования работает не очень хорошо, если внутренние списки или строки не имеют одинаковую длину, что, во-первых, могло бы преодолеть точку вертикального коллапса. Предложения по игре в гольф приветствуются. Попробуйте онлайн!

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.

Ракетка 312 байт

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

Тестирование:

(f "Programming Puzzles & Code Golf")

Выход:

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

JavaScript (ES6), 103 байта

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

Разделенная на CR внешняя карта гарантирует, что мы зациклимся достаточно раз, чтобы позволить гравитации отбрасывать буквы так, как им нужно.

Внутренняя карта сначала проверяет, есть ли следующая строка, если она есть, и она короче, сбрасывает переполнение на следующую строку. т. е. если в 1-й строке указано «ABCD», а во 2-й строке указано «FG», поместите «CD» из 1-й строки во 2-ю, чтобы 1-я строка стала «AB», а вторая - «FGCD».

Поскольку мы делаем это столько раз, сколько строк, буквы падают так далеко, как следовало, оставляя нам желаемый результат.

Japt , 8 байт

y kS ù y

Попробуйте онлайн!

Как это устроено

Uy kS ù y

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

Есть также, zкоторый поворачивает 2D строку на кратное 90 градусов, но это как-то обрезает строку, когда height > length.

05AB1E , 10 9 байтов

¶¡RζðмζR»

Попробуйте онлайн.

или с альтернативным началом:

.BRøðмζR»

Попробуйте онлайн.

Подобный подход, как @ Деннис ♦ Пайт ответ .
-1 байт благодаря замене @Emignaðõ: на ðм.

Объяснение:

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

Альтернативное объяснение:

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

R, s81 52 байта

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

Я взял на себя смелость при интерпретации вопроса и предположил, что текст представлен в виде матрицы по одному символу на ячейку, таким образом:

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

Итак, х становится:

     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 

Теперь я использую orderи [сортирую столбцы так, чтобы вначале стояли NA, а затем все остальные значения:

     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"

Это становится длиннее, если требуется, чтобы на выходе были слова:

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 байт

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}

Человекочитаемая версия:

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
}                            

Как это устроено:

1. Возьмите первую «плохую» строку, т.е. строку, которая длиннее следующей строки, возьмите «лишнюю» часть и добавьте ее к следующей строке
2. Проверьте, остались ли «плохие» строки, если да, перейдите к # 1

(Или, другими словами, «лишние» детали падают до тех пор, пока не упадет все, что может упасть.)

Ввод: символьный вектор.

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

Юлия 0,6 , 141 байт

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

Попробуйте онлайн!

Трансляция с помощью g.([w], [d d])позволяет мне избавиться от любого оператора карты и экономит мне около 7 байтов.