Пов’язано: Досить схожий (але набагато простіше) виклик по горизонталі: Там я його виправив (скотчем)

Виклик:

Враховуючи рядок, що містить лише великі та / або малі літери (залежно від того, що ви хочете) та нові рядки, поставте 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, функції / метод із відповідними параметрами та повним програмами типу return. Твій дзвінок.
• Лазівки за замовчуванням заборонені.
• Якщо можливо, додайте посилання з тестом для вашого коду.
• Також, будь ласка, додайте пояснення, якщо це необхідно.

Тестові приклади:

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 байту завдяки Еріку Переверхувача

05AB1E , 38 37 25 байт

Збережено 10 байт із пропозиціями із Urn 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

Пітон 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}}

Спробуйте в Інтернеті!

Так, це набагато складніше, ніж виклик "TAPE". Я намагався розвинути своє рішення цього завдання, але це має кілька додаткових поворотів.

Приймає введення як масив символів стовпців, повертає масив рядків, також у форматі стовпців. Код у нижньому колонтитулі посилання TIO виконує попередню та післяобробку даних вводу / виводу, щоб ми могли поставити більш керований рядок і потім добре друкувати результат.

Пояснення

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

У першому проході ми застосовуємо reduceоперацію, яка заповнює простір між символами необхідною кількістю ROPE ( y.ord-x[-1].ord-1символів, якщо вони позитивні). Нам також слід відстежувати використану довжину ROPE ( l).

На відміну від випадку TAPE, ми не можемо просто використовувати rjustдля заповнення, оскільки це завжди починається з символу R. Натомість, взяти належний фрагмент довгої рядки "ROPEROPE ..." здається легшим на кількість байтів, тим більше, що нам також потрібно оновлюватись lна льоту.

У другому проході ми залишили обгрунтування отриманих рядків з пробілами, щоб відповідати довжині найдовшої з них. Оскільки нам потрібні повні результати попередньої ітерації тут, перший прохід змінює масив на місці (отже map!, ні map).

-1 байт завдяки Kevin Cruijssen

-70 байт завдяки Джонатану Фреху , ух .......

Пітон 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)))

Спробуйте в Інтернеті!

Пітон 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=' ')

Спробуйте в Інтернеті!

Функція приймає свої дані як список (або ітерабельний) рядків, а також повертає генератор послідовностей рядків, що майже так само добре, як і список.

Безумовно

… Для кращої читабельності вкладених генераторів.

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. … Відрізає необхідну кількість безперервного ROPE з (нескінченного) cycleгенератора.

4. Після великої кількості рядків, що з'єднуються з генераторами, функція повторно переносить список стовпців назад до генератора або рядків і заповнює відсутні записи zip_longest.

Стакс , 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