도전:

여러 줄로 된 문자열 목록이 주어지면 겹치게하고 (왼쪽 상단에) 결과를 출력하십시오.

예:

입력 : ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
출력 :

cbaa
bbaa
bbaa
aaaa

도전 규칙 :

• 입력 형식이 유연합니다. 입력을 2D 행 목록 (예 :) [["aaaa","aaaa","aaaa","aaaa"],["bb","bb","bb"],["c"]]또는 3D 문자 목록 (예 :)으로 가져올 수 있습니다 [[["a","a","a","a"],["a","a","a","a"],["a","a","a","a"],["a","a","a","a"]],[["b","b"],["b","b"],["b","b"]],[["c"]]]. STDIN을 통해 모든 입력을 하나씩 가져올 수 있습니다. 기타.
• 출력 형식이 엄격합니다. 여러 줄 문자열을 인쇄하거나 반환하도록 선택할 수 있습니다. 언어에 문자열이없는 경우 2D 문자 목록으로 출력하는 것이 대안으로 허용됩니다. 그러나 언어에 문자열이없는 경우에만 가능합니다.
• 입력 목록의 순서는 물론 중요하지만 원하는 경우 입력을 반대로 입력 할 수 있습니다.
• 입력에는 유니 코드 범위 $[33,126]$ ( !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~)의 인쇄 가능한 ASCII 만 포함됩니다 .
• 입력은 사각형 일 뿐이므로 이상한 모양은 없습니다. 그러나 출력은 필요한 사각형이 아닙니다.
• 후행 공백과 단일 후행 줄 바꿈이 허용됩니다. 선행 공백 및 / 또는 줄 바꿈이 아닙니다.

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하지 마십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙 은 기본 I / O 규칙으로 답변에 적용 되므로 STDIN / STDOUT, 적절한 매개 변수 및 반환 유형의 전체 프로그램과 함께 함수 / 방법을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트와 링크를 추가하십시오 (예 : TIO ).
• 또한 답변에 대한 설명을 추가하는 것이 좋습니다.

테스트 사례 :

입력 : ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
출력 :

cbaa
bbaa
bbaa
aaaa

입력 : ["12345\n54321","00\n00\n00\n00","001\n011\n012"]
출력 :

00145
01121
012
00

입력 : ["sm\noo\nmr\nee\nt!\nh_\ni_\nn_\ng_","!@#$%^\n&*()_+\nqwerty\nuiopas","this\nis_a\ntest"]
출력 :

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

젤리 , 3 바이트

a/Y

온라인으로 사용해보십시오!

한동안 젤리를 사용하지 않았지만 의견의 도전은 이길 수 있다고 생각했습니다. 논리 및 ( a)를 직접 사용 하여 입력의 각 요소 ( /) 간 스태킹 작업을 수행합니다 . Y필요한 형식으로 인쇄하는 데 사용됩니다.

자바 스크립트 (Node.js) , 24 바이트

@Grimy 덕분에 2 바이트 절약

리턴 된 문자열이 ANSI 이스케이프 코드 를 지원하는 터미널에 인쇄되었다고 가정합니다 . 인쇄 할 수없는 문자가 들어 있습니다 ESC로 (웃기려는 의도 없음) 이스케이프, \x1B아래를.

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

TIO에서는 작동하지 않지만 온라인으로 사용해 볼 수 있습니다! 대신 원시 출력을 볼 수 있습니다.

방법?

사용 된 CSI 시퀀스 는 다음과 같습니다.

• ED (디스플레이에서 삭제) :

  ESC[2J

  여기서 $2$ 는 "전체 화면 지우기"를 의미합니다.

• 컵 (커서 위치) :

  ESC[H

  어떤 수단 "커서 행으로 이동 $n$ 칼럼 $m$ " 모두 $n$ 및 $m$ 생략 암시로 설정 $1$ (화면의 왼쪽 상단).

출력 예

R , 120 , 111 (110) 107 바이트

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,,'')}

온라인으로 사용해보십시오!

