Diyelim ki bunun gibi bir metnim var (her satır bir satırda, boşluksuz)

Programming
Puzzles
&
Code
Golf

Bu hiç mantıklı değil! Tamamen fizik yasalarına meydan okuyor.

Buradaki zorluk, bu imkansız durumu düzeltmek ve metni şöyle daraltmaktır:

P
Prog
&uzz
Coderam
Golflesming

Böylece herhangi bir karakterin altında boş alan kalmaz, ancak karakterler dikey sıralarını korurlar.

Amaç, gereklilikleri yerine getirmek, ancak kaynak kodunun en az baytını kullanmaktır.

Pyth, 10 bayt

jb_.T.T_.z

Pyth Compiler / Executor'da çevrimiçi olarak deneyin .

Fikir

Dört basit dönüşüm uygulayarak istenen çıktıya ulaşabiliriz:

1. Satırların sırasını ters çevirin:

   Golf
   Code
   &
   Puzzles
   Programming
   

2. Satır ve sütunları devretme:

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

   Bu üst, orijinal sütunların daraltılmasını haklı kılar.

3. Satır ve sütunları devretme:

   Golflesming
   Coderam
   &uzz
   Prog
   P
   

4. Satırların sırasını ters çevirin:

   P
   Prog
   &uzz
   Coderam
   Golflesming
   

kod

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

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

Çok olgunum

Python 2, 104 bayt

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)

Yinelemeli bir tek geçişli algoritma. Her satırın içinden geçerek lsatırların çıktısını güncelliyoruz . Yeni kelime etkili bir şekilde aşağıdan yukarıya doğru iterek tüm harfleri bir boşlukta kaydırır. Örneğin, test durumunda

Programming
Puzzles
&
Code
Golf

biz kadar yaptıktan sonra Code, elimizdeki

P
Prog
&uzzram
Codelesming

ve ardından Golfsonuçların eklenmesi

P
Prog
&uzz
Coderam
Golflesming

ki iki parçanın birleşimi olarak görebiliriz

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

ilk parça nereye kaydırıldı? golf . Bu kaydırmayı zipelemanların sonunda (sol tarafta) ve çıkış listesinde öncelikli olarak boş bir satır (sağ tarafta) olacak şekilde çıkış listesinden biriyle, yeni parçanın uzunluğundaki her bir parçayı keseriz.

Bunun yerine geriye doğru yinelemek, yeni mektupların üstten düşmesine izin vermek daha doğal görünebilir, ancak bu girişimi daha uzun sürdü.

Karşılaştırma için, işte ( zip/ byte) için kullanılan bir / filteryaklaşım :map(None,*x)iziplongest

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 bayt

qN/W%zzW%N*

CJam tercümanında çevrimiçi olarak deneyin .

Nasıl çalışır

Fikir, Pyth cevabımdakiyle aynı .

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

(Şablon dizelerinin içindeki 2 yeni satır önemli ve sayılır)

