関連：水平方向に似た（ただしはるかに簡単な）課題： そこに固定（テープを使用）

チャレンジ：

大文字および/または小文字（どちらでもかまいません）と改行のみを含む文字列が与えられた場合、rope垂直に配置して修正します。これを行うには、アルファベット内の2つの隣接する文字の違いを確認し（折り返しを無視して下向きにするだけ）、スペースを必要なだけROPE/ で埋めropeます。
注：この課題と（テープを使用して）修正したThere のもう 1つの重要な違いは、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

どうして？

• 列間bおよびd列1はc（長さ1）でなければならないため、これをR;で埋めます。
• 列間eおよびg列1はf（長さ1）でなければならないため、これをO;で埋めます。
• 列間fおよびk列2はghij（長さ4）でなければならないため、これをPERO;で埋めます。
• 列の間kとm列2はl（長さ1）でなければならないので、これをP;で埋めます。
• 列間dおよびc列3はefghijklmnopqrstuvw（長さ19）でなければならないので、これをEROPEROPEROPEROPERO;で埋めます。
• 列間xおよびz列3はy（長さ1）でなければならないため、これをP;で埋めます。
• 列間aおよびh列3はbcdefg（長さ6）でなければならないため、これをで埋めEROPERます。

チャレンジルール：

• 違いは下向きにのみ適用されるため、間にロープはありませんza（上の例の列3）。
• dd（上記の例では列3）のように、同じ隣接する文字を複数持つことができます。
• ROPEパーツを無駄にしないために、一度に1列ずつ使用します（チャレンジのパート1で@JonathanAllanが推奨）。
• 妥当な形式で入力することができます。単一の文字列、文字列配列/リスト、文字マトリックスなどを使用できます。出力にも同じ柔軟性があります。
• 小文字や大文字を自由に使用できます。これは、入力、出力、およびの両方に適用されますROPE。
• 末尾のスペースはオプションです（列が正しいように、適切な量の先頭のスペースが必須であることに注意してください）。
  後続および/または先頭の改行の量も任意です。
• すべてのテストケースがすべての行で同じ長さであると想定できるため、a\naa/[[a][a,a]]は有効な入力ではありません。
• それは何もできないROPE入力が変わらない、その場合には、必要です。

一般的なルール：

• これはcode-golfなので、バイト単位の最短の回答が優先されます。
  コードゴルフ言語では、コードゴルフ言語以外の言語で回答を投稿しないようにしないでください。「あらゆる」プログラミング言語について、可能な限り短い答えを考え出すようにしてください。
• 標準ルールが適用されます回答にはため、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バイト-Erik the Outgolferによる
2バイト

05AB1E、38 37 25バイト

Magic Octopus Urnからの提案と出力形式を変更する別のバイトで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])

オンラインでお試しください！

• ovsのおかげで-3バイト

Ruby、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データの前処理と後処理を実行するので、より管理しやすい文字列を指定して、結果を適切に出力できます。

説明

コードは、入力配列を2回パスします。

最初のパスではreduce、文字間のスペースを必要な量のROPE（y.ord-x[-1].ord-1正の場合は文字）で埋める操作を適用します。また、使用されたROPEの長さ（l）も追跡する必要があります。

TAPEの場合とは異なり、rjust常にR文字から始まるため、単純に塗りつぶしに使用することはできません。その代わりに、特にlオンザフライで更新する必要があるため、長い「ROPEROPE ...」文字列の適切なスライスを取得することで、バイト数が軽くなるように見えます。

2番目のパスでは、結果の文字列をスペースで左揃えして、最も長い文字列の長さに一致させます。ここでは前の反復の完全な結果が必要なので、最初のパスで配列を変更します（したがってmap!、ではありませんmap）。

-1バイト（Kevin Cruijssenのおかげ）

Jonathan Frechのおかげで-70バイト、すごい.......

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