Connexes: Défi assez similaire (mais beaucoup plus facile) horizontalement: Là, je l'ai corrigé (avec du ruban adhésif)

Défi:

Étant donné une chaîne contenant uniquement des lettres majuscules et / ou minuscules (selon ce que vous préférez) et des nouvelles lignes, mettez ropeverticalement pour le corriger. Nous faisons cela en vérifiant la différence de deux lettres adjacentes dans l'alphabet (en ignorant le bouclage et en ne descendant que), et en remplissant l'espace avec autant ROPE/ ropeque nous aurions besoin.
REMARQUE: Une autre différence clé entre ce défi et le défi Là je l'ai résolu (avec une bande) est que nous ne perdons pas ropece temps comme nous l'avons fait avec le tape(suggéré par @JonathanAllan dans la première partie du défi).

Exemple:

Contribution:

abc
bcd
ddd
eex
gfz
hka
imh

Production:

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

Pourquoi?

• Entre bet ddans la colonne 1 devrait être c(longueur 1), nous remplissons donc ceci avec R;
• Entre eet gdans la colonne 1 devrait être f(longueur 1), nous remplissons donc ceci avec O;
• Entre fet kdans la colonne 2 devrait être ghij(longueur 4), nous remplissons donc ceci avec PERO;
• Entre ket mdans la colonne 2 devrait être l(longueur 1), nous remplissons donc ceci avec P;
• Entre det cdans la colonne 3 devrait être efghijklmnopqrstuvw(longueur 19), nous remplissons donc ceci avec EROPEROPEROPEROPERO;
• Entre xet zdans la colonne 3 devrait être y(longueur 1), nous remplissons donc ceci avec P;
• Entre aet hdans la colonne 3 devrait être bcdefg(longueur 6), nous remplissons donc cela avec EROPER.

Règles du défi:

• La différence ne s'applique que vers le bas, donc pas de corde entre za(colonne 3 dans l'exemple ci-dessus).
• Il est possible d'avoir plusieurs des mêmes lettres adjacentes comme dd(colonne 3 dans l'exemple ci-dessus).
• Vous continuerez à utiliser ROPEune colonne à la fois pour ne pas gaspiller de pièces (suggéré par @JonathanAllan dans la partie 1 du défi).
• Vous êtes autorisé à prendre l'entrée dans n'importe quel format raisonnable. Peut être une chaîne unique, un tableau de chaînes / liste, une matrice de caractères, etc. La sortie a la même flexibilité.
• Vous êtes autorisé à utiliser les minuscules et / ou les majuscules comme vous le souhaitez. Cela s'applique à la fois à l'entrée, à la sortie et à ROPE.
• Les espaces de fin sont facultatifs (notez que la quantité correcte d'espaces de tête est obligatoire pour que les colonnes soient correctes).
  Toute quantité de nouvelles lignes de fin et / ou de début est également facultative.
• Vous pouvez supposer que tous les cas de test auront la même longueur sur toutes les lignes, donc a\naa/ [[a][a,a]]ne serait pas une entrée valide.
• Il est possible que non ROPEsoit nécessaire, auquel cas l'entrée reste inchangée.

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues non-golfeur de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

Cas de test:

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ée , 21 octets

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

Essayez-le en ligne!

Explication

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 octet grâce à M. Xcoder
-2 octets grâce à Erik l'Outgolfer

05AB1E , 38 37 25 octets

10 octets enregistrés avec les suggestions de Magic Octopus Urn et un autre octet changeant le format de sortie.

Génère une liste de chaînes.
Pied de page jolis imprimés.

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

Essayez-le en ligne!

Explication

'Ùº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 octets

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

Essayez-le en ligne!

• -3 octets grâce aux ovs

Rubis , 119 octets

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

Essayez-le en ligne!

Oui, c'est beaucoup plus difficile que le défi "TAPE". J'ai essayé de construire sur ma solution à cette tâche, mais cela a quelques rebondissements supplémentaires.

Prend l'entrée comme un tableau de caractères par colonne, renvoie un tableau de chaînes, également au format colonne. Le code dans le pied de page du lien TIO effectue le pré et le post-traitement des données d'E / S afin que nous puissions fournir une chaîne plus facile à gérer, puis imprimer le résultat correctement.

Explication

Le code effectue deux passages dans le tableau d'entrée.

Dans la première passe, nous appliquons l' reduceopération qui remplit l'espace entre les caractères avec la quantité requise de CORDE ( y.ord-x[-1].ord-1caractères, si positifs). Nous devons également garder une trace de la longueur de CORDE utilisée ( l).

Contrairement au cas TAPE, nous ne pouvons pas simplement utiliser rjustpour le remplissage, car il partirait toujours du caractère R. Au lieu de cela, prendre une tranche appropriée d'une longue chaîne "ROPEROPE ..." semble plus léger en nombre d'octets, d'autant plus que nous devons également mettre à jour là la volée.

Dans la deuxième passe, nous avons justifié à gauche les chaînes résultantes avec des espaces pour correspondre à la longueur de la plus longue d'entre elles. Puisque nous avons besoin des résultats complets de l'itération précédente ici, la première passe modifie le tableau en place (donc map!pas map).

-1 octets grâce à Kevin Cruijssen

-70 octets grâce à Jonathan Frech , wow .......

Python 3 , 203 octets

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

Essayez-le en ligne!

Python 3 , 182 octets

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

Essayez-le en ligne!

La fonction prend son entrée comme une liste (ou un itérable) de chaînes et renvoie également un générateur pour une séquence de chaînes, ce qui est presque aussi bon qu'une liste.

Non golfé

… Pour une meilleure lisibilité des générateurs imbriqués.

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

Explication

1. La fonction permet zipde transposer la liste des lignes entrantes dans un générateur de colonnes.

2. Le générateur le plus intérieur regarde des paires de personnages adjacents et…

3. … Découpe la quantité requise de CORDE continue d'un cyclegénérateur (infini) .

4. Après de grandes quantités de chaînes jointes à partir de générateurs, la fonction retranspose la liste des colonnes à un générateur ou à des lignes et remplit les entrées manquantes avec zip_longest.

Stax , 25 octets

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

Exécutez et déboguez en ligne!

L'entrée et la sortie sont données sous forme de listes séparées par des espaces. L'entrée est la liste des lignes selon les besoins, la sortie est la liste des colonnes comme autorisé.

Explication

Utilise la version décompressée pour expliquer.

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