相关：横向比较相似（但容易得多）的挑战：在那里（用胶带固定）

挑战：

给定仅包含大写和/或小写字母（以您喜欢的为准）和换行符的字符串，请rope垂直放置以对其进行修复。为此，我们检查字母表中两个相邻字母的差异（忽略环绕并且仅向下移动），并在需要的地方填充ROPE/ rope。
注意：此挑战与“ 我已解决（使用磁带）”挑战之间的另一个主要区别是，这次我们没有浪费rope我们的时间tape（在挑战的第一部分中，@ JonathanAllan建议）。

例：

输入：

abc
bcd
ddd
eex
gfz
hka
imh

输出：

abc
bcd
Rdd
deE
efR
OPO
gEP
hRE
iOR
 kO
 PP
 mE
  R
  O
  P
  E
  R
  O
  P
  E
  R
  O
  x
  P
  z
  a
  E
  R
  O
  P
  E
  R
  h

为什么？

• 第1列之间b和第d1列之间应为c（长度1），因此我们将其填充为R;
• 第1列之间e和第g1列之间应为f（长度1），因此我们将其填充为O;
• 第2列之间f和第k2列之间应为ghij（长度4），因此我们将其填充为PERO;
• 第2列之间k和第m2列之间应为l（长度1），因此我们将其填充为P;
• 第3列之间d和c之中应为efghijklmnopqrstuvw（长度19），因此我们将其填充为EROPEROPEROPEROPERO;
• 第3列之间x和z之中应为y（长度1），因此我们将其填充为P;
• 第3列之间a和h之中应为bcdefg（长度6），因此我们用填充EROPER。

挑战规则：

• 差异仅适用于向下，因此之间没有绳索za（上例中的第3列）。
• 可能有多个相同的相邻字母，例如dd（上例中的第3列）。
• 您将ROPE一次一次继续使用一列以不浪费零件（挑战中第1部分中@JonathanAllan的建议）。
• 您可以采用任何合理的格式输入。可以是单个字符串，字符串数组/列表，字符矩阵等。输出具有相同的灵活性。
• 您可以随意使用小写和/或大写字母。这适用于输入，输出和ROPE。
• 尾随空格是可选的（请注意，必须有正确数量的前导空格，因此列是正确的）。
  任意数量的尾随和/或前导换行符也是可选的。
• 您可以假设所有测试用例在所有行上的长度都相同，因此a\naa/ [[a][a,a]]并不是有效的输入。
• 可能没有ROPE必要，在这种情况下，输入保持不变。

通用规则：

• 这是代码高尔夫球，因此最短答案以字节为单位。
  不要让代码高尔夫球语言阻止您使用非代码高尔夫球语言发布答案。尝试针对“任何”编程语言提出尽可能简短的答案。
• 标准规则适用于您的答案，因此允许您使用STDIN / STDOUT，具有正确参数的函数/方法和返回类型的完整程序。您的来电。
• 默认漏洞是禁止的。
• 如果可能的话，请添加一个带有测试代码的链接。
• 另外，如有必要，请添加说明。

测试用例：

As string:
 Input:  "abc\nbcd\nddd\neex\ngfz\nhka\nimh"
 Output: "abc\nbcd\nRdd\ndeE\nefR\nOPO\ngEP\nhRE\niOR\n kO\n PP\n mE\n  R\n  O\n  P\n  E\n  R\n  O\n  P\n  E\n  R\n  O\n  x\n  P\n  z\n  a\n  E\n  R\n  O\n  P\n  E\n  R\n  h"
As array-matrix:
 Input:  [[a,b,c],[b,c,d],[d,d,d],[e,e,x],[g,f,z],[h,k,a],[i,m,h]]
 Output: [[a,b,c],[b,c,d],[R,d,d],[d,e,E],[e,f,R],[O,P,O],[g,E,P],[h,R,E],[i,O,R],[ ,k,O],[ ,P,P],[ ,m,E],[ , ,R],[ , ,O],[ , ,P],[ , ,E],[ , ,R],[ , ,O],[ , ,P],[ , ,E],[ , ,R],[ , ,O],[ , ,x],[ , ,P],[ , ,z],[ , ,a],[ , ,E],[ , ,R],[ , ,O],[ , ,P],[ , ,E],[ , ,R],[ , ,h]]

As string:
 Input:  "a\nz\na"
 Output: "a\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nz\na"
As array-matrix:
 Input:  [[a],[z],[a]]
 Output: [[a],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[z],[a]]

As string:
 Input:  "zz\nyy\nxx\nxx\ncc\ncc\nbb\nad"
 Output: "zz\nyy\nxx\nxx\ncc\ncc\nbb\naR\n d"
As array-matrix:
 Input:  [[z,z],[y,y],[x,x],[x,x],[c,c],[c,c],[b,b],[a,d]]
 Output: [[z,z],[y,y],[x,x],[x,x],[c,c],[c,c],[b,b],[a,R],[ ,d]]

