Relacionado: desafío bastante similar (pero mucho más fácil) horizontalmente: allí lo arreglé (con cinta)

Desafío:

Dada una cadena que solo contiene letras mayúsculas y / o minúsculas (lo que prefiera) y nuevas líneas, coloque ropeverticalmente para arreglarlo. Hacemos esto mediante la comprobación de la diferencia de dos letras adyacentes en el alfabeto (ignorando envolvente y sólo va a la baja), y llenando el espacio con tanto ROPE/ ropecomo sería necesario.
NOTA: Otra diferencia clave entre este desafío y el desafío Allí lo arreglé (con cinta) es que no estamos perdiendo ropeesta vez como lo hicimos con el tape(sugerido por @JonathanAllan en la primera parte del desafío).

Ejemplo:

Entrada:

abc
bcd
ddd
eex
gfz
hka
imh

Salida:

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

¿Por qué?

• Entre by den la columna 1 debe ser c(longitud 1), por lo que llenamos esto con R;
• Entre ey gen la columna 1 debe ser f(longitud 1), por lo que llenamos esto con O;
• Entre fy ken la columna 2 debe ser ghij(longitud 4), por lo que llenamos esto con PERO;
• Entre ky men la columna 2 debe ser l(longitud 1), por lo que llenamos esto con P;
• Entre dy cen la columna 3 debe ser efghijklmnopqrstuvw(longitud 19), por lo que llenamos esto con EROPEROPEROPEROPERO;
• Entre xy zen la columna 3 debe ser y(longitud 1), por lo que llenamos esto con P;
• Entre ay hen la columna 3 debe ser bcdefg(longitud 6), por lo que llenamos esto con EROPER.

Reglas de desafío:

• La diferencia solo se aplica hacia abajo, por lo que no hay cuerda entre za(columna 3 en el ejemplo anterior).
• Es posible tener múltiples de las mismas letras adyacentes como dd(columna 3 en el ejemplo anterior).
• Continuará usando ROPEuna columna a la vez para no desperdiciar partes (sugerido por @JonathanAllan en la parte 1 del desafío).
• Se le permite tomar la entrada en cualquier formato razonable. Puede ser una sola cadena, una matriz / lista de cadenas, una matriz de caracteres, etc. La salida tiene la misma flexibilidad.
• Puede usar minúsculas y / o mayúsculas de la forma que desee. Esto se aplica tanto a la entrada, salida y ROPE.
• Los espacios finales son opcionales (tenga en cuenta que la cantidad correcta de espacios iniciales es obligatoria por lo que las columnas son correctas).
  Cualquier cantidad de nuevas líneas finales y / o iniciales también son opcionales.
• Puede suponer que todos los casos de prueba tendrán la misma longitud en todas las filas, por lo que a\naa/ [[a][a,a]]no sería una entrada válida.
• Es posible que no ROPEsea ​​necesario, en cuyo caso la entrada permanece sin cambios.

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, agregue una explicación si es necesario.

Casos de prueba:

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

Jalea , 21 bytes

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

Pruébalo en línea!

Explicación

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 gracias al Sr. Xcoder
-2 bytes gracias a Erik the Outgolfer

05AB1E , 38 37 25 bytes

Guardado 10 bytes con sugerencias de Magic Octopus Urn y otro byte que cambia el formato de salida.

Emite una lista de cadenas.
Pie de página bonitas impresiones.

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

Pruébalo en línea!

Explicación

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

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

Pruébalo en línea!

• -3 bytes gracias a los ovs

Ruby , 119 bytes

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

Pruébalo en línea!

Sí, esto es mucho más difícil que el desafío "TAPE". Traté de desarrollar mi solución para esa tarea, pero esto tiene algunos giros adicionales.

Toma la entrada como una matriz de caracteres en columnas, devuelve una matriz de cadenas, también en formato de columnas. El código en el pie de página del enlace TIO realiza el procesamiento previo y posterior de los datos de E / S para que podamos proporcionar una cadena más manejable y luego imprimir el resultado muy bien.

Explicación

El código hace dos pases a través de la matriz de entrada.

En la primera pasada, aplicamos la reduceoperación que llena el espacio entre los caracteres con la cantidad requerida de CUERDA ( y.ord-x[-1].ord-1caracteres, si es positivo). También debemos realizar un seguimiento de la longitud de la cuerda utilizada ( l).

A diferencia del caso TAPE, no podemos simplemente usarlo rjustpara llenar, ya que siempre comenzaría con el carácter R. En cambio, tomar una porción adecuada de una larga cadena "ROPEROPE ..." parece más ligera en el recuento de bytes, especialmente porque también necesitamos actualizar lsobre la marcha.

En la segunda pasada, justificamos a la izquierda las cadenas resultantes con espacios para que coincidan con la longitud de la más larga. Como necesitamos los resultados completos de la iteración anterior aquí, el primer paso modifica la matriz en su lugar (por lo tanto map!, no map).

-1 bytes gracias a Kevin Cruijssen

-70 bytes gracias a Jonathan Frech , wow .......

Python 3 , 203 bytes

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

Pruébalo en línea!

Python 3 , 182 bytes

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

Pruébalo en línea!

La función toma su entrada como una lista (o iterable) de cadenas y también devuelve un generador para una secuencia de cadenas, que es casi tan buena como una lista.

Sin golf

... para una mejor legibilidad de los generadores anidados.

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

Explicación

1. La función utiliza zippara transponer la lista entrante de líneas en un generador de columnas.

2. El generador más interno mira pares de caracteres adyacentes y ...

3. … Corta la cantidad requerida de CUERDA continua de un cyclegenerador (infinito) .

4. Después de copiosas cantidades de cadenas que se unen desde los generadores, la función vuelve a transponer la lista de columnas a un generador o líneas y llena las entradas que faltan zip_longest.

Stax , 25 bytes

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

¡Ejecute y depure en línea!

La entrada y la salida se dan como listas separadas por espacios. La entrada es la lista de filas según sea necesario, la salida es la lista de columnas según lo permitido.

Explicación

Utiliza la versión desempaquetada para explicar.

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