Herausforderung:

Überlappen Sie eine Liste mehrzeiliger Zeichenfolgen (oben links) und geben Sie das Ergebnis aus.

Beispiel:

Eingabe: ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
Ausgabe:

cbaa
bbaa
bbaa
aaaa

Herausforderungsregeln:

• Das Eingabeformat ist flexibel. Sie können die Eingabe als 2D-Liste von Linien (dh [["aaaa","aaaa","aaaa","aaaa"],["bb","bb","bb"],["c"]]) oder 3D-Liste von Zeichen (dh [[["a","a","a","a"],["a","a","a","a"],["a","a","a","a"],["a","a","a","a"]],[["b","b"],["b","b"],["b","b"]],[["c"]]]) erhalten. Sie können alle Eingaben einzeln über STDIN vornehmen. Etc.
• Das Ausgabeformat ist streng. Sie können die mehrzeilige Zeichenfolge drucken oder zurückgeben. (Wenn Ihre Sprache keine Zeichenketten enthält, ist die Ausgabe als 2D-Liste von Zeichen als Alternative zulässig. Aber nur, wenn Ihre Sprache überhaupt keine Zeichenketten enthält.)
• Die Reihenfolge der Eingabeliste ist natürlich wichtig (aber Sie können die Eingabe auch in umgekehrter Reihenfolge vornehmen, wenn Sie dies wünschen).
• Eingaben enthalten nur druckbare ASCII-Zeichen im Unicode-Bereich $[33,126]$ ( !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~).
• Eingaben sind nur Rechtecke (also keine seltsamen Formen). Die Ausgabe ist jedoch kein notwendiges Rechteck.
• Nachgestellte Leerzeichen und eine einzelne nachgestellte Zeile sind zulässig. Führende Leerzeichen und / oder Zeilenumbrüche nicht.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp, verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu (z. B. TIO ).
• Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Testfälle:

Eingabe: ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
Ausgabe:

cbaa
bbaa
bbaa
aaaa

Eingabe: ["12345\n54321","00\n00\n00\n00","001\n011\n012"]
Ausgabe:

00145
01121
012
00

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

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

Gelee , 3 Bytes

a/Y

Probieren Sie es online!

Hatte Jelly schon eine Weile nicht mehr benutzt, aber ich fand die Herausforderung in den Kommentaren besiegbar. Verwendet direkt logisch und ( a), um die Stapeloperation zwischen jedem Element der Eingabe ( /) auszuführen . Ywird verwendet, um im gewünschten Format zu drucken.

JavaScript (Node.js) , 24 Byte

2 Bytes dank @Grimy gespart

Angenommen, die zurückgegebene Zeichenfolge wird auf einem Terminal gedruckt, das ANSI-Escape-Codes unterstützt . Enthält das nicht druckbare Zeichen ESC, das wie folgt maskiert wird (kein Wortspiel beabsichtigt) \x1B.

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

Dies funktioniert nicht mit TIO, aber Sie können es online ausprobieren! stattdessen die rohe Ausgabe zu sehen.

Wie?

Die verwendeten CSI-Sequenzen sind:

