Verwandte: Eher ähnliche (aber viel einfachere) Herausforderung horizontal: Dort habe ich es behoben (mit Klebeband)

Herausforderung:

Wenn eine Zeichenfolge nur Groß- und / oder Kleinbuchstaben (je nachdem, was Sie bevorzugen) und neue Zeilen enthält, setzen Sie sie ropevertikal, um sie zu korrigieren. Dazu überprüfen wir den Unterschied zwischen zwei benachbarten Buchstaben im Alphabet (ignorieren den Umlauf und gehen nur nach unten) und füllen den Raum mit so viel ROPE/, ropewie wir benötigen würden.
HINWEIS: Ein weiterer wesentlicher Unterschied zwischen dieser Herausforderung und der Herausforderung " Dort habe ich sie behoben (mit Band)" besteht darin, dass wir ropediese Zeit nicht wie bei der tape(von @JonathanAllan in Teil 1 der Herausforderung vorgeschlagenen) verschwenden .

Beispiel:

Eingang:

abc
bcd
ddd
eex
gfz
hka
imh

Ausgabe:

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

Warum?

• Zwischen bund din Spalte 1 sollte c(Länge 1) sein, also füllen wir dies mit R;
• Zwischen eund gin Spalte 1 sollte f(Länge 1) sein, also füllen wir dies mit O;
• Zwischen fund kin Spalte 2 sollte ghij(Länge 4) sein, also füllen wir dies mit PERO;
• Zwischen kund min Spalte 2 sollte l(Länge 1) sein, also füllen wir dies mit P;
• Zwischen dund cin Spalte 3 sollte efghijklmnopqrstuvw(Länge 19) sein, also füllen wir dies mit EROPEROPEROPEROPERO;
• Zwischen xund zin Spalte 3 sollte y(Länge 1) sein, also füllen wir dies mit P;
• Zwischen aund hin Spalte 3 sollte bcdefg(Länge 6) sein, also füllen wir dies mit EROPER.

Herausforderungsregeln:

• Der Unterschied gilt nur nach unten, also kein Seil dazwischen za(Spalte 3 im obigen Beispiel).
• Es ist möglich, mehrere gleiche benachbarte Buchstaben wie dd(Spalte 3 im obigen Beispiel) zu haben.
• Sie werden weiterhin jeweils ROPEeine Spalte verwenden, um keine Teile zu verschwenden (vorgeschlagen von @JonathanAllan in Teil 1 der Herausforderung).
• Sie dürfen die Eingabe in jedem vernünftigen Format vornehmen. Kann eine einzelne Zeichenfolge, ein Zeichenfolgenarray / eine Liste, eine Zeichenmatrix usw. sein. Die Ausgabe hat die gleiche Flexibilität.
• Sie können Klein- und / oder Großbuchstaben nach Belieben verwenden. Dies gilt sowohl für die Eingabe als auch für die Ausgabe und ROPE.
• Nachgestellte Leerzeichen sind optional (beachten Sie, dass die richtige Anzahl führender Leerzeichen obligatorisch ist, damit die Spalten korrekt sind).
  Beliebig viele nachfolgende und / oder führende neue Zeilen sind ebenfalls optional.
• Sie können davon ausgehen, dass alle Testfälle über alle Zeilen hinweg die gleiche Länge haben, sodass a\naa/ [[a][a,a]]keine gültige Eingabe wäre.
• Es ist möglich, dass keine ROPEerforderlich ist. In diesem Fall bleibt die Eingabe unverändert.

Allgemeine Regeln:

• Dies ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich nicht von Code-Golf-Sprachen davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, eine möglichst kurze Antwort für "jede" Programmiersprache zu finden.
• Für Ihre Antwort gelten Standardregeln , sodass Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp verwenden dürfen. Ihr Anruf.
• Standardschlupflöcher sind verboten.
• Wenn möglich, fügen Sie bitte einen Link mit einem Test für Ihren Code hinzu.
• Fügen Sie bei Bedarf auch eine Erklärung hinzu.

