Sfida:

Dato un elenco di stringhe multilinea, sovrapporle (in alto a sinistra) e produrre il risultato.

Esempio:

Ingresso: ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
Uscita:

cbaa
bbaa
bbaa
aaaa

Regole della sfida:

• Il formato di input è flessibile. È consentito ottenere l'input come un elenco di linee 2D (ad es. [["aaaa","aaaa","aaaa","aaaa"],["bb","bb","bb"],["c"]]) O un elenco di caratteri 3D (ad es [[["a","a","a","a"],["a","a","a","a"],["a","a","a","a"],["a","a","a","a"]],[["b","b"],["b","b"],["b","b"]],[["c"]]].). È consentito prendere tutti gli input uno per uno tramite STDIN. Eccetera.
• Il formato di output è rigoroso. È possibile scegliere di stampare o restituire la stringa multilinea. (Se la tua lingua non ha stringhe, l'output come elenco 2D di caratteri è consentito come alternativa. Ma solo se la tua lingua non ha stringhe.)
• L'ordine della lista di input è ovviamente importante (ma puoi scegliere di invertire l'input se scegli di farlo).
• Gli input conterranno solo ASCII stampabili nell'intervallo unicode $[33,126]$ ( !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~).
• Gli input saranno solo rettangoli (quindi nessuna forma strana). Tuttavia, i risultati non sono rettangoli necessari.
• Sono consentiti spazi finali e una nuova riga finale finale. Spazi iniziali e / o newline no.

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard con regole I / O predefinite , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice (ad es. TIO ).
• Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Casi test:

Ingresso: ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
Uscita:

cbaa
bbaa
bbaa
aaaa

Ingresso: ["12345\n54321","00\n00\n00\n00","001\n011\n012"]
Uscita:

00145
01121
012
00

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

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

Gelatina , 3 byte

a/Y

Provalo online!

Non usavo Jelly da un po 'ma pensavo che la sfida nei commenti fosse battibile. Utilizza molto direttamente la logica e ( a) per eseguire l'operazione di sovrapposizione tra ciascun elemento dell'input ( /). Yviene utilizzato per stampare nel formato richiesto.

JavaScript (Node.js) , 24 byte

Salvato 2 byte grazie a @Grimy

Presuppone che la stringa restituita sia stampata su un terminale che supporta i codici di escape ANSI . Contiene il carattere non stampabile ESC, che è sfuggito (nessun gioco di parole previsto) come di \x1Bseguito.

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

Questo non funziona su TIO, ma puoi provarlo online! per vedere invece l'output non elaborato.

Come?

Le sequenze CSI utilizzate sono:

• ED (Cancella in display):

  ESC[2J

  dove $2$ significa "cancella tutto lo schermo"

• CUP (posizione del cursore):

  ESC[H

  il che significa "sposta il cursore sulla riga $n$ , colonna $m$ " dove sia $n$ che $m$ sono implicitamente impostati su $1$ (angolo superiore sinistro dello schermo).

Esempio di output

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

Provalo online!

Una funzione che accetta un elenco di matrici di caratteri (viene accettato l'input 3D).

(come puoi notare dal conteggio dei byte, questo non è molto facile da fare in R ...)

• -9 byte grazie a @Giuseppe
• -4 byte grazie a @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)))

Provalo online!

Spiegazione (con esempio):

Accetta un elenco 2D come input.

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

Per prima cosa l'elenco di input è compresso, per ottenere le righe di ogni rettangolo di input ( map(None,l)è lo stesso uno zip più lungo):

map(n,*input())   gives:

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

Ciascuna di queste righe viene quindi filtrata su Nones rimossa e zippata di nuovo:

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

Quale è un elenco di caratteri per ogni posizione del risultato desiderato. Questi elenchi vengono nuovamente filtrati e l'ultimo è preso:

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

Infine, gli elenchi risultanti vengono uniti e stampati:

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

Non sembra funzionare su TIO, che potrebbe essere correlato all'uso del \rcarattere di ritorno a capo. Funziona sulla mia installazione locale di R.

Prende l'input come un elenco contenente un vettore di righe:

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

Passa sopra le righe di ciascun rettangolo, stampando un ritorno a capo dopo ciascuna, riavviando la linea.

Se allunghiamo un po 'le regole, possiamo fare a meno di controllare la lunghezza dell'input e di fare un ciclo infinito, stampando una grande quantità di righe:

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

Funzione di prefisso tacito anonimo che prende come argomento un elenco di matrici di caratteri 2D. Stampe.

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

Provalo online!

Funziona creando una tela, quindi aggiungendola all'elenco dei blocchi e riducendo (piegando) con una funzione che posiziona i blocchi nell'angolo.

↑ mescolare il blocco 2D per creare un blocco 3D ortogonale, riempiendolo di spazi se necessario