• ED (Löschen im Display):

  ESC[2J

  wobei $2$ mittels „clear gesamter Bildschirm“

• CUP (Cursorposition):

  ESC[H

  Dies bedeutet, "bewegt den Cursor in Zeile $n$ , Spalte $m$ ", wobei sowohl $n$ als auch $m$ weggelassen und implizit auf $1$ (obere linke Ecke des Bildschirms).

Beispielausgabe

R , 120 , 111 110 107 Bytes

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

Probieren Sie es online!

Eine Funktion, die eine Liste von Zeichenmatrizen akzeptiert (3D-Eingabe wird akzeptiert).

(Wie Sie an der Anzahl der Bytes erkennen können, ist dies in R nicht ganz einfach ...)

• -9 Bytes dank @ Giuseppe
• -4 Bytes dank @RobinRyder

Python 2 , 88 Bytes

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

Probieren Sie es online!

Erklärung (mit Beispiel):

Nimmt eine 2D-Liste als Eingabe.

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

Zuerst wird die Eingabeliste gezippt, um die Zeilen der einzelnen Eingaberechtecke zu erhalten (entspricht map(None,l)einer Zip-Länge):

map(n,*input())   gives:

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

Jede dieser Zeilen wird dann gefiltert, um Nones zu entfernen , und erneut komprimiert:

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

Welches ist eine Liste von Zeichen für jede Position des gewünschten Ergebnisses. Diese Listen werden erneut gefiltert und die letzte wird genommen:

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

Zuletzt werden die resultierenden Listen zusammengefügt und gedruckt:

print''.join(..)

00145
01121
012
00

R 107 97 Bytes

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

Funktioniert anscheinend nicht mit TIO, was möglicherweise mit der Verwendung des \rWagenrücklaufzeichens zusammenhängt. Es funktioniert auf meiner lokalen Installation von R.

Nimmt die Eingabe als Liste mit einem Vektor von Zeilen:

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

Durchläuft die Zeilen jedes Rechtecks, druckt nach jedem Zeilenumbruch einen Zeilenumbruch und startet die Zeile neu.

Wenn wir die Regeln ein wenig ausdehnen, können wir die Länge der Eingabe überprüfen und einfach eine Endlosschleife ausführen und eine große Anzahl von Zeilenumbrüchen ausgeben:

R, 85 Bytes

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

Anonyme implizite Präfixfunktion, die eine Liste von 2D-Zeichenarrays als Argument verwendet. Druckt.

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

Probieren Sie es online!

Dies funktioniert, indem eine Zeichenfläche erstellt, diese dann an die Liste der Blöcke angehängt und mit einer Funktion, die Blöcke in der Ecke platziert, verkleinert (gefaltet) wird.

↑ Mischen Sie den 2D-Block, um einen orthogonalen 3D-Block zu erstellen, und füllen Sie ihn nach Bedarf mit Leerzeichen auf

1⌷ Nimm die erste Schicht

⊂ legen Sie das
 ∘ dann bei
⌽,  der umgekehrten Liste von Blöcken voran

(…)  Wenden folgende stillschweigende Funktion an:

 {…}/  Reduzieren mit dem folgenden anonymen Lambda:

  ⊢⍵ mit dem richtigen argument als leinwand ...

  ⍺@(… ) Ändern mit den Elementen des linken Arguments, platziert bei folgenden Stellen platziert sind:

   ⍴⍺ die Form des linken Arguments

   ⍳ die ɩ eines Arrays dieser Form

 ⊃ offen zu legen (weil die Reduzierung um Rang eingeschlossen)

Haskell, 66 Bytes

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

Die Eingabe wird als eine Liste der Liste von Zeichenketten in umgekehrter Reihenfolge genommen, zB für den ersten Testfall: [["c"],["bb","bb","bb"],["aaaa","aaaa","aaaa","aaaa"]].

Probieren Sie es online!

05AB1E , 12 Bytes

Port von TFelds Python-Lösung
2 Bytes gespart dank Grimy

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

Probieren Sie es online!

Erläuterung

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

Alternative 14-Byte-Version

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

Probieren Sie es online!

Erläuterung

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

Ｈ１１╋╋

Probieren Sie es hier aus!

Wenn ein Überlappen von /+ \→ X, -+ |→ +usw. in Ordnung wäre, würden 2 Bytes funktionieren.

Python 2 , 77 Bytes

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

Probieren Sie es online!

PowerShell 6 , nur Konsole, 20 Byte

basierend auf Arnauld's Antwort . Dies funktioniert nur mit der Konsole und nicht mit TIO.

cls
$args-join"`e[H"

Probieren Sie es online!

PowerShell , 103 Byte

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

Probieren Sie es online!

Abgerollt:

$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 Bytes ist für den Import, using C=System.Console;

Funktioniert nicht in TIO, da es keine Konsole ist.

Probieren Sie es online!

Ruby , 67 Bytes

Die Eingabe ist eine Liste von Zeilen. Erstellt eine Liste von Zeilen und überschreibt diese während des Durchlaufs der Eingaben. Anschließend werden sie mit einer neuen Zeile (dargestellt durch die Variable $/) am Ende verbunden, um der strengen Ausgabe zu entsprechen.

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

Probieren Sie es online!

C (GCC, MinGW) 138 Bytes

Es wird davon ausgegangen, dass CR den Cursor an den Anfang der aktuellen Zeile setzt.

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

Getestet mit:

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

Oktave , 71 67 Bytes

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

Funktion, die ein vertikales Zellenarray von Zeichenmatrizen verwendet und eine Zeichenmatrix zurückgibt.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Javascript (Browser) , 216 208 204 Bytes

Mein Versuch dazu. Ich bin nicht glücklich über die Größe und es muss sicherlich noch mehr für Verbesserungen geben, aber ich bin nicht so erfahren im Golfen.

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)

Auf jeden Fall werden zuerst alle Zeichenfolgen aufgeteilt, dann alle Zeichenfolgen umgedreht und dann in einer Reduce-Operation geloopt umgedreht Reduce- gestartet. PadStart all the strings together. Kehren Sie dann alle Zeichenfolgen erneut um und fügen Sie sie mit Zeilenumbrüchen wieder zusammen.

Besonderer Dank geht an Kevin Cruijssen , der mich daran erinnert hat, dass der letzte Teil einer for-Schleife am Ende stattfindet und insgesamt 8 Byte eingespart werden .

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 Bytes

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

Probieren Sie es online!

-4 Bytes dank Ceilingcat.

Verwendet die CSI-Sequenzen zum Speichern / Wiederherstellen der Cursorposition. Durchläuft einfach das übergebene String-Array (im selben Format wie argv) und druckt<save position>string<restore position> für jedes.

Der Cursor bleibt dabei oben links. Wenn Sie also am Terminal arbeiten, müssen Sie danach genügend Zeilenumbrüche einfügen, damit die Eingabeaufforderung die Eingabe nicht blockiert.

Japt -P , 7 Bytes

Übernimmt die Eingabe als Array von mehrzeiligen Zeichenfolgen und gibt eine einzelne mehrzeilige Zeichenfolge aus.

ú y_¸¬Ì

Versuch es

ú 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-Abfrage, 297 295 Byte

Verwenden von ¶ als Trennzeichen und einer Tabellenvariablen als Eingabe.

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)