@Dennis fikri JavaScript'te uygulanmaktadır. Uzun S işlevi, aktarım satırını satır satır ve satır char karakter sırayla sonuç bırakarak yapar 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`
`)

Snippet'in içinde daha az golf oynadı (Firefox'ta deneyin)

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 bayt

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

Bu, saçma sapanca, naif bir yoludur.

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

Şunları yapabilirsiniz çevrimiçi denemek .

Matlab / Octave, 99 bayt

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

Örnek :

Bir değişkende bir girdi dizgisi tanımlayın, örneğin s. 10Satır besleme karakteri:

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

İşlevini çağırın fgirişli s:

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

Ya da çevrimiçi deneyin ( çevrimiçi Octave tercümanı ile ilgili yardım için @beaker sayesinde )

JavaScript ES6, 119 bayt

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

İşte nasıl eskimiş ve nasıl çalıştığını açıklayan yorumlarla ES5'te:

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 Genişletilmiş) , 13 11 bayt ^SBCS

-2 benim Dyalog APL uzantılarımla.

Anonim tacit işlevi, karakter matrisini alıp döndürmek.

~∘' '⍤1⍢⍉⍢⊖

Çevrimiçi deneyin!

~ kaldırmak  boşluk  gelen  satır (lit. 1D alt dizileri)  ise  transpoze  ise  ters çevrilmiş
∘
' '
⍤
1
⍢
⍉
⍢
⊖

R, 190 178 175 Bayt

Muhtemelen hala bu konuda golf için bazı oda. Muhtemelen birkaç gereksiz operasyon var.

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 ve açıkladı

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

Test sürüşü. Taramanın çalışma şekli nedeniyle tüm cümlenin boşluklarla girilebileceğini ve çıktıyı belirtildiği gibi verebileceğini not etmek ilginçtir.

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

Ab adındaki bir dosyaya girdi alır Şimdilik en fazla 24 karakter çalışır. Daha fazla çalışması için daha sonra güncellenecektir. Ayrıca, çevrimiçi derleyicide çalışmıyor. Ücretsiz olmayan derleyici gerektirir.

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
}

Düzenleme: sessizce (çıktıyı bastırmak için) döngünün her ifadesinden döngünün kendisine taşındı, 8 bayt kazandı.

R, 171 bayt

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

Yeni satırlara ve girintiye sahip:

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

Kullanımı:

> 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

Jöle , 6 bayt (yarışmaz)

ỴṚZZṚY

Çevrimiçi deneyin!

Nasıl çalışır

Fikir, Pyth cevabımdakiyle aynı .

ỴṚ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 bayt,

Baytları kurtarmak için yaklaşımı değiştirebileceğimden eminim ama sonra.

: p Golf sahası olmayan esolang normal maçları atıyor:

Turtlèd ile ilgili garip olan şey, asci sanat sanatıyla ilgili tartışmalardan sonra yapıldığı, ancak aslında bu tür zorluklarda en iyisi olduğu görülüyor

Turtlèd yeni satır girişini alamaz, ancak çoklu girişler için bu yalnızca bir giriş alır: her sözcüğü, sonuncusu da dahil olmak üzere bir boşlukla sonlandırın.

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

Çevrimiçi deneyin!

Açıklama:

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

Bu, kafamda çok zor olmaktan, kolay olmaktan, beklediğimden çok daha fazla kod olmaktan geçen zorluklardan biriydi ... Bu yaklaşımdan özellikle memnun değilim, eminim ki print pop@F...Belki kullanmak -nya da sadece saf regex bit azaltmak için çok daha iyi bir yol , ama şu anda oraya gidemem ... Aslen kullanıyordum say, ama sanırım bu yüzden daha yüksek puan almak zorunda kalırdım ( 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

kullanım

Olarak kaydet vertically-collapse-text.pl.

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

SmileBASIC, 90 bayt

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

Konsoldaki tüm metne yerçekimi uygular. Bunun geçerli olup olmadığından veya bir dize dizisi kullanmam gerekip gerekmediğinden emin değilim.

Ruby, 99 82 bayt

Oraya gitmek ...

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

Denenen bir açıklama:

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

Bu şekilde çalıştırın:

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"

açıklama

x@\:!|/#:'x bir kare char matrisi oluşturmak için her dizeyi genişletir.

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

+ transpoze eder

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} Bir dizgideki boşlukları kaldıracak ve sonra dizgiyi asıl uzunluğuna göre dolduracak

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

Bu işlevi aktarılan dizelerin her birine uygulayın, ardından sonucu elde etmek için çıktıyı çevirin

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

pb - 310 bayt

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

Ne felaket. Nasıl çalıştığı hakkında hiçbir şey hatırlamıyorum.

Pb'nin girişinin çalışma şekli (bir kerede tek bir satır) nedeniyle girişteki yeni satırlar yerine boşluk kullanmanız gerekir. Tercüman çöp değilse ve girdiye yeni satırlar ekleyebilirseniz, tek değişiklik [B=32]başlangıçtaki başlangıç olacaktır [B=10].

Programın çalışmasını izlemek istiyorsanız görselleri temizleyen pbi'ye (tercüman) yönelik bir güncelleme üzerinde çalışıyorum. Hala çok fazla çalışmaya ihtiyacı var ama bu arada bu programı YouTube'da izleyebilirsiniz .

J, 17 bayt

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

Oldukça hoş bir çözüm.

Açıklama:

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

Test durumu açıklandı

   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

Test durumları

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

Aslında , 13 bayt

Bu Dennis'in Jelly cevabında açıklanan algoritmayı kullanır . Giriş ve çıkış her iki dizenin listesidir. Maalesef, yerleşik transpozisyon işlevi, iç listeler veya dizgilerin hepsi aynı uzunlukta değilse, bu, ilk olarak dikey çöküş noktasını yenecek türden çok iyi çalışmaz. Golf önerileri kabul edilir. Çevrimiçi deneyin!

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.

Raket 312 bayt

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

Ungolfed:

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

Test yapmak:

(f "Programming Puzzles & Code Golf")

Çıktı:

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

JavaScript (ES6), 103 bayt

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'de bölünmüş dış harita, "yerçekimi" nin harfleri düşmesi gereken yere kadar bırakmasını sağlamak için yeterince döngü oluşturmamızı sağlar.

İç harita ilk önce bir sonraki satır olup olmadığını kontrol eder, eğer öyleyse ve daha kısa ise, taşma işlemini bir sonraki satıra bırakın. örneğin, 1. satırda "ABCD" ve 2. satırda "FG" varsa, "CD" yi 1. satırdan 2. satıra bırakın, böylece 1. satır "AB" olur ve 2. satır "FGCD" olur.

Bunu satırların olduğu kadar çok yaptığımız gibi, harfler olması gerektiği kadar düşer ve bizi istenen sonucu bırakır.

Japt , 8 bayt

y kS ù y

Çevrimiçi deneyin!

Nasıl çalışır

Uy kS ù y

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

Ayrıca z2B dizeyi 90 derecenin katları kadar döndüren de var , ancak bir şekilde dizeyi keser height > length.

05AB1E , 10 9 bayt

¶¡RζðмζR»

Çevrimiçi deneyin.

veya alternatif bir başlangıçla:

.BRøðмζR»

Çevrimiçi deneyin.

@ Dennis ile benzer bir yaklaşım answer 'Pyth answer .
-1 bayt sayesinde @Emigna değiştirilmesi ðõ:ileðм .

Açıklama:

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

Alternatif açıklama:

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

R, s81 52 bayt

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

Sorunun yorumlanmasında biraz özgürlük gördüm ve metnin hücre başına bir karakter içeren bir matriste temsil edildiğini varsaydım.

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

Böylece x olur:

     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 

Şimdi kullanıyorum orderve [sütunları NA'nın ilk önce diğer değerlerden gelmesi için sıralıyorum:

     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"

Çıktının kelimeler olması gerekirse daha uzun olur:

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 bayt

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}

İnsan tarafından okunabilen bir versiyon:

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
}                            

Nasıl çalışır:

1. İlk "kötü" satırı, yani bir sonraki satırdan daha uzun olan satırı alın, "ekstra" kısmı alın ve bir sonraki satıra ekleyin
2. Herhangi bir "kötü" satır olup olmadığını kontrol edin, evet ise # 1'e gidin

(Başka bir deyişle, "gereksiz" kısımlar, düşebilecek her şey düşene kadar düşer.)

Giriş: Bir karakter vektörü.

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

Julia 0.6 , 141 bayt

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

Çevrimiçi deneyin!

İle yayın yapmak g.([w], [d d])herhangi bir harita ifadesinden kurtulmamı sağlar ve beni 7 bayta kadar kurtarır.