As string:
 Input:  "a\nb\nc\nc\nx\nx\ny\nz"
 Output: "a\nb\nc\nc\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nx\nx\ny\nz"
 As array-matrix:
  Input:  [[a],[b],[c],[c],[x],[x],[y],[z]]
  Output: [[a],[b],[c],[c],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[x],[x],[y],[z]]

As string:
 Input:  "zai\nybj\nxcq\nxcu\ncxw\ncxw\nbyr\nazw"
 Output: "zai\nybj\nxcR\nxcO\ncRP\ncOE\nbPR\naEO\n Rq\n OP\n PE\n ER\n Ru\n OO\n Pw\n Ew\n Rr\n OP\n PE\n ER\n RO\n Ow\n P \n E \n x \n x \n y \n z "
As array-matrix:
  Input:  [[z,a,i],[y,b,j],[x,c,q],[x,c,u],[c,x,w],[c,x,w],[b,y,r],[a,z,w]]
  Output: [[z,a,i],[y,b,j],[x,c,R],[x,c,O],[c,R,P],[c,O,E],[b,P,R],[a,E,O],[ ,R,q],[ ,O,P],[ ,P,E],[ ,E,R],[ ,R,u],[ ,O,O],[ ,P,w],[ ,E,w],[ ,R,r],[ ,O,P],[ ,P,E],[ ,E,R],[ ,R,O],[ ,O,w],[ ,P, ],[ ,E, ],[ ,x, ],[ ,x, ],[ ,y, ],[ ,z, ]]

As string:
 Input:  "asdljasdjk"
 Output: "asdljasdjk"
As array-matrix:
 Input:  [[a,s,d,l,j,a,s,d,j,k]]
 Output: [[a,s,d,l,j,a,s,d,j,k]]

As string:
 Input:  "asdljasdjk\nlkawdasuhq\nasjdhajksd"
 Output: "asdljasdjk\nRkaOdasPhR\nOPOPEajEPO\nPEPER  REP\nERERO  ORE\nROROh  POR\nOPOP   EPq\nPEPE   ROd\nERER   OR \nRsRO   PO \nO jP   EP \nl  w   RE \na  d   Os \n       P  \n       E  \n       R  \n       O  \n       u  \n       k  "
As array-matrix:
 Input:  [[a,s,d,l,j,a,s,d,j,k],[l,k,a,w,d,a,s,u,h,q],[a,s,j,d,h,a,j,k,s,d]]
 Output: [[a,s,d,l,j,a,s,d,j,k],[R,k,a,O,d,a,s,P,h,R],[O,P,O,P,E,a,j,E,P,O],[P,E,P,E,R, , ,R,E,P],[E,R,E,R,O, , ,O,R,E],[R,O,R,O,h, , ,P,O,R],[O,P,O,P, , , ,E,P,q],[P,E,P,E, , , ,R,O,d],[E,R,E,R, , , ,O,R, ],[R,s,R,O, , , ,P,O, ],[O, ,j,P, , , ,E,P, ],[l, , ,w, , , ,R,E, ],[a, , ,d, , , ,O,s, ],[ , , , , , , ,P, , ],[ , , , , , , ,E, , ],[ , , , , , , ,R, , ],[ , , , , , , ,O, , ],[ , , , , , , ,u, , ],[ , , , , , , ,k, , ]]

As string:
 Input:  "re\nop\npo\ner"
 Output: "re\noR\npO\neP\n E\n R\n O\n P\n E\n R\n O\n p\n o\n P\n E\n r"
As array-matrix:
 Input:  [[r,e],[o,p],[p,o],[e,r]]
 Output: [[r,e],[o,R],[p,O],[e,P],[ ,E],[ ,R],[ ,O],[ ,P],[ ,E],[ ,R],[ ,O],[ ,p],[ ,o],[ ,P],[ ,E],[ ,r]]

果冻，21字节

ZµOI’R“¡nⱮ»ṁż@"µF€z⁶Y

在线尝试！

说明

ZµOI’R“¡nⱮ»ṁż@"µF€z⁶Y  Main Link
Z                      Transpose the input so the columns are now rows
 µ                     New monadic chain
  O                    [Vectorizing] Convert each letter to its character code
   I                   [Vectorizing] Get the differences (gap size)
    ’                  [Vectorizing] Add one
     R                 [Vectorizing] Range from 1 .. x
           ṁ           Mold the string        into the ranges
      “¡nⱮ»                            "rope"
            ż@"        Vectorizing zip the rope strings with the original string (place ropes in gaps)
               µ       New monadic chain
                F€     Flatten Each
                  z⁶   Zip and fill with spaces
                    Y  Join on newlines for output

Xcoder先生为-1字节-Outgolfer的
Erik为-2字节

05AB1E，38 37 25字节

在魔术八爪鱼缸的建议下保存了10个字节，另一个字节更改了输出格式。

输出字符串列表。
页脚漂亮的印花。

'ÙºUζεDÇ¥<)ζε`FX¬sÀU}J]Jζ

