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

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.

Хаскелл, 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 виконує переміщення по рядку, а по знаку - char, залишаючи результат у 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="")}

Це абсурдно довгий, наївний спосіб зробити це.

Безумовно:

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

Ви можете спробувати в Інтернеті .

Матлаб / Октава, 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 Не гольф-езоланг б'є звичайні моменти: p

Дивна річ про Туртледа: вона спочатку була зроблена після дискусії про те, що стосується мистецтва ascii, але насправді, здається, найкраще в таких видах проблем

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.

Застосовує гравітацію до всього тексту на консолі. Я не впевнений, чи це дійсно, чи якщо я повинен використовувати рядковий масив.

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

Безумовно:

(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", а у другому рядку "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»

Спробуйте в Інтернеті.

Подібний підхід , як @ Pyth відповідь Денніса ♦ » .
-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)))

Так 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 

Тепер я використовую orderі [сортую стовпчики так, щоб НС прийшов спочатку, а потім усі інші значення:

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