垂直折叠文字


85

说我有这样的文本(每个单词一行,没有空格)

Programming
Puzzles
&
Code
Golf

这是没有意义的!它完全违背了物理定律。

您的挑战是要纠正这种不可能的情况并像这样折叠文本:

P
Prog
&uzz
Coderam
Golflesming

因此,在任何字符下方都没有空白,但是字符保持了垂直顺序。

目的是满足要求,但使用尽可能少的源代码字节。


12
另外,每行是一个单词,还是会有空格?如果有空间,它们应该坍塌,还是空间可以承受重量?
Glen O

53
“P&PROG uzz Coderam Golflesming”,听起来像有该网站的标题一个新的候选..
JCAI

1
有人要使用Marbelous(github.com/marbelous-lang/marbelous.py)吗?
查理

1
我决定使用物理引擎并保留一个0字节
l4m2,18年

2
输出中是否可以包含尾随空格?
暴民埃里克(Erik the Outgolfer)

Answers:


57

Pyth,10个字节

jb_.T.T_.z

Pyth编译器/执行器上在线尝试。

理念

我们可以通过应用四个简单的转换来获得所需的输出:

  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.

1
Grr,将要发布的正是这个:)。代之以投票。
Maltysen,2015年

我也有计划发布类似的内容...也正在投票
WallyWest

如果在反转顺序之前转置行和列会发生什么?
John Odom 2015年

1
@JohnOdom只需简单地转置两次即可将字符移至顶部,而不是将其移至底部。您可以从转置开始,然后必须反转每一行,这将长一字节。
丹尼斯

神圣的FoxPro,这很聪明。
workoverflow

38

Haskell,62个字节

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

我很成熟


20
+1,因为我很少见过Haskell,还有排便。
Carcigenicate,2015年

17

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使用元素末尾(左侧)的输出列表的a在输出列表中以空行(右侧)的优先级并在新元素的长度处截去每个部分。

相反地​​,向后迭代似乎更自然,让新字母从顶部掉下来,但我尝试这样做的时间更长。

为了进行比较,这是一个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])

12

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.

7

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>


替换S(t.reverse()),t.reverse().join为减少几个字节S(R=t.reverse()),R.join
Ismael Miguel

@IsmaelMiguel否,S会更改t,因此S之后的t与S之前的t不相同
edc65

5

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

您可以 在线尝试


5

Matlab /八度,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))

范例

在变量中定义输入字符串,例如s10是换行符:

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

f带输入的调用函数s

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

在线尝试(感谢@beaker提供在线Octave解释器的帮助)


4

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>



3

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
>   

3

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个字节。


为什么您的提交仅由于需要非自由的编译器而无效?
丹尼斯

@Dennis我认为这是在meta中决定的,编程语言必须在某些自由环境中可运行。同样,对输入长度的限制可能会使它无效。
bmark

1
字符限制将是一个问题,但是我不知道任何需要自由实现的元共识。(如果您是从“ Hello World”测验中获得这个想法的,则该问题明确要求使用免费语言。)
Dennis

@Dennis我想这是一个共识:meta.codegolf.stackexchange.com/questions/988/...
bmarks

答案建议降低无法测试的帖子的数量,这实际上并不需要共识,而且在实践中不会发生。实际上,Mathematica和TI-BASIC答案通常很受欢迎。
丹尼斯

2

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

2

果冻,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.

2

Turtlèd,72字节,无竞争

可以肯定的是,我可以更改保存字节的方法,但是稍后。

:p非高尔夫esolang击败常规lang:p

Turtlèd的奇怪之处在于它最初是在讨论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

2

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

2

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.

将重力应用于控制台中的所有文本。我不确定这是否有效,或者我是否必须使用字符串数组。


1

红宝石, 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]

1

K,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"

{+{(-#x)$x@&~^x}'+(|/#:'x)$x}
29。– streetster

1

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上观看此程序


1

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
FrownyFrog

1

其实,13个字节

这使用了Dennis的Jelly答案中描述的算法。输入和输出都是字符串列表。不幸的是,如果内部列表或字符串的长度不一样,则内置的转置功能将无法很好地工作,这首先会破坏垂直折叠的点。欢迎打高尔夫球。在线尝试!

R2`;i(lZ♂Σ`nR

开球

          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.

1

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

1

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上拆分,外部地图可确保我们循环足够的时间,以允许“重力”将字母放到需要放下的程度。

内部映射首先检查是否有下一行,如果有,则较短,将溢出的内容放到下一行。例如,如果第一行具有“ ABCD”,第二行具有“ FG”,则将“ CD”从第一行放到第二行,以使第一行变为“ AB”,第二行变为“ FGCD”。

由于我们会尽可能多地执行这些操作,因此字母会尽可能地下降,从而使我们获得理想的结果。


1

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


7个字节。顺便说一下,欢迎您来到Japt(如果我还没有欢迎您的话)。
粗野的

1

05AB1E10 9 字节

¶¡RζðмζR»

在线尝试。

或使用其他开始:

.BRøðмζR»

在线尝试。

@ Dennis♦的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

1

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[对列进行排序,以使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"

欢迎(返回)PPCG!只要OP适合您的格式,您就可以放心!通常的方法是在对问题的评论中提出。
JayCe

如您对另一个问题的回答中所述,答案必须是完整功能或程序,因此function(x)需要包含在字节数中。
JayCe

1

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

朱莉娅 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])使我摆脱了任何map语句,并节省了大约7个字节。

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.