在线尝试！

说明

'ÙºU                       # store the string "rope" in variable X
    ζ                      # transpose input
     ε                ]    # for each transposed row
      D   )ζ               # zip the row with
       ǥ<                 # the decremented deltas of its character codes  
            ε              # for each pair of [letter, delta-1]
             `F     }      # delta-1 times do:
               X¬          # get the first letter of X (originally "rope")
                 sÀU       # rotate the letters left by 1 and store in X 
                     J     # join the rope-letter to the current row-letter
                       J   # join to list of strings (the new columns)
                        ζ  # transpose

Python 2中，197个 194字节

def f(s):
 r='ROPE'*len(`s`)*9;x=[]
 for i in zip(*s):
	x+='',
	for c,C in zip(i,i[1:]+(' ',)):l=(C>c)*(ord(C)+~ord(c));x[-1]+=c+r[:l];r=r[l:]
 print zip(*['%*s'%(-max(map(len,x)),s)for s in x])

在线尝试！

• -3个字节，感谢ovs

红宝石，119字节

->a{l=0;a.map!{|r|r.reduce{|x,y|x+("ROPE"*7)[l%4,-l+l+=[0,y.ord+~x[-1].ord].max]+y}}.map{|s|s.ljust a.map(&:size).max}}

在线尝试！

是的，这比“ TAPE”挑战要困难得多。我尝试建立针对该任务的解决方案，但这有一些额外的变数。

将输入作为字符的列式数组，以字符串形式返回字符串数组。TIO链接页脚中的代码执行I / O数据的预处理和后处理，以便我们可以提供更易于管理的字符串，然后很好地打印结果。

说明

该代码通过输入数组两次。

在第一遍中，我们应用reduce以所需的ROPE量（y.ord-x[-1].ord-1字符为正数）填充字符之间的空间的操作。我们还需要跟踪使用的ROPE长度（l）。

与TAPE情况不同，我们不能简单地使用rjust填充，因为它总是从R字符开始。取而代之的是，从字节数上看，取一个适当的长“ ROPEROPE ...”字符串切片似乎比较轻松，特别是因为我们还需要l即时更新。

在第二遍中，我们用空格左对齐结果字符串，以匹配最长的字符串的长度。由于这里需要上一次迭代的完整结果，因此第一遍将就地修改数组（因此map!，不是map）。

-1个字节，感谢Kevin Cruijssen

-70字节，感谢Jonathan Frech，哇...

Python 3，203字节

def f(s,c=0,x=()):
	for i in range(len(s[0])):
		p,o=" ",""
		for j in s:t=j[i];y=p>' 'and~ord(p)+ord(t);o+=('ROPE'*y)[c:y+c]+t;c,p=c%4+y*(y>=0)%4,t
		x+=o,
	for i in x:yield i.ljust(len(max(x,key=len)))

在线尝试！

Python 3，182字节

from itertools import*
def f(l):r=cycle('ROPE');return zip_longest(*(''.join(c+''.join(islice(r,max(ord(n)+~ord(c),0)))for c,n in zip(z,z[1:]+(' ',)))for z in zip(*l)),fillvalue=' ')

在线尝试！

该函数将其输入作为字符串列表（或可迭代），并返回一个字符串序列的生成器，该字符串序列几乎与列表一样好。

不打高尔夫球

…以提高嵌套生成器的可读性。

def f(l):
    r = cycle('ROPE')
    return zip_longest(
        *(
            ''.join(
                c + ''.join(islice(r, max(ord(n) - ord(c) - 1, 0)))
                for c, n in zip(z, z[1:] + (' ',)))
            for z in zip(*l)),
        fillvalue=' ')

说明

1. 该函数用于zip将输入的行列表转置为列生成器。

2. 最里面的生成器查看成对的相邻字符，然后…

3. … 从（无限）生成器中切出所需的连续 ROPE 量cycle。

4. 在生成器产生大量字符串连接后，该函数将列列表重新换位到生成器或行，并用填充缺少的条目zip_longest。

Stax，25 个字节

ÅiV╘ε╢+gA┘♦W[≈{`Co?-φvM«'

在线运行和调试！

输入和输出以空格分隔的列表形式给出。输入是所需的行列表，输出是允许的列列表。

说明

使用解压后的版本进行解释。

M"ROPE"s{2B{Ev|r%b:m~|(,m_s\mJ
M                                 Transpose
 "ROPE"                           The string "ROPE"
       s{                   mJ    Map each column (in the original input) with block, and output with space as the separator
         2B                       All contiguous pairs of current column
           {            m         Map each pair with block
            Ev|r%                     Pair [j,k] to length of range [j..k-2]
                 b:m                  Repeat current repeating string to given length
                    ~                 Last line gives the result the pair should map to, now store it on the input stack
                     |(               Rotate current repeating string `p` times, where `p` is the length of the range [j..k-1]
                       ,              Fetch back the result
                         _s\      Zip with current column, filling missing element with empty string