İlgili: Yatay olarak oldukça benzer (ama çok daha kolay) meydan okuma: Orada sabitledim (bant ile)

Meydan okuma:

Yalnızca büyük ve / veya küçük harfler (hangisini tercih ederseniz seçin) ve yeni satırlar içeren bir dize verildiğinde, ropedüzeltmek için dikey olarak koyun . Bunu, alfabedeki iki bitişik harfin farkını kontrol ederek (etrafı sarar ve sadece aşağı doğru gider) ve boşluğu ihtiyacımız olduğu kadar ROPE/ ile doldurarak ropeyaparız.
Not: Bu meydan okuma ve orada sabit (bant ile) meydan okuma arasındaki bir diğer önemli fark ( biz meydan okuma bir bölümünde @JonathanAllan tarafından önerilen) ropeyaptığımız gibi bu kez israf etmiyoruz olmasıdır .tape

Misal:

Giriş:

abc
bcd
ddd
eex
gfz
hka
imh

Çıktı:

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

Neden?

• Sütun 1 arasında bve diçinde c(uzunluk 1) olmalıdır, bu yüzden bunu R;
• Sütun 1 arasında eve giçinde f(uzunluk 1) olmalıdır, bu yüzden bunu O;
• Sütun 2 arasında fve kiçinde ghij(uzunluk 4) olmalıdır, bu yüzden bunu dolduruyoruz PERO;
• Sütun 2 arasında kve miçinde l(uzunluk 1) olmalıdır, bu yüzden bunu dolduruyoruz P;
• Sütun 3 arasında dve ciçinde efghijklmnopqrstuvw(uzunluk 19) olmalıdır, bu yüzden bunu dolduruyoruz EROPEROPEROPEROPERO;
• Sütun 3 arasında xve ziçinde y(uzunluk 1) olmalıdır, bu yüzden bunu doldururuz P;
• Sütun 3 arasında ave hiçinde bcdefg(uzunluk 6) olmalıdır, bu yüzden bunu dolduruyoruz EROPER.

Zorluk kuralları:

• Fark sadece aşağıya doğru uygulanır, bu nedenle arasında hiçbir ip yoktur za(yukarıdaki örnekte sütun 3).
• Aynı bitişik harflerden birden fazlasına sahip olmak mümkündür dd(yukarıdaki örnekte sütun 3).
• ROPEParça israf etmemek için her seferinde bir sütunu kullanmaya devam edeceksiniz ( meydan okumanın 1. bölümünde @JonathanAllan tarafından önerilmektedir ).
• Girdiyi makul bir biçimde almanıza izin verilir. Tek bir dize, dize dizisi / liste, karakter matrisi vb. Olabilir. Çıktı aynı esnekliğe sahiptir.
• Küçük ve / veya büyük harfleri istediğiniz şekilde kullanabilirsiniz. Bu hem giriş, çıkış hem de için geçerlidir ROPE.
• Sondaki boşluklar isteğe bağlıdır (sütunların doğru olması için doğru miktarda önde gelen boşlukların zorunlu olduğunu unutmayın).
  Herhangi bir miktarda sondaki ve / veya önde gelen yeni hatlar da isteğe bağlıdır.
• Tüm test senaryolarının tüm satırlarda aynı uzunluğa sahip olacağını varsayabilirsiniz, bu nedenle a\naa/ [[a][a,a]]geçerli bir girdi olmaz.
• Mümkün hayır ROPEbu durumda girdi değişmeden kalır, gereklidir.

Genel kurallar:

• Bu kod golf , bayt en kısa cevap kazanır.
  Kod golf dillerinin, kod yazmayan dillerle yanıt göndermenizi engellemesine izin vermeyin. 'Herhangi bir' programlama dili için olabildiğince kısa bir cevap bulmaya çalışın.
• Cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT, fonksiyon / yöntemi uygun parametreler ve dönüş tipi, tam programlar ile kullanmanıza izin verilir. Çağrınız.
• Standart Boşluk Doldurma yasaktır.
• Mümkünse, lütfen kodunuz için test içeren bir bağlantı ekleyin.
• Ayrıca, gerekirse bir açıklama ekleyin.

Test senaryoları:

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

Jöle , 21 bayt

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

Çevrimiçi deneyin!

açıklama

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

Bay
Xcoder sayesinde -1 bayt Outgolfer Erik sayesinde -2 bayt

05AB1E , 38 37 25 bayt

Magic Octopus Urn ve başka bir bayt değiştirme çıkış formatı önerileriyle 10 bayt kaydedildi .

Dizelerin bir listesini çıkarır.
Altbilgi güzel yazdırır.

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

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

• Ovs sayesinde -3 bayt

Ruby , 119 bayt

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

Çevrimiçi deneyin!

Evet, bu "TAPE" yarışmasından çok daha zor. Bu göreve yönelik çözümümü geliştirmeye çalıştım, ancak bunun fazladan birkaç katlaması var.

Girişi sütun şeklinde bir karakter dizisi olarak alır, sütun dizesi biçiminde de bir dizgi dizisi döndürür. TIO bağlantısının altbilgisindeki kod, daha yönetilebilir bir dize sağlayabilmemiz ve ardından sonucu güzel bir şekilde yazdırabilmemiz için G / Ç verilerinin önceden ve sonra işlenmesini gerçekleştirir.

açıklama

Kod, giriş dizisinden iki geçiş yapar.

İlk geçişte reduce, karakterler arasındaki boşluğu gerekli miktarda ROPE ( y.ord-x[-1].ord-1pozitifse karakterler) ile dolduran işlemi uygularız . Ayrıca, kullanılan HALAT uzunluğunu da izlememiz gerekir ( l).

TAPE durumundan farklı rjustolarak, her zaman R karakterinden başlayacağı için doldurmak için kullanamayız . Bunun yerine, uzun bir "ROPEROPE ..." dizesinin uygun bir dilimini almak bayt sayımında daha hafif görünüyor, özellikle de lanında güncellememiz gerektiğinden .

İkinci geçişte, ortaya çıkan dizeleri en uzunlarının uzunluğuna uyacak şekilde boşluklarla sola yaslıyoruz. Burada önceki yinelemenin tam sonuçlarına ihtiyacımız olduğundan, ilk geçiş diziyi yerinde değiştirir (dolayısıyla map!değil map).

Kevin Cruijssen sayesinde -1 bayt

Jonathan Frech sayesinde -70 bayt , vay .......

Python 3 , 203 bayt

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

Çevrimiçi deneyin!

Python 3 , 182 bayt

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

Çevrimiçi deneyin!

İşlev girişini bir dize listesi (veya yinelenebilir) olarak alır ve ayrıca bir dizi dizisi için neredeyse bir liste kadar iyi olan bir jeneratör döndürür.

Ungolfed

... yuvalanmış jeneratörlerin daha iyi okunabilmesi için.

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

açıklama

1. İşlev zip, gelen satır listesini bir sütun oluşturucuya aktarmak için kullanılır.

2. En içteki jeneratör bitişik karakter çiftlerine bakar ve…

3. … Gerekli miktarda sürekli ROPE'u (sonsuz) bir cyclejeneratörden dilimler .

4. Jeneratörlerden bol miktarda dize eklendikten sonra işlev, sütun listesini bir jeneratöre veya çizgilere geri aktarır ve eksik girişleri ile doldurur zip_longest.

Stax , 25 bayt

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

Çevrimiçi çalıştırın ve hata ayıklayın!

Girdi ve çıktı boşlukla ayrılmış listeler olarak verilmiştir. Girdi gerektiği gibi satır listesidir, çıktı izin verilen sütun listesidir.

açıklama

Açıklamak için ambalajsız sürümü kullanır.

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