문자 행렬 목록을 수락하는 기능 (3D 입력 허용)

(바이트 수에서 알 수 있듯이 R에서는 쉽지 않습니다.)

• @Giuseppe 덕분에 -9 바이트
• @RobinRyder 덕분에 -4 바이트

파이썬 2 , 88 바이트

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

온라인으로 사용해보십시오!

설명 (예) :

2D리스트를 입력으로받습니다.

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

먼저 입력 목록이 압축되어 각 입력 사각형의 행을 가져옵니다 ( map(None,l)가장 긴 지퍼와 동일 함).

map(n,*input())   gives:

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

그런 다음 각 행을 필터링하여 Nones 를 제거 하고 다시 압축합니다.

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

원하는 결과의 각 위치에 대한 문자 목록입니다. 이 목록은 다시 필터링되고 마지막 목록이 사용됩니다.

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

마지막으로 결과 목록이 결합되고 인쇄됩니다.

print''.join(..)

00145
01121
012
00

R, 107 97 바이트

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

\r캐리지 리턴 문자 사용과 관련이있을 수있는 TIO에서 작동하지 않는 것 같습니다 . 로컬 R 설치에서 작동합니다.

행 벡터를 포함하는 목록으로 입력을받습니다.

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

각 사각형의 행을 반복하여 각 캐리지 리턴을 인쇄하고 행을 다시 시작합니다.

규칙을 약간 늘리면 입력 길이를 확인하지 않고 무한히 반복하여 많은 줄 바꿈을 인쇄 할 수 있습니다.

R, 85 바이트

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 바이트 ^SBCS

익명의 암묵적 접두사 함수로 2D 문자 배열 목록을 인수로 사용합니다. 인쇄물.

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

온라인으로 사용해보십시오!

이것은 캔버스를 만든 다음 블록 목록에 추가하고 모서리에 블록을 배치하는 함수로 축소 (폴딩)하는 방식으로 작동합니다.

↑ 2D 블록을 혼합하여 직교 3D 블록을 생성하고 필요에 따라 공백으로 채 웁니다.

1⌷ 첫 번째 레이어를 가져

⊂ 둘러싸는
 ∘ 다음
⌽, 블록의 반전 목록을 앞에 추가

(… ) 다음 암묵적 기능을 적용하십시오.

 {… }/ 다음 익명 람다를 사용하여 줄입니다.

  ⊢⍵ 캔버스로 올바른 논증과 함께…

  ⍺@(... ) 배치 왼쪽 인자의 요소와 수정 에 다음과 같은 지표 :

   ⍴⍺ 좌파의 형태

   ⍳ɩ의 그 형상의 배열 ndices

 ⊃ 공개 (순위를 줄이기 위해 동봉 된 축소 때문에)

하스켈, 66 바이트

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

입력은 문자열 목록의 목록으로 거꾸로 표시됩니다 (예 : 첫 번째 테스트 사례의 경우) [["c"],["bb","bb","bb"],["aaaa","aaaa","aaaa","aaaa"]].

온라인으로 사용해보십시오!

05AB1E , 12 바이트

포트 TFeld의 파이썬 솔루션
2 바이트에 감사를 저장 검댕으로 더럽혀진

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

온라인으로 사용해보십시오!

설명

ζ             # 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

대체 14 바이트 버전

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

온라인으로 사용해보십시오!

설명

õζ              # 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

캔버스 , 5 바이트

Ｈ１１╋╋

여기 사용해보십시오!

/+ \→ X, -+ |→ +등이 겹치면 2 바이트 가 작동합니다.

파이썬 2 , 77 바이트

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

온라인으로 사용해보십시오!

PowerShell 6 , 콘솔 전용, 20 바이트

Arnauld의 답변을 기반으로 합니다. 이것은 콘솔에서만 작동하며 TIO에서는 작동하지 않습니다.

cls
$args-join"`e[H"

온라인으로 사용해보십시오!

PowerShell , 103 바이트

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

온라인으로 사용해보십시오!

풀림 :