Probieren Sie es online aus

Javascript (Browser), 129 124 Bytes

Mein erster Versuch, Code Golf zu spielen. Ich habe die in den Regeln angegebenen Links gelesen (Lücken, Standardregeln ...) und hoffe, dass ich etwas falsch gemacht habe!

Ich habe die Eingaben beibehalten, wie sie im ersten Beitrag (flache Array-Form) sind.

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

Vielen Dank an Kevin Cruijssen für das Speichern von 5 Bytes.

Tests:

_=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 Bytes

L.tb0VyQsme #dy #N

Probieren Sie es online! (Hinweis: Der Code selbst wertet nur einen Block aus. Im Test-Suite-Modus des Interpreters wird das Programm für jede Eingabezeile einmal ausgeführt.)

Basiert auf der Python 2-Lösung von TFeld .

Erläuterung:

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

Eine Erklärung, warum der Algorithmus selbst funktioniert, finden Sie in der Antwort von TFeld.

Kohle , 4 Bytes

ＦθＰι

Probieren Sie es online (ausführlich) oder online (rein) .

Erläuterung:

Durchlaufen Sie die Eingabeliste mehrzeiliger Zeichenfolgen:

For(q)
Ｆθ

Und drucken Sie die mehrzeilige Zeichenfolge, ohne den Cursor zu bewegen:

Multiprint(i);
Ｐι