Relacionado: Desafio bastante semelhante (mas muito mais fácil) horizontalmente: Lá eu o corrigi (com fita adesiva)

Desafio:

Dada uma string contendo apenas letras maiúsculas e / ou minúsculas (o que você preferir) e novas linhas, coloque ropeverticalmente para corrigi-la. Fazemos isso verificando a diferença de duas letras adjacentes no alfabeto (ignorando o contorno e descendo apenas) e preenchendo o espaço com o máximo ROPE/ ropenecessário.
OBSERVAÇÃO: Outra diferença importante entre esse desafio e o desafio Lá consertei (com fita) é que não estamos perdendo ropeesse tempo como fizemos com o tape(sugerido por @ JonathanAllan na parte um do desafio).

Exemplo:

Entrada:

abc
bcd
ddd
eex
gfz
hka
imh

Resultado:

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 be dna coluna 1 deve ser c(comprimento 1), por isso preenchemos isso R;
• Entre ee gna coluna 1 deve ser f(comprimento 1), por isso preenchemos isso O;
• Entre fe kna coluna 2 deve ser ghij(comprimento 4), então preenchemos isso com PERO;
• Entre ke mna coluna 2 deve ser l(comprimento 1), então preenchemos isso com P;
• Entre de cna coluna 3 deve ser efghijklmnopqrstuvw(comprimento 19), então preenchemos isso com EROPEROPEROPEROPERO;
• Entre xe zna coluna 3 deve ser y(comprimento 1), por isso preenchemos com P;
• Entre ae hna coluna 3 deve ser bcdefg(comprimento 6), por isso preenchemos isso EROPER.

Regras do desafio:

• A diferença se aplica apenas para baixo, portanto, não há corda entre za(coluna 3 no exemplo acima).
• É possível ter várias das mesmas letras adjacentes como dd(coluna 3 no exemplo acima).
• Você continuará usando a ROPEcoluna de cada vez para não desperdiçar peças (sugerido por @ JonathanAllan na parte 1 do desafio).
• Você tem permissão para receber a entrada em qualquer formato razoável. Pode ser uma única string, string-array / lista, matriz de caracteres, etc. A saída tem a mesma flexibilidade.
• Você tem permissão para usar letras minúsculas e / ou maiúsculas da maneira que desejar. Isso se aplica à entrada, saída e ROPE.
• Os espaços à direita são opcionais (observe que a quantidade correta de espaços à esquerda é obrigatória para que as colunas estejam corretas).
  Qualquer quantidade de linhas novas e / ou principais também são opcionais.
• Você pode assumir que todos os casos de teste terão o mesmo comprimento em todas as linhas, portanto a\naa/ [[a][a,a]]não seria uma entrada válida.
• É possível que não ROPEseja necessário; nesse caso, a entrada permanece inalterada.

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código.
• Além disso, adicione uma explicação, se necessário.

Casos de teste:

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

Geléia , 21 bytes

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

Experimente online!

Explicação

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 graças ao Sr. Xcoder
-2 bytes graças a Erik the Outgolfer

05AB1E , 38 37 25 bytes

Economizou 10 bytes com sugestões do Magic Octopus Urn e outro byte que altera o formato de saída.

Produz uma lista de strings.
Rodapé estampas bonitas.

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

Experimente online!

Explicação

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

Experimente online!

• -3 bytes graças a 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}}

Experimente online!

Sim, isso é muito mais difícil que o desafio "TAPE". Tentei desenvolver minha solução para essa tarefa, mas isso tem algumas reviravoltas extras.

Recebe a entrada como uma matriz de caracteres em coluna, retorna uma matriz de cadeias de caracteres, também no formato coluna. O código no rodapé do link TIO realiza o pré e o pós-processamento dos dados de E / S, para que possamos fornecer uma string mais gerenciável e, em seguida, imprimir o resultado de maneira adequada.

Explicação

O código faz duas passagens pela matriz de entrada.

Na primeira passagem, aplicamos a reduceoperação que preenche o espaço entre os caracteres com a quantidade necessária de ROPE ( y.ord-x[-1].ord-1caracteres, se positivo). Também precisamos acompanhar o comprimento do ROPE usado ( l).

Diferentemente do caso TAPE, não podemos simplesmente usar o rjustpreenchimento, pois ele sempre começaria a partir do caractere R. Em vez disso, pegar uma fatia adequada de uma string "ROPEROPE ..." longa parece mais leve na contagem de bytes, especialmente porque também precisamos atualizar lem tempo real.

Na segunda passagem, justificamos à esquerda as seqüências resultantes com espaços para corresponder ao comprimento da maior delas. Como precisamos dos resultados completos da iteração anterior aqui, a primeira passagem modifica a matriz no local (portanto map!, não map).

-1 bytes graças a Kevin Cruijssen

-70 bytes graças a Jonathan Frech , uau .......

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

Experimente online!

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

Experimente online!

A função recebe sua entrada como uma lista (ou iterável) de strings e também retorna um gerador para uma sequência de strings, que é quase tão boa quanto uma lista.

Ungolfed

… Para melhor legibilidade dos geradores aninhados.

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

Explicação

1. A função usa zippara transpor a lista de linhas recebida em um gerador de colunas.

2. O gerador mais interno analisa pares de caracteres adjacentes e…

3. … Corta a quantidade necessária de CORDA contínua de um cyclegerador (infinito) .

4. Após grandes quantidades de junção de strings de geradores, a função transpõe novamente a lista de colunas para um gerador ou linhas e preenche as entradas ausentes zip_longest.

Stax , 25 bytes

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

Execute e depure online!

Entrada e saída são fornecidas como listas separadas por espaço. Entrada é a lista de linhas conforme necessário, saída é a lista de colunas conforme permitido.

Explicação

Usa a versão descompactada 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