Liên quan: Thử thách tương tự (nhưng dễ hơn nhiều) theo chiều ngang: Tôi đã sửa nó (bằng băng)

Thử thách:

Cho một chuỗi chỉ chứa các chữ cái viết hoa và / hoặc chữ thường (tùy theo ý thích của bạn) và dòng mới, đặt ropetheo chiều dọc để sửa nó. Chúng tôi thực hiện điều này bằng cách kiểm tra sự khác biệt của hai chữ cái liền kề trong bảng chữ cái (bỏ qua việc bao quanh và chỉ đi xuống) và lấp đầy khoảng trống với bao nhiêu ROPE/ ropenhư chúng tôi cần.
LƯU Ý: Một điểm khác biệt quan trọng khác giữa thử thách này và thử thách Tôi đã sửa nó (bằng băng) là chúng tôi không lãng phí ropethời gian như chúng tôi đã làm với tape(được đề xuất bởi @JonathanAllan trong phần một của thử thách).

Thí dụ:

Đầu vào:

abc
bcd
ddd
eex
gfz
hka
imh

Đầu ra:

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

Tại sao?

• Giữa bvà dtrong cột 1 phải là c(chiều dài 1), vì vậy chúng tôi điền vào đây R;
• Giữa evà gtrong cột 1 phải là f(chiều dài 1), vì vậy chúng tôi điền vào đây O;
• Giữa fvà ktrong cột 2 phải là ghij(chiều dài 4), vì vậy chúng tôi điền vào đây PERO;
• Giữa kvà mtrong cột 2 phải là l(chiều dài 1), vì vậy chúng tôi điền vào đây P;
• Giữa dvà ctrong cột 3 phải là efghijklmnopqrstuvw(chiều dài 19), vì vậy chúng tôi điền vào đây EROPEROPEROPEROPERO;
• Giữa xvà ztrong cột 3 phải là y(chiều dài 1), vì vậy chúng tôi điền vào đây P;
• Giữa avà htrong cột 3 phải là bcdefg(chiều dài 6), vì vậy chúng tôi điền vào đây EROPER.

Quy tắc thử thách:

• Sự khác biệt chỉ áp dụng xuống dưới, do đó không có dây giữa za(cột 3 trong ví dụ trên).
• Có thể có nhiều chữ cái liền kề giống như dd(cột 3 trong ví dụ trên).
• Bạn sẽ tiếp tục sử dụng ROPEmột cột tại một thời điểm để không lãng phí các bộ phận (được đề xuất bởi @JonathanAllan trong phần 1 của thử thách).
• Bạn được phép lấy đầu vào ở bất kỳ định dạng hợp lý. Có thể là một chuỗi đơn, chuỗi-mảng / danh sách, ma trận ký tự, v.v ... Đầu ra có cùng tính linh hoạt.
• Bạn được phép sử dụng chữ thường và / hoặc chữ hoa theo bất kỳ cách nào bạn muốn. Điều này áp dụng cả cho đầu vào, đầu ra và ROPE.
• Không gian lưu trữ là tùy chọn (lưu ý rằng số lượng chính xác của không gian hàng đầu là bắt buộc để các cột là chính xác).
  Bất kỳ số lượng dấu vết và / hoặc dòng mới hàng đầu cũng là tùy chọn.
• Bạn có thể giả sử rằng tất cả các trường hợp kiểm tra sẽ có cùng độ dài trên tất cả các hàng, vì vậy a\naa/ [[a][a,a]]sẽ không phải là một đầu vào hợp lệ.
• Có thể không ROPEcần thiết, trong trường hợp đầu vào vẫn không thay đổi.

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Các quy tắc chuẩn áp dụng cho câu trả lời của bạn, vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, các chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn.
• Ngoài ra, xin vui lòng thêm một lời giải thích nếu cần thiết.

Các trường hợp thử nghiệm:

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

Thạch , 21 byte

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

Hãy thử trực tuyến!

Giải trình

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 nhờ ông Xcoder
-2 byte nhờ Erik Outgolfer

05AB1E , 38 37 25 byte

Đã lưu 10 byte với các đề xuất từ Magic Octopus Urn và một định dạng đầu ra thay đổi byte khác.

Xuất ra một danh sách các chuỗi.
Chân trang in đẹp.

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

Hãy thử trực tuyến!

Giải trình

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

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

Hãy thử trực tuyến!

• -3 byte nhờ vào ovs

Ruby , 119 byte

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

Hãy thử trực tuyến!

Đúng, điều này khó hơn nhiều so với thử thách "TAPE". Tôi đã cố gắng xây dựng giải pháp của mình cho nhiệm vụ đó, nhưng điều này có thêm một vài vòng xoắn.

Đưa đầu vào dưới dạng một mảng các ký tự theo cột, trả về một chuỗi các chuỗi, cũng ở định dạng theo cột. Mã trong phần chân trang của liên kết TIO thực hiện xử lý trước và sau dữ liệu I / O để chúng tôi có thể cung cấp một chuỗi dễ quản lý hơn và sau đó in kết quả độc đáo.

Giải trình

Mã làm cho hai đi qua mảng đầu vào.

Trong lần đầu tiên, chúng tôi áp dụng reducethao tác lấp đầy khoảng trống giữa các ký tự với lượng ROPE cần thiết ( y.ord-x[-1].ord-1ký tự, nếu dương). Chúng ta cũng cần theo dõi độ dài ROPE đã sử dụng ( l).

Không giống như trong trường hợp TAPE, chúng ta không thể đơn giản sử dụng rjustđể điền, vì nó sẽ luôn bắt đầu từ ký tự R. Thay vào đó, việc sử dụng một lát cắt thích hợp của chuỗi "ROPEROPE ..." có vẻ nhẹ hơn về số byte, đặc biệt là vì chúng ta cũng cần cập nhật lnhanh chóng.

Trong lần chuyển thứ hai, chúng ta chỉ trái các chuỗi kết quả với khoảng trắng để khớp với độ dài của chuỗi dài nhất. Vì chúng ta cần kết quả đầy đủ của lần lặp trước ở đây, nên pass đầu tiên sửa đổi mảng tại chỗ (do đó map!, không map).

-1 byte nhờ Kevin Cruijssen

-70 byte nhờ Jonathan Frech , wow .......

Python 3 , 203 byte

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

Hãy thử trực tuyến!

Python 3 , 182 byte

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

Hãy thử trực tuyến!

Hàm lấy đầu vào của nó dưới dạng một danh sách (hoặc một lần lặp) của các chuỗi và cũng trả về một trình tạo cho một chuỗi các chuỗi, gần như là một danh sách.

Ung dung

Để có thể đọc tốt hơn các máy phát lồng nhau.

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

Giải trình

1. Hàm này sử dụng zipđể hoán chuyển danh sách các dòng đến thành một bộ tạo cột.

2. Trình tạo trong cùng nhìn vào các cặp ký tự liền kề và Lọ

3. Máy cắt lát số lượng ROPE liên tục cần thiết ra khỏi một cyclemáy phát (vô hạn) .

4. Sau khi có nhiều chuỗi kết nối từ các trình tạo, hàm sẽ chuyển lại danh sách các cột trở lại một trình tạo hoặc các dòng và điền vào các mục bị thiếu zip_longest.

Stax , 25 byte

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

Chạy và gỡ lỗi trực tuyến!

Đầu vào và đầu ra được đưa ra dưới dạng danh sách phân tách không gian. Đầu vào là danh sách các hàng theo yêu cầu, đầu ra là danh sách các cột như được phép.

Giải trình

Sử dụng phiên bản giải nén để giải thích.

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