Testfälle:

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

Gelee , 21 Bytes

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

Probieren Sie es online aus!

Erläuterung

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 dank Mr. Xcoder
-2 Bytes dank Erik the Outgolfer

05AB1E , 38 37 25 Bytes

10 Bytes mit Vorschlägen von Magic Octopus Urn und einem weiteren Byte, das das Ausgabeformat ändert, gespeichert.

Gibt eine Liste von Zeichenfolgen aus.
Fußzeile hübsche Drucke.

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

Probieren Sie es online aus!

Erläuterung

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

Probieren Sie es online aus!

• -3 Bytes dank 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}}

Probieren Sie es online aus!

Ja, das ist viel schwieriger als die "TAPE" -Herausforderung. Ich habe versucht, auf meiner Lösung für diese Aufgabe aufzubauen, aber dies hat ein paar zusätzliche Wendungen.

Nimmt die Eingabe als spaltenweises Array von Zeichen auf und gibt ein Array von Zeichenfolgen zurück, ebenfalls im spaltenweisen Format. Der Code in der Fußzeile des TIO-Links führt die Vor- und Nachbearbeitung von E / A-Daten durch, sodass wir eine besser verwaltbare Zeichenfolge bereitstellen und das Ergebnis dann gut drucken können.

Erläuterung

Der Code durchläuft das Eingabearray zweimal.

Im ersten Durchgang wenden wir die reduceOperation an, die den Raum zwischen den Zeichen mit der erforderlichen Menge an SEIL ( y.ord-x[-1].ord-1Zeichen, falls positiv) ausfüllt . Wir müssen auch die verwendete SEILlänge ( l) verfolgen .

Anders als im TAPE-Fall können wir nicht einfach rjustzum Füllen verwenden, da dies immer mit dem R-Zeichen beginnen würde. Stattdessen scheint es bei der Anzahl der Bytes leichter zu sein, ein richtiges Stück einer langen "ROPEROPE ..." - Zeichenfolge zu nehmen, zumal wir auch im laufenden Betrieb aktualisieren müssen l.

Im zweiten Durchgang haben wir die resultierenden Zeichenfolgen mit Leerzeichen linksbündig ausgerichtet, um sie an die Länge der längsten anzupassen. Da wir hier die vollständigen Ergebnisse der vorherigen Iteration benötigen, ändert der erste Durchgang das Array an Ort und Stelle (daher map!nicht map).

-1 Bytes dank Kevin Cruijssen

-70 Bytes dank 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)))

Probieren Sie es online aus!

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

Probieren Sie es online aus!

Die Funktion verwendet ihre Eingabe als Liste (oder iterierbare Zeichenfolge) und gibt auch einen Generator für eine Folge von Zeichenfolgen zurück, der fast so gut wie eine Liste ist.

Ungolfed

… Zur besseren Lesbarkeit der verschachtelten Generatoren.

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

Erläuterung

1. Die Funktion verwendet zip, um die eingehende Liste von Zeilen in einen Generator von Spalten zu transponieren.

2. Der innerste Generator betrachtet Paare benachbarter Zeichen und…

3. … Schneidet die erforderliche Menge an kontinuierlichem SEIL aus einem (unendlichen) cycleGenerator.

4. Nach einer umfangreichen Verknüpfung von Zeichenfolgen durch Generatoren transponiert die Funktion die Liste der Spalten wieder in einen Generator oder in Zeilen und füllt fehlende Einträge mit zip_longest.

Stax , 25 Bytes

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

Online ausführen und debuggen!

Eingabe und Ausgabe werden als durch Leerzeichen getrennte Listen angegeben. Eingabe ist die Liste der erforderlichen Zeilen, Ausgabe ist die Liste der zulässigen Spalten.

Erläuterung

Verwendet die entpackte Version zur Erklärung.

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