Terkait: Tantangan yang agak mirip (tapi jauh lebih mudah) secara horizontal: Di sana saya memperbaikinya (dengan kaset)

Tantangan:

Diberikan string yang hanya berisi huruf besar dan kecil (mana saja yang Anda suka) dan baris baru, masukkan ropesecara vertikal untuk memperbaikinya. Kami melakukan ini dengan memeriksa perbedaan dua huruf yang berdekatan dalam alfabet (mengabaikan pembungkus dan hanya turun ke bawah), dan mengisi ruang dengan sebanyak ROPE/ yang ropekita butuhkan.
CATATAN: Satu perbedaan utama lainnya antara tantangan ini dan tantangan Di sana saya memperbaikinya (dengan pita) adalah bahwa kita tidak membuang-buang ropewaktu seperti yang kita lakukan dengan tape(disarankan oleh @ Jonathan Allan di bagian satu dari tantangan).

Contoh:

Memasukkan:

abc
bcd
ddd
eex
gfz
hka
imh

Keluaran:

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

Mengapa?

• Antara bdan ddi kolom 1 harus c(panjang 1), jadi kami isi ini dengan R;
• Antara edan gdi kolom 1 harus f(panjang 1), jadi kami isi ini dengan O;
• Antara fdan kdi kolom 2 harus ghij(panjang 4), jadi kami isi ini dengan PERO;
• Antara kdan mdi kolom 2 harus l(panjang 1), jadi kami isi ini dengan P;
• Antara ddan cdi kolom 3 harus efghijklmnopqrstuvw(panjang 19), jadi kami isi dengan ini EROPEROPEROPEROPERO;
• Antara xdan zdi kolom 3 harus y(panjang 1), jadi kami isi ini dengan P;
• Antara adan hdi kolom 3 harus bcdefg(panjang 6), jadi kami isi dengan ini EROPER.

Aturan tantangan:

• Perbedaannya hanya berlaku ke bawah, jadi tidak ada tali di antara za(kolom 3 pada contoh di atas).
• Dimungkinkan untuk memiliki beberapa huruf berdekatan yang sama seperti dd(kolom 3 pada contoh di atas).
• Anda akan terus menggunakan ROPEkolom satu per satu untuk tidak membuang-buang bagian (disarankan oleh @JonathanAllan di bagian 1 dari tantangan).
• Anda diizinkan mengambil input dalam format apa pun yang masuk akal. Dapat berupa string tunggal, string-array / daftar, karakter-matriks, dll. Output memiliki fleksibilitas yang sama.
• Anda diizinkan menggunakan huruf kecil dan / atau huruf besar dengan cara apa pun yang Anda inginkan. Ini berlaku untuk input, output, dan ROPE.
• Ruang tambahan adalah opsional (perhatikan bahwa jumlah ruang utama yang benar adalah wajib sehingga kolomnya benar).
  Jumlah trailing dan / atau baris baru yang baru juga opsional.
• Anda dapat mengasumsikan bahwa semua kasus uji akan memiliki panjang yang sama di semua baris, jadi a\naa/[[a][a,a]] tidak akan menjadi input yang valid.
• Mungkin tidak ROPEdiperlukan, dalam hal ini input tetap tidak berubah.

Aturan umum:

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
  Jangan biarkan bahasa kode-golf mencegah Anda dari memposting jawaban dengan bahasa yang bukan kode. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa pun'.
• Aturan standar berlaku untuk jawaban Anda, jadi Anda diperbolehkan menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat dan tipe pengembalian, program penuh. Panggilanmu.
• Celah default tidak diperbolehkan.
• Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda.
• Juga, silakan tambahkan penjelasan jika perlu.

Kasus uji:

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]]

Jelly , 21 byte

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

Cobalah online!

Penjelasan

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 byte terima kasih kepada Tn. Xcoder
-2 byte terima kasih kepada Erik the Outgolfer

05AB1E , 38 37 25 byte

Disimpan 10 byte dengan saran dari Magic Octopus Guci dan byte lain mengubah format output.

Menghasilkan daftar string.
Footer cetakan cantik.

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

Cobalah online!

Penjelasan

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

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])

Cobalah online!

• -3 bytes terima kasih kepada ovs

Ruby , 119 byte

->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}}

Cobalah online!

Ya, ini jauh lebih sulit daripada tantangan "TAPE". Saya mencoba membangun solusi saya untuk tugas itu, tetapi ini memiliki beberapa tikungan tambahan.

Mengambil input sebagai array karakter berbentuk kolom, mengembalikan array string, juga dalam format berbentuk kolom. Kode di footer dari tautan TIO melakukan pra-dan pasca pemrosesan data I / O sehingga kami dapat menyediakan string yang lebih mudah dikelola dan kemudian mencetak hasilnya dengan baik.

Penjelasan

Kode membuat dua melewati array input.

Pada pass pertama kami menerapkan reduceoperasi yang mengisi ruang antara karakter dengan jumlah ROPE yang diperlukan ( y.ord-x[-1].ord-1karakter, jika positif). Kita juga perlu melacak panjang ROPE yang digunakan ( l).

Tidak seperti dalam kasus TAPE kita tidak bisa hanya menggunakan rjustuntuk mengisi, karena itu akan selalu dimulai dari karakter R. Alih-alih, mengambil string yang tepat dari string "ROPEROPE ..." yang panjang tampaknya lebih ringan pada hitungan byte, terutama karena kita juga perlu memperbarui ldengan cepat.

Di umpan kedua kami meninggalkan-menjustifikasi string yang dihasilkan dengan spasi untuk mencocokkan panjang yang terpanjang dari mereka. Karena kita membutuhkan hasil lengkap dari iterasi sebelumnya di sini, pass pertama memodifikasi array di tempatnya (karenanya map!, tidak map).

-1 byte, terima kasih kepada Kevin Cruijssen

-70 byte terima kasih kepada Jonathan Frech , wow .......

Python 3 , 203 byte

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)))

Cobalah online!

Python 3 , 182 byte

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=' ')

Cobalah online!

Fungsi mengambil inputnya sebagai daftar (atau iterable) string dan juga mengembalikan generator untuk urutan string, yang hampir sama baiknya dengan daftar.

Tidak disatukan

... untuk keterbacaan yang lebih baik dari generator bersarang.

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=' ')

Penjelasan

1. Fungsi ini digunakan zipuntuk mengubah daftar garis yang masuk menjadi generator kolom.

2. Generator terdalam melihat pasangan karakter yang berdekatan dan ...

3. ... mengiris jumlah yang diperlukan ROPE kontinu dari cyclegenerator (tak terbatas) .

4. Setelah jumlah string yang banyak bergabung dari generator, fungsi tersebut mentransposisi ulang daftar kolom kembali ke generator atau jalur dan mengisi entri yang hilang zip_longest.

Stax , 25 byte

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

Jalankan dan debug online!

Input dan output diberikan sebagai daftar yang dipisahkan oleh ruang. Input adalah daftar baris yang diperlukan, output adalah daftar kolom yang diizinkan.

Penjelasan

Gunakan versi yang belum dibongkar untuk menjelaskan.

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