Powiązane: Raczej podobne (ale o wiele łatwiejsze) wyzwanie w poziomie: tam to naprawiłem (za pomocą taśmy)

Wyzwanie:

Biorąc pod uwagę ciąg zawierający tylko wielkie i / lub małe litery (w zależności od tego, co wolisz) i nowe wiersze, umieść je ropepionowo, aby je naprawić. Robimy to, sprawdzając różnicę dwóch sąsiednich liter w alfabecie (ignorując zawijanie i tylko schodząc w dół), i wypełniając miejsce tyle ROPE/ ropeile byśmy potrzebowali.
UWAGA: Inną kluczową różnicą między tym wyzwaniem a wyzwaniem Tam, w którym to naprawiłem (z taśmą) jest to, że nie marnujemy ropetego czasu, jak to zrobiliśmy z tape(sugerowane przez @JonathanAllan w części pierwszej wyzwania).

Przykład:

Wejście:

abc
bcd
ddd
eex
gfz
hka
imh

Wynik:

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

Dlaczego?

• Pomiędzy biw dkolumnie 1 powinna być c(długość 1), więc wypełniamy to R;
• Pomiędzy eiw gkolumnie 1 powinna być f(długość 1), więc wypełniamy to O;
• Pomiędzy fiw kkolumnie 2 powinno być ghij(długość 4), więc wypełniamy to PERO;
• Pomiędzy kiw mkolumnie 2 powinno być l(długość 1), więc wypełniamy to P;
• Pomiędzy diw ckolumnie 3 powinno być efghijklmnopqrstuvw(długość 19), więc wypełniamy to EROPEROPEROPEROPERO;
• Pomiędzy xiw zkolumnie 3 powinno być y(długość 1), więc wypełniamy to P;
• Pomiędzy aiw hkolumnie 3 powinno być bcdefg(długość 6), więc wypełniamy to EROPER.

Zasady konkursu:

• Różnica dotyczy tylko w dół, więc nie ma między nimi liny za(kolumna 3 w powyższym przykładzie).
• Możliwe jest posiadanie wielu takich samych sąsiadujących liter jak dd(kolumna 3 w powyższym przykładzie).
• Będziesz nadal używać ROPEjednej kolumny na raz, aby nie marnować części (sugerowane przez @JonathanAllan w części 1 wyzwania).
• Dozwolone jest przyjmowanie danych wejściowych w dowolnym rozsądnym formacie. Może być pojedynczym ciągiem, tablicą / listą znaków, macierzą znaków itp. Wyjście ma taką samą elastyczność.
• Możesz używać małych i / lub wielkich liter w dowolny sposób. Dotyczy to zarówno wejścia, wyjścia, jak i ROPE.
• Końcowe spacje są opcjonalne (zwróć uwagę, że poprawna liczba wiodących spacji jest obowiązkowa, więc kolumny są prawidłowe).
  Każda ilość końcowych i / lub wiodących nowych linii jest również opcjonalna.
• Możesz założyć, że wszystkie przypadki testowe będą miały tę samą długość we wszystkich wierszach, więc a\naa/ [[a][a,a]]nie będzie poprawnym wejściem.
• Możliwe, że nie ROPEjest konieczne, w którym to przypadku dane wejściowe pozostają niezmienione.

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki kod-golfowe zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi mają zastosowanie standardowe reguły , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i zwracanymi typami, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem swojego kodu.
• W razie potrzeby dodaj również wyjaśnienie.

Przypadki testowe:

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

Galaretka , 21 bajtów

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

Wypróbuj online!

Wyjaśnienie

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 bajt dzięki Mr. Xcoder
-2 bajty dzięki Erik the Outgolfer

05AB1E , 38 37 25 bajtów

Zapisano 10 bajtów z sugestiami z Magic Octopus Urn i innym bajtowym formatem wyjściowym.

Wyświetla listę ciągów znaków.
Śliczne odciski stopki.

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

Wypróbuj online!

Wyjaśnienie

'Ùº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 bajtów

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

Wypróbuj online!

• -3 bajty dzięki ovs

Ruby , 119 bajtów

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

Wypróbuj online!

Tak, jest to o wiele trudniejsze niż wyzwanie „TAPE”. Próbowałem rozwinąć swoje rozwiązanie tego zadania, ale ma to kilka dodatkowych zwrotów.

Pobiera dane wejściowe jako kolumnową tablicę znaków, zwraca tablicę ciągów, również w formacie kolumnowym. Kod w stopce łącza TIO wykonuje przetwarzanie wstępne i końcowe danych we / wy, abyśmy mogli dostarczyć łatwiejszy do zarządzania ciąg, a następnie ładnie wydrukować wynik.

Wyjaśnienie

Kod wykonuje dwa przejścia przez tablicę wejściową.

W pierwszym przejściu stosujemy reduceoperację, która wypełnia przestrzeń między znakami wymaganą ilością LINY ( y.ord-x[-1].ord-1znaki, jeśli są dodatnie). Musimy również śledzić zastosowaną długość LINY ( l).

W przeciwieństwie do przypadku TAPE, nie możemy po prostu użyć rjustdo wypełnienia, ponieważ zawsze zaczynałby się od znaku R. Zamiast tego pobranie odpowiedniego kawałka długiego łańcucha „ROPEROPE ...” wydaje się lżejsze pod względem liczby bajtów, zwłaszcza, że ​​musimy także aktualizować lw locie.

W drugim przejściu justujemy w lewo powstałe ciągi spacjami, aby pasowały do ​​długości najdłuższego z nich. Ponieważ potrzebujemy tutaj pełnych wyników poprzedniej iteracji, pierwsze przejście modyfikuje tablicę w miejscu (stąd map!nie map).

-1 bajty dzięki Kevin Cruijssen

-70 bajtów dzięki Jonathan Frech , wow .......

Python 3 , 203 bajty

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

Wypróbuj online!

Python 3 , 182 bajty

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

Wypróbuj online!

Funkcja przyjmuje dane wejściowe jako listę (lub iterowalną) ciągów, a także zwraca generator sekwencji ciągów, który jest prawie tak dobry jak lista.

Nie golfił

… Dla lepszej czytelności zagnieżdżonych generatorów.

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

Wyjaśnienie

1. Funkcja służy zipdo transponowania przychodzącej listy linii do generatora kolumn.

2. Najbardziej wewnętrzny generator sprawdza pary sąsiednich postaci i…

3. … Wycina wymaganą ilość ciągłej LINY z (nieskończonego) cyclegeneratora.

4. Po dużej ilości ciągów łączących generatory funkcja ponownie transponuje listę kolumn z powrotem do generatora lub wierszy i uzupełnia brakujące wpisy zip_longest.

Stax , 25 bajtów

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

Uruchom i debuguj online!

Dane wejściowe i wyjściowe są podawane jako listy rozdzielone spacjami. Dane wejściowe to lista wierszy zgodnie z wymaganiami, dane wyjściowe to lista kolumn, jeśli jest to dozwolone.

Wyjaśnienie

Używa rozpakowanej wersji do wyjaśnienia.

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