Связанный: Скорее похожая (но гораздо более простая) задача по горизонтали: там я ее исправил (с помощью ленты)

Вызов:

Для строки, содержащей только заглавные и / или строчные буквы (в зависимости от того, что вы предпочитаете) и новые строки, поместите их 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необходимости, и в этом случае вход остается неизменным.

Основные правила:

• Это код-гольф , поэтому выигрывает самый короткий ответ в байтах.
  Не позволяйте языкам кода-гольфа отговаривать вас от публикации ответов на языках, не относящихся к кодексу. Попробуйте найти как можно более короткий ответ для «любого» языка программирования.
• К вашему ответу применяются стандартные правила , поэтому вы можете использовать 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 байт благодаря мистеру Xcoder
-2 байта благодаря Эрику 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 байта благодаря овсу

Рубин , 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}}

Попробуйте онлайн!

Да, это гораздо сложнее, чем задача «ЛЕНТА». Я пытался использовать свое решение для этой задачи, но в этом есть несколько дополнительных поворотов.

Принимает ввод в виде массива символов по столбцам, возвращает массив строк, также в формате по столбцам. Код в нижнем колонтитуле ссылки TIO выполняет предварительную и последующую обработку данных ввода-вывода, чтобы мы могли предоставить более управляемую строку и затем красиво распечатать результат.

объяснение

Код делает два прохода через входной массив.

В первом проходе мы применяем reduceоперацию, которая заполняет пространство между символами требуемым количеством ВЕРЕВКИ ( y.ord-x[-1].ord-1символы, если положительные). Нам также нужно отслеживать используемую ROPE length ( l).

В отличие от случая TAPE, мы не можем просто использовать rjustдля заполнения, так как он всегда начинается с символа R. Вместо этого взятие правильного фрагмента длинной строки «ROPEROPE ...» кажется меньшим при подсчете байтов, тем более что нам также нужно обновлять lна лету.

Во втором проходе мы выравниваем по левому краю получающиеся строки с пробелами, чтобы соответствовать длине самой длинной из них. Поскольку нам нужны полные результаты предыдущей итерации, первый проход изменяет массив на месте (следовательно map!, нет map).

-1 байт благодаря Кевину Круйссену

-70 байт благодаря Джонатану Фреу , вау .......

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

Попробуйте онлайн!

Функция принимает входные данные в виде списка (или итерируемого) строк, а также возвращает генератор для последовательности строк, что почти так же хорошо, как список.

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. … Вырезает необходимое количество непрерывной ВЕРЕВКИ из (бесконечного) cycleгенератора.

4. После большого количества строк, соединяющих генераторы, функция переставляет список столбцов обратно в генератор или строки и заполняет отсутствующие записи 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