Thử thách:

Đưa ra một danh sách các chuỗi nhiều dòng, chồng chúng lên nhau (ở phía trên bên trái) và đưa ra kết quả.

Thí dụ:

Đầu vào: ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
Đầu ra:

cbaa
bbaa
bbaa
aaaa

Quy tắc thử thách:

• Định dạng đầu vào là linh hoạt. Bạn được phép lấy đầu vào dưới dạng danh sách 2D của các dòng (tức là [["aaaa","aaaa","aaaa","aaaa"],["bb","bb","bb"],["c"]]) hoặc danh sách các ký tự 3D (nghĩa là [[["a","a","a","a"],["a","a","a","a"],["a","a","a","a"],["a","a","a","a"]],[["b","b"],["b","b"],["b","b"]],[["c"]]]). Bạn được phép lấy tất cả các đầu vào từng cái một thông qua STDIN. V.v.
• Định dạng đầu ra là nghiêm ngặt. Bạn có thể chọn in hoặc trả về chuỗi nhiều dòng. (Nếu ngôn ngữ của bạn không có bất kỳ chuỗi nào, việc xuất ra dưới dạng danh sách các ký tự 2D được phép thay thế. Nhưng chỉ khi ngôn ngữ của bạn không có chuỗi nào cả.)
• Thứ tự của danh sách đầu vào tất nhiên là quan trọng (nhưng bạn được phép lấy đầu vào ngược lại nếu bạn chọn).
• Các đầu vào sẽ chỉ chứa ASCII có thể in trong phạm vi unicode ( ).$[33,126]$!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
• Đầu vào sẽ chỉ là hình chữ nhật (vì vậy không có hình dạng kỳ lạ). Tuy nhiên, đầu ra không phải là hình chữ nhật cần thiết.
• Không gian lưu trữ và một dòng mới duy nhất được cho phép. Không gian hàng đầu và / hoặc dòng mới không.

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ỳ'.
• Quy tắc chuẩn áp dụng cho câu trả lời của bạn với quy tắc I / O mặc định , 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ề, 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 (ví dụ TIO ).
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

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

Đầu vào: ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
Đầu ra:

cbaa
bbaa
bbaa
aaaa

Đầu vào: ["12345\n54321","00\n00\n00\n00","001\n011\n012"]
Đầu ra:

00145
01121
012
00

Đầu vào: ["sm\noo\nmr\nee\nt!\nh_\ni_\nn_\ng_","!@#$%^\n&*()_+\nqwerty\nuiopas","this\nis_a\ntest"]
Đầu ra:

this%^
is_a_+
testty
uiopas
t!
h_
i_
n_
g_

Thạch , 3 byte

a/Y

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

Đã không sử dụng Jelly trong một thời gian nhưng tôi nghĩ rằng thách thức trong các bình luận là có thể đánh bại. Rất trực tiếp sử dụng logic và ( a) để thực hiện thao tác xếp chồng giữa mỗi phần tử của đầu vào ( /). Yđược sử dụng để in ở định dạng cần thiết.

JavaScript (Node.js) , 24 byte

Đã lưu 2 byte nhờ @Grimy

Giả sử rằng chuỗi trả về được in trên thiết bị đầu cuối hỗ trợ mã thoát ANSI . Chứa ký tự không thể in được ESC, được thoát (không có ý định chơi chữ) như \x1Bdưới đây.

a=>`\x1B[2J\x1B[H`+a.join`\x1B[H`

Điều này không hoạt động trên TIO, nhưng bạn có thể dùng thử trực tuyến! để xem đầu ra thô thay thế.

Làm sao?

Các chuỗi CSI được sử dụng là:

• ED (Xóa trong màn hình):

  ESC[2J

  trong đó $2$ có nghĩa là "xóa toàn bộ màn hình"

• CUP (Vị trí con trỏ):

  ESC[H

  có nghĩa là "di chuyển con trỏ đến hàng $n$ , cột $m$ " trong đó cả $n$ và $m$ được bỏ qua và được đặt thành $1$ (góc trên cùng bên trái của màn hình).

Ví dụ đầu ra

R , 120 , 111 110 107 byte

function(x,`!`=ncol,M=array('',Reduce(pmax,Map(dim,x)))){for(m in x)M[1:!t(m),1:!m]=m
write(t(M),1,!M,,'')}

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

Hàm chấp nhận danh sách ma trận các ký tự (đầu vào 3D được chấp nhận).

(như bạn có thể nhận thấy từ số byte, điều này không dễ thực hiện trong R ...)

• -9 byte nhờ @Giuseppe
• -4 byte nhờ @RobinRyder

Python 2 , 88 byte

n,f=None,filter
for l in map(n,*input()):print''.join(f(n,x)[-1]for x in map(n,*f(n,l)))

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

Giải thích (với ví dụ):

Lấy danh sách 2D làm đầu vào.

Input: [["12345","54321"],["00","00","00","00"],["001","011","012"]]

Đầu tiên, danh sách đầu vào được nén, để lấy các hàng của mỗi hình chữ nhật đầu vào ( map(None,l)giống với một zip dài nhất):

map(n,*input())   gives:

('12345', '00', '001')
('54321', '00', '011')
(None, '00', '012')
(None, '00', None)

Mỗi hàng trong số này sau đó được lọc để loại bỏ Nones và được nén lại:

map(None,*filter(None,l))

filter(None,l) for each l gives:

('12345', '00', '001')
('54321', '00', '011')
('00', '012')
('00',)

map*... gives:

[('1', '0', '0'), ('2', '0', '0'), ('3', None, '1'), ('4', None, None), ('5', None, None)]
[('5', '0', '0'), ('4', '0', '1'), ('3', None, '1'), ('2', None, None), ('1', None, None)]
[('0', '0'), ('0', '1'), (None, '2')]
['0', '0']

Đó là danh sách các ký tự cho từng vị trí của kết quả mong muốn. Các danh sách này được lọc lại và danh sách cuối cùng được thực hiện:

filter(None,x)   gives:

[('1', '0', '0'), ('2', '0', '0'), ('3', '1'), ('4',), ('5',)]
[('5', '0', '0'), ('4', '0', '1'), ('3', '1'), ('2',), ('1',)]
[('0', '0'), ('0', '1'), ('2',)]
['0', '0']

and with [-1]:

['0', '0', '1', '4', '5']
['0', '1', '1', '2', '1']
['0', '1', '2']
['0', '0']

Cuối cùng, danh sách kết quả được nối và in:

print''.join(..)

00145
01121
012
00

R, 107 97 byte

function(x)for(i in 1:max(lengths(x))){for(m in x)if(i<=length(m))cat(m[i],'\r',sep='');cat('
')}

Dường như không hoạt động trên TIO, điều này có thể liên quan đến việc sử dụng \rký tự trả về xe ngựa. Nó không hoạt động trên bản cài đặt R.

Đưa đầu vào dưới dạng danh sách chứa vectơ hàng:

x <- list(c("aaaa","aaaa","aaaa","aaaa"),c("bb","bb","bb"),c("c"))

Vòng lặp trên các hàng của mỗi hình chữ nhật, in trở lại vận chuyển sau mỗi hàng, khởi động lại dòng.

Nếu chúng ta kéo dài các quy tắc một chút, chúng ta có thể loại bỏ việc kiểm tra độ dài của đầu vào và chỉ lặp vô hạn, in một số lượng lớn các dòng mới:

R, 85 byte

function(x)for(i in 1:8e8){for(m in x)if(i<=length(m))cat(m[i],'\r',sep='');cat('
')}

APL (Dyalog Unicode) , 22 byte ^SBCS

Hàm tiền tố ẩn danh lấy danh sách các mảng ký tự 2D làm đối số. In.

(⊃{⍺@(⍳⍴⍺)⊢⍵}/)⌽,∘⊂1⌷↑

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

Điều này hoạt động bằng cách tạo một khung vẽ, sau đó gắn nó vào danh sách các khối và giảm (gấp) với chức năng đặt các khối trong góc.

↑ trộn khối 2D để tạo khối 3D trực giao, đệm chúng với khoảng trắng khi cần

1⌷ lấy lớp đầu tiên

⊂ kèm theo đó
 ∘ sau đó
⌽, thêm vào danh sách các khối bị đảo ngược

(... ) áp dụng các chức năng ngầm như sau:

 {... }/ giảm sử dụng lambda ẩn danh sau đây:

  ⊢⍵ với lập luận đúng như vải canvas

  ⍺@(Bản ) sửa đổi với các yếu tố của đối số bên trái, được đặt ở các chỉ số sau:

   ⍴⍺ hình dạng của đối số bên trái

   ⍳ các ɩ ndices của một loạt các hình dạng

 ⊃ tiết lộ (vì giảm kèm theo để giảm thứ hạng)

Haskell, 66 byte

unlines.foldl((const?)?)[]
(g?(a:b))(c:d)=g a c:(g?b)d;(_?a)b=a++b

Đầu vào được lấy dưới dạng danh sách các chuỗi theo thứ tự ngược lại, ví dụ cho trường hợp thử nghiệm đầu tiên : [["c"],["bb","bb","bb"],["aaaa","aaaa","aaaa","aaaa"]].

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

05AB1E , 12 byte

Giải pháp python của Port of TFeld được
lưu 2 byte nhờ Grimy

ζεðKζðδK€θJ,

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

Giải trình

ζ             # transpose input with space as filler
 ε            # apply to each
  ðK          # remove spaces
    ζ         # transpose with space as filler
     ðδK      # deep remove spaces
        €θ    # get the tail of each
          J   # join each
           ,  # print

Phiên bản 14 byte thay thế

õζεÅ»DŠg.$J}θ,

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

Giải trình

õζ              # zip with empty string as filler
  ε             # apply to each
   Å»      }    # cumulative reduce by
     D          # duplicate second input
      Š         # move down twice on stack
       g.$      # remove len(other_copy) elements from the other input
          J     # join with other copy
            θ,  # print the last element

Canvas , 5 byte

Ｈ１１╋╋

Hãy thử nó ở đây!

Nếu chồng chéo /+ \→ X, -+ |→ +, v.v. sẽ ổn, 2 byte sẽ hoạt động.

Python 2 , 77 byte

for t in map(None,*input()):
 r=''
 for s in t:
	if s:r=s+r[len(s):]
 print r

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

PowerShell 6 , chỉ giao diện điều khiển, 20 byte

dựa trên câu trả lời của Arnauld . Điều này chỉ hoạt động với bảng điều khiển và không hoạt động trên TIO.

cls
$args-join"`e[H"

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

PowerShell , 103 byte

$args|%{$l=$_-split'
';$r=&{$r+($l|%{''})|%{($x=$l[$j++])+($_-replace"^.{0,$("$x"|% Le*)}")}|?{$_}}}
$r

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

Chưa được kiểm soát:

$args|%{
    $l=$_-split"`n"
    $r=&{                           # run this scriptblock in a new scope
        $r+($l|%{''})|%{
            $x=$l[$j++]             # a new line or $null
            $w="$x"|% Length
            $y=$_-replace"^.{0,$w}" # remove first chars from the current line
            $x+$y                   # output the new line plus tail of the overlapped line
        }|?{$_}                     # filter out not empty lines only
    }                               # close the scope and remove all variables created in the scope
}
$r

C # (.NET Core) , 68 + 23 = 91 byte

n=>{C.Clear();n.ForEach(k=>{C.SetCursorPosition(0,0);C.Write(k);});}

23 byte dành cho nhập khẩu, using C=System.Console;

Không hoạt động trong TIO, vì nó không phải là bàn điều khiển.

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

Ruby , 67 byte

Đầu vào là một danh sách các dòng. Xây dựng một danh sách các dòng và ghi đè khi nó đi qua các đầu vào, sau đó nối chúng với một dòng mới (đại diện bởi biến $/) ở cuối để khớp với đầu ra nghiêm ngặt.

->i,*r{i.map{|e|j=-1;e.map{|l|r[j+=1]||='';r[j][0,l.size]=l}};r*$/}

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

C (GCC, MinGW) 138 byte

Giả sử rằng CR đặt con trỏ ở đầu dòng hiện tại.

d,i,l;f(S,n,p,t)char**S,*p,*t;{for(d=i=0;i<n;d+=l)p=strchr(t=S[i],10),printf("\n%.*s\r"+!!i,l=p?p-t:strlen(t),t),S[i++]+=l+!!p;d&&f(S,n);}

Đã thử nghiệm với:

int main()
{
    char *test1[] = {"aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"};
    char *test2[] = {"12345\n54321","00\n00\n00\n00","001\n011\n012"};
    char *test3[] = {"sm\noo\nmr\nee\nt!\nh_\ni_\nn_\ng_","!@#$%^\n&*()_+\nqwerty\nuiopas","this\nis_a\ntest"};

    f(test1, 3);
    f(test2, 3);
    f(test3, 3);
}

Octave , 71 67 byte

function y=f(x)
for k=1:size(x)
y(1:(t=size(x{k})),1:t(2))=x{k};end

Hàm lấy một mảng ô dọc của ma trận char và trả về ma trận char.

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Javascript (trình duyệt) , 216 208 204 byte

Nỗ lực của tôi ở đây. Tôi không hài lòng về kích thước, và chắc chắn phải có nhiều hơn để cải thiện, nhưng tôi không có kinh nghiệm chơi golf.

var n='\n',x=s=>s.split``.reverse().join``,i,j,f=a=>a.map(s=>s.split(n).map(y=>x(y))).reduce((a,b)=>{for(i=0;i<b.length;i++){j=a[i];if(!j)j=b[i];a[i]=b[i].padStart(j.length,j)}return a}).map(s=>x(s)).join(n)

Dù sao, những gì nó làm trước tiên là phân chia tất cả các chuỗi, sau đó đảo ngược tất cả các chuỗi, sau đó lặp lại trong một hoạt động giảm rút gọn Bắt đầu tất cả các chuỗi lại với nhau. Sau đó đảo ngược tất cả các chuỗi một lần nữa và sau đó nối chúng lại với dòng mới.

Đặc biệt cảm ơn Kevin Cruijssen đã nhắc nhở tôi rằng phần cuối cùng trong vòng lặp for xảy ra ở cuối và tổng tiết kiệm byte là 8 byte.

var n='\n',x=s=>s.split``.reverse().join``,i,j,f=a=>a.map(s=>s.split(n).map(y=>x(y))).reduce((a,b)=>{for(i=0;i<b.length;a[i]=b[i++].padStart(j.length,j))if(!(j=a[i]))j=b[i];return a}).map(s=>x(s)).join(n)

console.log(f(["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]));
console.log(f(["12345\n54321","00\n00\n00\n00","001\n011\n012"]));
console.log(f(["sm\noo\nmr\nee\nt!\nh_\ni_\nn_\ng_","!@#$%^\n&*()_+\nqwerty\nuiopas","this\nis_a\ntest"]));

C (gcc) , 51 47 byte

f(char**s){for(;*s;printf("\e[s%s\e[u",*s++));}

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

-4 byte nhờ vào trần nhà.

Sử dụng các chuỗi CSI để lưu / khôi phục vị trí con trỏ. Chỉ cần lặp lại qua mảng chuỗi đã qua (có cùng định dạng argv) và in<save position>string<restore position> cho từng .

Điều này không để con trỏ ở trên cùng bên trái, vì vậy khi chạy ở thiết bị đầu cuối, điều quan trọng là phải để lại đủ dòng mới sau đó để lời nhắc không bị chặn đầu vào.

Japt -P , 7 byte

Lấy đầu vào dưới dạng một chuỗi các chuỗi nhiều dòng, xuất ra một chuỗi nhiều dòng đơn.

ú y_¸¬Ì

Thử nó

ú y_¸¬Ì     :Implicit input of array
ú           :Right pad each line of each element with spaces to the length of the longest
  y         :Transpose
   _        :Map
    ¸       :  Split on spaces
     ¬      :  Join
      Ì     :  Last character
            :Implicitly join and output

Truy vấn T-SQL, 297 295 byte

Sử dụng làm dấu phân cách và một biến bảng làm đầu vào.

DECLARE @ table(a varchar(max),k int identity(1,1))
INSERT @ values('aaaa¶aaaa¶aaaa¶aaaa'),('bb¶bv¶bb'),('c');

WITH c as(SELECT k,row_number()over(partition
by k order by k)s,value v FROM @ CROSS APPLY
string_split(a,'¶')s),m(i,l,e)as(SELECT*FROM c
WHERE k=1UNION ALL
SELECT k,s,STUFF(e,1,len(v),v)FROM m
JOIN c ON-~i=k and s=l)SELECT
top 1with ties e FROM m
ORDER BY rank()over(partition by l order by-i)

Dùng thử trực tuyến

Javascript (trình duyệt), 129 124 byte

Nỗ lực đầu tiên của tôi tại golf golf. Tôi đọc các liên kết được đưa ra trong các quy tắc (sơ hở, quy tắc chuẩn ...), vì vậy tôi hy vọng tôi đã làm bất cứ điều gì sai!

Tôi giữ các đầu vào như trong bài đầu tiên (dạng mảng phẳng).

_=o=>{o=o.map(i=>i.split`\n`),r=o.shift();for(a of o)for(l in a)b=a[l],r[l]=r[l]?b+r[l].slice(b.length):b;return r.join`\n`}

Cảm ơn Kevin Cruijssen vì đã tiết kiệm 5 byte.

Các xét nghiệm:

_=o=>{o=o.map(i=>i.split`\n`),r=o.shift();for(a of o)for(l in a)b=a[l],r[l]=r[l]?b+r[l].slice(b.length):b;return r.join`\n`}

console.log(_(["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]));
console.log(_(["12345\n54321","00\n00\n00\n00","001\n011\n012"]));
console.log(_(["sm\noo\nmr\nee\nt!\nh_\ni_\nn_\ng_","!@#$%^\n&*()_+\nqwerty\nuiopas","this\nis_a\ntest"]));

Bình thường , 18 byte

L.tb0VyQsme #dy #N

Hãy thử trực tuyến!(lưu ý: bản thân mã chỉ đánh giá một khối, chế độ bộ kiểm tra của trình thông dịch chạy chương trình một lần cho mỗi dòng đầu vào)

Dựa trên giải pháp Python 2 của TFeld .

Giải trình:

L.tb0         # define a lambda function called y which does a transpose, padding with integer 0's
VyQ           # loop over transposed first input line (Q = eval(input()) ) (loop index = N)
   s          # concatenate array of strings (implicitly printed)
    m         # map over
         y #N # transpose of non-falsy values of N
     e        # for each item: last element of array
       #d     # relevant space at the start! filter with identity function, removes falsy values

để biết giải thích tại sao thuật toán tự hoạt động, hãy xem câu trả lời của TFeld.

Than , 4 byte

ＦθＰι

Dùng thử trực tuyến (dài dòng) hoặc thử trực tuyến (thuần túy) .

Giải trình:

Lặp lại danh sách đầu vào của chuỗi nhiều dòng:

For(q)
Ｆθ

Và in chuỗi nhiều dòng mà không di chuyển con trỏ:

Multiprint(i);
Ｐι