Correlati: sfida piuttosto simile (ma molto più semplice) in orizzontale: lì l'ho risolto (con nastro)

Sfida:

Data una stringa contenente solo lettere maiuscole e / o minuscole (qualunque preferiate) e nuove righe, posizionate ropeverticalmente per correggerlo. Facciamo questo controllando la differenza di due lettere adiacenti in alfabeto (ignorando avvolgente e solo andando verso il basso), e riempire lo spazio con tanto ROPE/ ropecome avremmo bisogno.
NOTA: Un'altra differenza chiave tra questa sfida e la sfida Ci ho risolto (con nastro) è che ropequesta volta non stiamo perdendo come abbiamo fatto con tape(suggerito da @JonathanAllan nella prima parte della sfida).

Esempio:

Ingresso:

abc
bcd
ddd
eex
gfz
hka
imh

Produzione:

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

Perché?

• Tra be dnella colonna 1 dovrebbe essere c(lunghezza 1), quindi lo riempiamo con R;
• Tra ee gnella colonna 1 dovrebbe essere f(lunghezza 1), quindi lo riempiamo con O;
• Tra fe knella colonna 2 dovrebbe essere ghij(lunghezza 4), quindi lo riempiamo con PERO;
• Tra ke mnella colonna 2 dovrebbe essere l(lunghezza 1), quindi lo riempiamo con P;
• Tra de cnella colonna 3 dovrebbe essere efghijklmnopqrstuvw(lunghezza 19), quindi lo riempiamo con EROPEROPEROPEROPERO;
• Tra xe znella colonna 3 dovrebbe essere y(lunghezza 1), quindi lo riempiamo con P;
• Tra ae hnella colonna 3 dovrebbe essere bcdefg(lunghezza 6), quindi lo riempiamo con EROPER.

Regole della sfida:

• La differenza si applica solo verso il basso, quindi nessuna corda tra za(colonna 3 nell'esempio sopra).
• È possibile avere più lettere uguali simili dd(colonna 3 nell'esempio sopra).
• Continuerai a utilizzare ROPEuna colonna alla volta per non sprecare parti (suggerito da @JonathanAllan nella parte 1 della sfida).
• È consentito accettare l'input in qualsiasi formato ragionevole. Può essere una singola stringa, stringa-matrice / elenco, matrice di caratteri, ecc. L'output ha la stessa flessibilità.
• È consentito utilizzare lettere minuscole e / o maiuscole nel modo desiderato. Questo vale sia per l'input, che per l'output e ROPE.
• Gli spazi finali sono facoltativi (notare che la quantità corretta di spazi iniziali è obbligatoria, quindi le colonne sono corrette).
  Qualsiasi quantità di nuove righe finali e / o iniziali è facoltativa.
• Puoi presumere che tutti i casi di test avranno la stessa lunghezza su tutte le righe, quindi a\naa/ [[a][a,a]]non sarebbe un input valido.
• È possibile che non ROPEsia necessario, nel qual caso l'ingresso rimane invariato.

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Le scappatoie predefinite sono vietate.
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

Casi test:

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

Gelatina , 21 byte

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

Provalo online!

Spiegazione

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 grazie a Mr. Xcoder
-2 byte grazie a Erik the Outgolfer

05AB1E , 38 37 25 byte

Ho salvato 10 byte con suggerimenti da Magic Octopus Urn e un altro byte modificando il formato di output.

Emette un elenco di stringhe.
Piuttosto stampe a piè di pagina.

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

Provalo online!

Spiegazione

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

Provalo online!

• -3 byte grazie agli ovs

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

Provalo online!

Sì, questo è molto più difficile della sfida "TAPE". Ho provato a sviluppare la mia soluzione a questo compito, ma questo ha alcuni colpi di scena in più.

Accetta input come una matrice di caratteri a colonne, restituisce una matrice di stringhe, anche in formato a colonne. Il codice nel piè di pagina del collegamento TIO esegue pre e post-elaborazione dei dati I / O in modo da poter fornire una stringa più gestibile e quindi stampare correttamente il risultato.

Spiegazione

Il codice effettua due passaggi attraverso l'array di input.

Nel primo passaggio applichiamo l' reduceoperazione che riempie lo spazio tra i personaggi con la quantità richiesta di CORDA ( y.ord-x[-1].ord-1caratteri, se positivi). Dobbiamo anche tenere traccia della lunghezza ROPE utilizzata ( l).

A differenza del caso TAPE, non possiamo semplicemente usare rjustper il riempimento, poiché partirà sempre dal carattere R. Invece, prendere una porzione corretta di una lunga stringa "ROPEROPE ..." sembra più leggera sul conteggio dei byte, soprattutto perché dobbiamo anche aggiornare lal volo.

Nel secondo passaggio giustificiamo a sinistra le stringhe risultanti con spazi in modo che corrispondano alla lunghezza della più lunga di esse. Dato che qui abbiamo bisogno dei risultati completi della precedente iterazione, il primo passaggio modifica l'array in atto (quindi map!, non map).

-1 byte grazie a Kevin Cruijssen

-70 byte grazie a 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)))

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

Provalo online!

La funzione prende il suo input come un elenco (o un iterabile) di stringhe e restituisce anche un generatore per una sequenza di stringhe, che è quasi buono come un elenco.

Ungolfed

... per una migliore leggibilità dei generatori nidificati.

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

Spiegazione

1. La funzione utilizza zipper trasporre l'elenco di righe in arrivo in un generatore di colonne.

2. Il generatore più interno guarda coppie di personaggi adiacenti e ...

3. ... taglia la quantità richiesta di CORDA continua da un cyclegeneratore (infinito) .

4. Dopo abbondanti quantità di stringhe che si uniscono dai generatori, la funzione traspone nuovamente l'elenco delle colonne in un generatore o linee e riempie le voci mancanti zip_longest.

Stax , 25 byte

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

Esegui ed esegui il debug online!

Input e output sono dati come elenchi separati da spazi. L'input è l'elenco delle righe come richiesto, l'output è l'elenco delle colonne come consentito.

Spiegazione

Usa la versione decompressa per spiegare.

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