Wyzwanie:

Biorąc pod uwagę listę ciągów wieloliniowych, nałóż je (w lewym górnym rogu) i wyślij wynik.

Przykład:

Wejście: ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
Wyjście:

cbaa
bbaa
bbaa
aaaa

Zasady konkursu:

• Format wejściowy jest elastyczny. Dozwolone jest uzyskanie danych wejściowych w postaci dwuwymiarowej listy linii (tj. [["aaaa","aaaa","aaaa","aaaa"],["bb","bb","bb"],["c"]]) Lub trójwymiarowej listy znaków (tj [[["a","a","a","a"],["a","a","a","a"],["a","a","a","a"],["a","a","a","a"]],[["b","b"],["b","b"],["b","b"]],[["c"]]].). Możesz przejąć wszystkie dane wejściowe jeden po drugim przez STDIN. Itp.
• Format wyjściowy jest ścisły. Możesz wydrukować lub zwrócić ciąg wielu wierszy. (Jeśli twój język nie ma żadnych ciągów, wyświetlanie jako 2D znaków jest dozwolone jako alternatywa. Ale tylko jeśli twój język w ogóle nie ma ciągów.)
• Kolejność listy danych wejściowych jest oczywiście ważna (ale jeśli chcesz, możesz wprowadzić dane w odwrotnej kolejności).
• Wejścia będą zawierać tylko drukowalne ASCII w zakresie Unicode $[33,126]$ ( !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~).
• Wejściami będą tylko prostokąty (więc żadne dziwne kształty). Dane wyjściowe nie są jednak niezbędnymi prostokątami.
• Dozwolone są końcowe spacje i pojedyncza nowa linia. Wiodące spacje i / lub znaki nowej linii nie.

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi mają zastosowanie standardowe reguły z domyślnymi regułami We / Wy , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i typem zwracanych, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem kodu (tj. TIO ).
• Zalecane jest również dodanie wyjaśnienia do odpowiedzi.

Przypadki testowe:

Wejście: ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
Wyjście:

cbaa
bbaa
bbaa
aaaa

Wejście: ["12345\n54321","00\n00\n00\n00","001\n011\n012"]
Wyjście:

00145
01121
012
00

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

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

Galaretka , 3 bajty

a/Y

Wypróbuj online!

Dawno nie używałem Jelly, ale myślałem, że wyzwanie w komentarzach było do pokonania. Bardzo bezpośrednio używa logicznego i ( a) do wykonania operacji układania między poszczególnymi elementami input ( /). Ysłuży do drukowania w wymaganym formacie.

JavaScript (Node.js) , 24 bajty

Zaoszczędź 2 bajty dzięki @Grimy

Zakłada, że ​​zwracany ciąg jest drukowany na terminalu obsługującym kody specjalne ANSI . Zawiera znak ESC, którego nie można wydrukować , który jest uciekany (nie jest przeznaczony gra słów), jak \x1Bponiżej.

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

To nie działa w TIO, ale możesz wypróbować online! zamiast tego zobaczyć surowe dane wyjściowe.

W jaki sposób?

Zastosowane sekwencje CSI to:

