ที่เกี่ยวข้อง: ความท้าทายค่อนข้างคล้ายกัน (แต่ง่ายกว่ามาก) ในแนวนอน: ที่นั่นฉันซ่อมมัน (ด้วยเทป)

ท้าทาย:

กำหนดสตริงที่มีตัวอักษรพิมพ์ใหญ่และ / หรือตัวพิมพ์เล็ก (แล้วแต่จำนวนใดก็ได้ที่คุณต้องการ) และขึ้นบรรทัดใหม่ใส่ใน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

ทำไม?

• ระหว่าง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คอลัมน์ต่อครั้งเพื่อไม่ให้เสียชิ้นส่วน (แนะนำโดย@JonathanAllanในส่วนที่ 1 ของการท้าทาย)
• คุณได้รับอนุญาตให้ป้อนข้อมูลในรูปแบบที่เหมาะสม สามารถเป็นสตริงเดี่ยวสตริงอาร์เรย์ / รายการอักขระเมทริกซ์ ฯลฯ เอาต์พุตมีความยืดหยุ่นเหมือนกัน
• คุณได้รับอนุญาตให้ใช้ตัวพิมพ์เล็กและ / หรือพิมพ์ใหญ่ในแบบที่คุณต้องการ 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

-1 ไบต์ขอบคุณ Mr. Xcoder
-2 ไบต์ขอบคุณ Erik the Outgolfer

05AB1E , 38 37 25 ไบต์

บันทึก 10 ไบต์พร้อมคำแนะนำจากMagic Octopus Urnและรูปแบบเอาต์พุตที่เปลี่ยนไปอีกหนึ่งไบต์

ส่งออกรายการของสตริง
ส่วนท้ายพิมพ์สวย

'Ùº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

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 ก่อนและหลังการประมวลผลเพื่อให้เราสามารถจัดหาสตริงที่จัดการได้มากขึ้นแล้วพิมพ์ผลลัพธ์ได้อย่างดี

คำอธิบาย

รหัสทำให้สองผ่านผ่านอาร์เรย์ใส่

ในรอบแรกเราใช้การ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=' ')

ลองออนไลน์!

ฟังก์ชั่นรับอินพุตเป็นรายการ (หรือ iterable) ของสตริงและยังส่งคืนตัวกำเนิดสำหรับลำดับของสตริงซึ่งเกือบจะดีเท่ากับรายการ

Ungolfed

... เพื่อการอ่านที่ดีขึ้นของเครื่องกำเนิดไฟฟ้าที่ซ้อนกัน

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. หลังจากปริมาณมากของสตริงเข้าร่วมจากเครื่องปั่นไฟฟังก์ชั่นใหม่ transposes 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