관련 : 비슷한 (그러나 훨씬 더 쉬운) 수평으로 도전하십시오 : 테이프로 고정했습니다.

도전:

대문자 및 / 또는 소문자 (원하는 쪽)와 줄 바꾸기 만 포함 된 문자열이 있으면 rope세로로 넣어서 수정하십시오. 우리는 알파벳에서 인접한 두 문자의 차이를 확인하여이 작업을 수행 (랩 어라운드를 무시하고 단지 아래로가는), 그리고 많은으로 공간을 채우는 ROPE/ rope우리가 필요로.
참고 :이 도전과 내가 해결 한 (테이프가있는) 도전과의 또 다른 주요 차이점은 ( 도전 중 하나에서 @JonathanAllan 이 제안한) rope것처럼 우리 가이 시간을 낭비하지 않는다는 것입니다.tape

예:

입력:

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와 k열의 ghij길이 (길이 4) 여야합니다 PERO.
• 열 2 사이 k와 m열의 l길이 는 (길이 1) 이어야합니다 P.
• 열 3 d과 c열 사이의 efghijklmnopqrstuvw길이 (길이 19) 가되어야합니다 EROPEROPEROPEROPERO.
• 열 3 사이 x와 z열의 y길이 는 (길이 1) 이어야합니다 P.
• 3 열 사이 a와 h3 열은 bcdefg(길이 6)이되어야 EROPER합니다.

도전 규칙 :

• 차이는 아래쪽에만 적용되므로 사이에 로프가 없습니다 za(위 예의 3 열).
• dd(위의 예에서 3 열) 과 같은 동일한 인접 문자를 여러 개 가질 수 있습니다.
• ROPE한 번에 한 열을 계속 사용하여 부품을 낭비하지 않습니다 ( 도전 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 바이트
, Outgolfer Erik 덕분에 -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

파이썬 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 바이트

루비 , 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).

Kevin Cruijssen 덕분에 -1 바이트

Jonathan Frech 덕분에 -70 바이트 , 와우 .......

파이썬 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)))

온라인으로 사용해보십시오!

파이썬 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