• ED (Erase in Display):

  ESC[2J

  gdzie $2$ oznacza „wyczyść cały ekran”

• CUP (pozycja kursora):

  ESC[H

  co oznacza „przesuwa kursor do wiersza $n$ , kolumny $m$ ”, gdzie zarówno $n$ jak i $m$ są pomijane i domyślnie ustawione na $1$ (lewy górny róg ekranu).

Przykładowe dane wyjściowe

R , 120 , 111 110 107 bajtów

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

Wypróbuj online!

Funkcja akceptująca listę macierzy znaków (akceptowane jest wprowadzanie 3D).

(jak widać z liczby bajtów, nie jest to bardzo łatwe w R ...)

• -9 bajtów dzięki @Giuseppe
• -4 bajty dzięki @RobinRyder

Python 2 , 88 bajtów

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

Wypróbuj online!

Objaśnienie (z przykładem):

Pobiera na wejściu listę 2D.

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

Najpierw lista wejściowa jest skompresowana, aby uzyskać wiersze każdego prostokąta wejściowego ( map(None,l)jest tak samo długa jak zip):

map(n,*input())   gives:

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

Każdy z tych wierszy jest następnie filtrowany w celu usunięcia Nones i ponownie skompresowany:

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

Która jest listą znaków dla każdej pozycji pożądanego wyniku. Te listy są ponownie filtrowane, a ostatnia jest pobierana:

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

Na koniec powstałe listy są łączone i drukowane:

print''.join(..)

00145
01121
012
00

R, 107 97 bajtów

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

Nie działa na TIO, co może być związane z używaniem \rznaku powrotu karetki. Działa na mojej lokalnej instalacji R.

Pobiera dane wejściowe jako listę zawierającą wektor wierszy:

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

Pętle nad rzędami każdego prostokąta, po każdym wypisuje powrót karetki, ponownie uruchamiając linię.

Jeśli nieco rozciągniemy reguły, możemy zrezygnować ze sprawdzania długości danych wejściowych i po prostu zapętlać nieskończenie, drukując ogromną liczbę znaków nowego wiersza:

R, 85 bajtów

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 bajty ^SBCS

Anonimowa funkcja ukrytego prefiksu przyjmująca listę argumentów tablic znaków 2D. Wydruki

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

Wypróbuj online!

Działa to poprzez utworzenie obszaru roboczego, a następnie dołączenie go do listy bloków i zmniejszenie (składanie) za pomocą funkcji umieszczającej bloki w rogu.

↑ mieszaj blok 2D, aby utworzyć prostokątny blok 3D, wypełniając je spacjami w razie potrzeby

1⌷ weź pierwszą warstwę

⊂ załącz,
 ∘ a następnie
⌽, dodaj odwróconą listę bloków

(… ) Zastosuj następującą funkcję ukrytą:

 {… }/ Zredukuj używając następującej anonimowej lambda:

  ⊢⍵ z właściwym argumentem jako płótno…

  ⍺@(… ) Poprawiając elementy lewego argumentu umieszczonego przy następujących indeksach:

   ⍴⍺ kształt lewego argumentu

   ⍳ z ɩ ndices tablicy tego kształtu

 ⊃ ujawnić (ponieważ redukcja zawarta w celu zmniejszenia rangi)

Haskell, 66 bajtów

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

Wejście jest brane jako lista listy ciągów w odwrotnej kolejności, na przykład dla pierwszego przypadku testowego: [["c"],["bb","bb","bb"],["aaaa","aaaa","aaaa","aaaa"]].

Wypróbuj online!

05AB1E , 12 bajtów

Rozwiązanie portu Python TFeld
2 bajty zapisane dzięki Grimy

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

Wypróbuj online!

Wyjaśnienie

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

Alternatywna wersja 14-bajtowa

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

Wypróbuj online!

Wyjaśnienie

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

Płótno , 5 bajtów

Ｈ１１╋╋

Wypróbuj tutaj!

Jeśli nakładanie /+ \→ X, -+ |→ +itd. Byłoby w porządku, działałyby 2 bajty .

Python 2 , 77 bajtów

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

Wypróbuj online!

PowerShell 6 , tylko konsola, 20 bajtów

na podstawie odpowiedzi Arnaulda . Działa tylko z konsolą i nie działa na TIO.

cls
$args-join"`e[H"

Wypróbuj online!

PowerShell , 103 bajty

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

Wypróbuj online!

Rozwinięty:

$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 bajtów

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

23 bajty przeznaczone są na import, using C=System.Console;

Nie działa w TIO, ponieważ nie jest konsolą.

Wypróbuj online!

Rubinowy , 67 bajtów

Dane wejściowe to lista wierszy. Tworzy listę linii i nadpisuje, gdy przechodzi przez dane wejściowe, a następnie łączy je z nową linią (reprezentowaną przez zmienną $/) na końcu, aby dopasować ścisłe wyjście.

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

Wypróbuj online!

C (GCC, MinGW) 138 bajtów

Zakłada, że ​​CR umieszcza kursor na początku bieżącej linii.

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

Testowane z:

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

Oktawa , 71 67 bajtów

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

Funkcja, która pobiera pionową tablicę komórek macierzy znaków i zwraca macierz znaków.

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

JavaScript (przeglądarka) , 216 208 204 bajtów

Moja próba tego. Nie jestem zadowolony z tego rozmiaru i na pewno musi być coś więcej do poprawy, ale nie mam tak dużego doświadczenia w golfie.

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)

W każdym razie to, co robi, najpierw dzieli wszystkie ciągi, następnie odwraca wszystkie ciągi, a następnie zapętla operację redukcji zapętla Rozpocznij wszystkie struny razem. Następnie ponownie odwróć wszystkie ciągi, a następnie połącz je ponownie z nowymi liniami.

Specjalne podziękowania dla Kevina Cruijssena za przypomnienie, że ostatnia część pętli for ma miejsce na końcu, a łączna oszczędność bajtów wynosi 8 bajtów.

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 bajtów

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

Wypróbuj online!

-4 bajty dzięki pułapkowi cat.

Wykorzystuje sekwencje CSI do zapisywania / przywracania pozycji kursora. Wystarczy iterować po przekazanej tablicy ciągów (w tym samym formacie co argv) i drukuje<save position>string<restore position> dla każdego.

To powoduje pozostawienie kursora w lewym górnym rogu, dlatego podczas uruchamiania na terminalu ważne jest, aby później pozostawić wystarczającą liczbę znaków nowej linii, aby monit nie blokował danych wejściowych.

Japt -P , 7 bajtów

Pobiera dane wejściowe jako tablicę ciągów wieloliniowych, generuje pojedynczy ciąg wielu linii.

ú y_¸¬Ì

Spróbuj

ú 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

Zapytanie T-SQL, 297 295 bajtów

Użycie ¶ jako separatora i zmiennej tabeli jako danych wejściowych.

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)

Wypróbuj online

JavaScript (przeglądarka), 129 124 bajtów

Moja pierwsza próba gry w golfa kodowego. Czytam linki podane w regulaminie (luki, standardowe zasady ...), więc mam nadzieję, że zrobiłem coś złego!

Zachowałem dane wejściowe tak, jak są w pierwszym poście (forma płaskiej tablicy).

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

Podziękowania dla Kevina Cruijssena za oszczędność 5 bajtów.

Testy:

_=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 bajtów

L.tb0VyQsme #dy #N

Wypróbuj online! (uwaga: sam kod ocenia tylko jeden blok, tryb zestawu testów tłumacza uruchamia program jeden raz dla każdego wiersza wprowadzania)

Na podstawie rozwiązania Python 2 firmy TFeld .

Wyjaśnienie:

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

wyjaśnienie, dlaczego sam algorytm działa, patrz odpowiedź TFeld.

Węgiel drzewny , 4 bajty

ＦθＰι

Wypróbuj online (pełne) lub wypróbuj online (czyste) .

Wyjaśnienie:

Pętla nad listą wejściową ciągów wieloliniowych:

For(q)
Ｆθ

I wydrukuj ciąg wielu linii bez przesuwania kursora:

Multiprint(i);
Ｐι