$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 코어) , 68 + 23 = 91 바이트

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

23 바이트는 가져 오기 용입니다. using C=System.Console;

콘솔이 아니기 때문에 TIO에서는 작동하지 않습니다.

온라인으로 사용해보십시오!

루비 , 67 바이트

입력은 라인 목록입니다. 행 목록을 작성하고 입력을 통과 할 때 겹쳐 쓰고 $/엄격한 출력과 일치하도록 끝에 줄 바꿈 (변수로 표시 )을 결합합니다.

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

온라인으로 사용해보십시오!

C (GCC, MinGW) 138 바이트

CR이 현재 행의 시작 부분에 커서를 놓았다고 가정합니다.

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

로 테스트 :

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

옥타브 , 71 67 바이트

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

문자 행렬로 구성된 세로 셀형 배열을 가져와 문자 행렬을 반환하는 함수입니다.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

자바 (브라우저) , 216 (208) 204 바이트

이것에 대한 나의 시도. 나는 크기에 대해 행복하지 않으며, 개선을 위해 더 많은 것이 있어야하지만 골프를 경험 한 사람은 아닙니다.

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)

어쨌든 그것이하는 일은 먼저 모든 문자열을 분할 한 다음 모든 문자열을 뒤집은 다음 축소 작업에서 반복하는 동안 뒤집은 패드 모든 문자열을 함께 시작하십시오. 그런 다음 모든 문자열을 다시 뒤집은 다음 줄 바꿈으로 다시 결합하십시오.

for 루프의 마지막 부분이 마지막에 발생하고 총 8 바이트가 절약된다는 점을 상기시켜 준 Kevin Cruijssen 에게 특별히 감사드립니다 .

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 바이트

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

온라인으로 사용해보십시오!

ceilingcat 덕분에 -4 바이트.

커서 위치 저장 / 복원에 CSI 시퀀스를 사용합니다. 전달 된 문자열 배열을 (와 같은 형식으로 argv) 반복 하고 인쇄합니다.<save position>string<restore position> 각각에 대해 합니다.

이렇게하면 커서가 왼쪽 상단에 남게되므로 터미널에서 실행할 때 프롬프트가 입력을 방해하지 않도록 충분한 줄 바꿈을 남겨 두어야합니다.

Japt -P , 7 바이트

입력을 여러 줄 문자열의 배열로 가져와 단일 여러 줄 문자열을 출력합니다.

ú y_¸¬Ì

시도 해봐

ú 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

T-SQL 쿼리, 297 295 바이트

구분자로 ¶를 사용하고 입력으로 테이블 변수를 사용하십시오.

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)

온라인으로 사용해보십시오

자바 스크립트 (브라우저), 129124 바이트

코드 골프에 대한 나의 첫 번째 시도. 나는 규칙 (허점, 표준 규칙 ...)에 주어진 링크를 읽었으므로 내가 잘못한 것을 희망합니다!

입력이 첫 번째 게시물 (평면 배열 형식)에 그대로 유지했습니다.

_=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`}

5 바이트를 절약 한 Kevin Cruijssen 에게 감사 합니다.

테스트 :

_=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"]));

Pyth , 18 바이트

L.tb0VyQsme #dy #N

온라인으로 사용해보십시오! (참고 : 코드 자체는 하나의 블록 만 평가하며, 인터프리터의 테스트 스위트 모드는 각 입력 라인마다 한 번씩 프로그램을 실행합니다)

TFeld의 Python 2 솔루션을 기반으로 합니다 .

설명:

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

알고리즘 자체가 작동하는 이유에 대한 설명은 TFeld의 답변을 참조하십시오.

숯 , 4 바이트

ＦθＰι

온라인 (자세한 내용)으로 시도 하거나 온라인으로 시도하십시오 (순수) .

설명:

여러 줄 문자열의 입력 목록을 반복합니다.

For(q)
Ｆθ

커서를 움직이지 않고 여러 줄 문자열을 인쇄하십시오.

Multiprint(i);
Ｐι