1⌷ prendere il primo strato

⊂ allegare che
 ∘ quindi
⌽, anteporre l'elenco di blocchi invertito

(... ) applica la seguente funzione tacita:

 {... }/ riduci utilizzando la seguente lambda anonima:

  ⊢⍵ con l'argomento giusto come tela ...

  ⍺@(... ) modifica con gli elementi dell'argomento sinistro, collocati nei seguenti indici:

   ⍴⍺ la forma dell'argomento sinistro

   ⍳ i d ndices di una matrice di quella forma

 ⊃ divulgare (perché la riduzione allegata per ridurre il grado)

Haskell, 66 byte

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

Ingresso è preso come una lista di lista di stringhe in ordine inverso, ad esempio per il primo banco di prova: [["c"],["bb","bb","bb"],["aaaa","aaaa","aaaa","aaaa"]].

Provalo online!

05AB1E , 12 byte

La soluzione Python di Port of TFeld ha
salvato 2 byte grazie a Grimy

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

Provalo online!

Spiegazione

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

Versione alternativa a 14 byte

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

Provalo online!

Spiegazione

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

Tela , 5 byte

Ｈ１１╋╋

Provalo qui!

Se la sovrapposizione /+ \→ X, -+ |→ +, ecc. Andasse bene, funzionerebbero 2 byte .

Python 2 , 77 byte

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

Provalo online!

PowerShell 6 , solo console, 20 byte

basato sulla risposta di Arnauld . Funziona solo con console e non funziona su TIO.

cls
$args-join"`e[H"

Provalo online!

PowerShell , 103 byte

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

Provalo online!

srotolato:

$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 è per l'importazione, using C=System.Console;

Non funziona in TIO, poiché non è una console.

Provalo online!

Rubino , 67 byte

L'input è un elenco di righe. Crea un elenco di righe e sovrascrive mentre passa attraverso gli input, quindi li unisce con una nuova riga (rappresentata dalla variabile $/) alla fine per corrispondere all'output rigoroso.

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

Provalo online!

C (GCC, MinGW) 138 byte

Suppone che CR posiziona il cursore all'inizio della riga corrente.

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

Testato con:

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

Ottava , 71 67 byte

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

Funzione che accetta una matrice di celle verticali di matrici di caratteri e restituisce una matrice di caratteri.

Provalo online! Oppure verifica tutti i casi di test .

Javascript (browser) , 216 208 204 byte

Il mio tentativo di farlo. Non sono contento delle dimensioni, e sicuramente ci devono essere molti altri miglioramenti, ma non sono così esperto nel 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)

Ad ogni modo, ciò che fa è prima di tutto dividere tutte le stringhe, quindi invertire tutte le stringhe, quindi durante il looping in un pad operativo ridotto tutte le stringhe insieme. Quindi invertire nuovamente tutte le stringhe e ricollegarle con le nuove linee.

Un ringraziamento speciale a Kevin Cruijssen per avermi ricordato che l'ultima parte di un ciclo for avviene alla fine e un risparmio totale di byte di 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++));}

Provalo online!

-4 byte grazie a ceilingcat.

Utilizza le sequenze CSI per salvare / ripristinare la posizione del cursore. Esegue l'iterazione sull'array di stringhe passate (nello stesso formato di argv) e stampa <save position>string<restore position>per ognuna.

Questo lascia il cursore in alto a sinistra, quindi quando corri al terminale è importante lasciare abbastanza righe in seguito in modo che il prompt non ostruisca l'input.

Japt -P , 7 byte

Accetta l'input come una matrice di stringhe a più righe, genera un'unica stringa a più righe.

ú y_¸¬Ì

Provalo

ú 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

Query T-SQL, 297 295 byte

Usando ¶ come separatore e una variabile di tabella come input.

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)

Provalo online

Javascript (browser), 129 124 byte

Il mio primo tentativo di golf a codice. Ho letto i link indicati nelle regole (scappatoie, regole standard ...), quindi spero di aver fatto qualcosa di sbagliato!

Ho mantenuto gli input così come sono nel primo post (modulo array piatto).

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

Grazie a Kevin Cruijssen per aver salvato 5 byte.

test:

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

L.tb0VyQsme #dy #N

Provalo online! (nota: il codice stesso valuta solo un blocco, la modalità suite di test dell'interprete esegue il programma una volta per ogni riga di input)

Basato sulla soluzione Python 2 di TFeld .

Spiegazione:

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

per una spiegazione del perché l'algoritmo stesso funziona, vedere la risposta di TFeld.

Carbone , 4 byte

ＦθＰι

Provalo online (dettagliato) o provalo online (puro) .

Spiegazione:

Scorri l'elenco di input di stringhe multilinea:

For(q)
Ｆθ

E stampa la stringa multilinea senza spostare il cursore:

Multiprint(i);
Ｐι