Desafio:

Dada uma lista de cadeias de linhas múltiplas, sobreponha-as (na parte superior esquerda) e produza o resultado.

Exemplo:

Entrada: ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
Saída:

cbaa
bbaa
bbaa
aaaa

Regras do desafio:

• O formato de entrada é flexível. Você pode obter a entrada como uma lista 2D de linhas (ou seja [["aaaa","aaaa","aaaa","aaaa"],["bb","bb","bb"],["c"]]) ou lista 3D de caracteres (ou seja [[["a","a","a","a"],["a","a","a","a"],["a","a","a","a"],["a","a","a","a"]],[["b","b"],["b","b"],["b","b"]],[["c"]]]). Você tem permissão para receber todas as entradas uma por uma através do STDIN. Etc.
• O formato de saída é rigoroso. Você pode optar por imprimir ou retornar a sequência de várias linhas. (Se o seu idioma não tiver seqüências de caracteres, a saída como uma lista 2D de caracteres é permitida como alternativa. Mas somente se o seu idioma não possuir strings.)
• A ordem da lista de entrada é obviamente importante (mas você pode fazer a entrada inversa, se assim o desejar).
• As entradas conterão apenas ASCII imprimível no intervalo unicode $[33,126]$ ( !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~).
• As entradas serão apenas retângulos (portanto, sem formas estranhas). A saída não é retângulos necessários, no entanto.
• Espaços à direita e uma nova linha à direita são permitidos. Espaços iniciais e / ou novas linhas não.

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta com as regras de E / S padrão , para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código (ou seja, TIO ).
• Além disso, é altamente recomendável adicionar uma explicação para sua resposta.

Casos de teste:

Entrada: ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
Saída:

cbaa
bbaa
bbaa
aaaa

Entrada: ["12345\n54321","00\n00\n00\n00","001\n011\n012"]
Saída:

00145
01121
012
00

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

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

Geléia , 3 bytes

a/Y

Experimente online!

Não usava Jelly há algum tempo, mas achei que o desafio nos comentários era superável. Muito diretamente usa o lógico e ( a) para executar a operação de empilhamento entre cada elemento da entrada ( /). Yé usado para imprimir no formato necessário.

JavaScript (Node.js) , 24 bytes

Guardado 2 bytes graças a @Grimy

Supõe que a sequência retornada seja impressa em um terminal que suporte códigos de escape ANSI . Contém o caractere não imprimível ESC, que é escapado (sem trocadilhos), conforme \x1Babaixo.

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

Isso não funciona no TIO, mas você pode experimentá-lo online! para ver a saída bruta.

Quão?

As sequências CSI usadas são:

• ED (apagar no visor):

  ESC[2J

  onde $2$ significa "limpar a tela inteira"

• CUP (posição do cursor):

  ESC[H

  o que significa "move o cursor para a linha $n$ , coluna $m$ " , onde ambos $n$ e $m$ são omitidos e implicitamente definida como $1$ (canto superior esquerdo do ecrã).

Saída de exemplo

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

Experimente online!

Uma função que aceita uma lista de matriz de caracteres (entrada 3D é aceita).

(como você pode notar pela contagem de bytes, isso não é muito fácil de fazer no R ...)

• -9 bytes graças a @Giuseppe
• -4 bytes graças a @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)))

Experimente online!

Explicação (com exemplo):

Toma uma lista 2D como entrada.

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

Primeiro, a lista de entrada é compactada, para obter as linhas de cada retângulo de entrada ( map(None,l)o mesmo é o maior zip):

map(n,*input())   gives:

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

Cada uma dessas linhas é filtrada para se removida Nonee compactada novamente:

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

Qual é uma lista de caracteres para cada posição do resultado desejado. Essas listas são filtradas novamente e a última é obtida:

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

Por fim, as listas resultantes são unidas e impressas:

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

Não parece funcionar no TIO, o que pode estar relacionado ao uso do \rcaractere de retorno de carro. Ele funciona na minha instalação local do R.

Recebe entrada como uma lista que contém um vetor de linhas:

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

Faz um loop nas linhas de cada retângulo, imprimindo um retorno de carro após cada um, reiniciando a linha.

Se esticarmos um pouco as regras, podemos acabar com a verificação do comprimento da entrada e fazer um loop infinito, imprimindo uma enorme quantidade de novas linhas:

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) , ^{SBCS de} 22 bytes

Função de prefixo tácito anônimo, tendo como argumento a lista de matrizes de caracteres 2D. Imprime.

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

Experimente online!

Isso funciona criando uma tela, anexando-a à lista de blocos e reduzindo (dobrando) com uma função que coloca os blocos no canto.

↑ misture o bloco 2D para criar um bloco 3D ortogonal, preenchendo-o com espaços conforme necessário

1⌷ pegue a primeira camada

⊂ coloque que, em
 ∘ seguida,
⌽, anexe a lista invertida de blocos

(… ) Aplique a seguinte função tácita:

 {… }/ Reduza usando a seguinte lambda anônima:

  ⊢⍵ com o argumento certo como tela ...

  ⍺@(… ) Altere com os elementos do argumento esquerdo, colocados nos seguintes índices:

   ⍴⍺ a forma do argumento esquerdo

   ⍳ os índices de uma matriz dessa forma

 ⊃ divulgar (porque a redução incluía para reduzir a classificação)

Haskell, 66 bytes

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

A entrada é feita como uma lista de lista de strings em ordem inversa, por exemplo, para o primeiro caso de teste: [["c"],["bb","bb","bb"],["aaaa","aaaa","aaaa","aaaa"]].

Experimente online!

05AB1E , 12 bytes

Porta da solução python do TFeld
2 bytes salvos graças ao Grimy

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

Experimente online!

Explicação

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

Versão alternativa de 14 bytes

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

Experimente online!

Explicação

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

Ｈ１１╋╋

Experimente aqui!

Se sobrepor /+ \→ X, -+ |→ +, etc. estiver correto, 2 bytes funcionarão.

Python 2 , 77 bytes

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

Experimente online!

PowerShell 6 , somente console, 20 bytes

com base na resposta de Arnauld . Isso funciona apenas com console e não funciona no TIO.

cls
$args-join"`e[H"

Experimente online!

PowerShell , 103 bytes

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

Experimente online!

Desenrolado:

$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 bytes

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

23 bytes é para a importação, using C=System.Console;

Não funciona no TIO, pois não é um console.

Experimente online!

Ruby , 67 bytes

Entrada é uma lista de linhas. Cria uma lista de linhas e sobrescreve à medida que passa pelas entradas e as junta a uma nova linha (representada pela variável $/) no final para corresponder à saída estrita.

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

Experimente online!

C (GCC, MinGW) 138 bytes

Supõe que CR coloca o cursor no início da linha atual.

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

Testado com:

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

Oitava , 71 67 bytes

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

Função que pega uma matriz de células vertical de matrizes char e retorna uma matriz char.

Experimente online! Ou verifique todos os casos de teste .

Javascript (navegador) , 216 208 204 bytes

Minha tentativa nisso. Não estou feliz com o tamanho e certamente deve haver mais para melhorar, mas não sou tão experiente no golfe.

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)

De qualquer forma, o que ele faz é primeiro dividir todas as strings, depois reverter todas as strings e, em seguida, girar em um bloco de operação reduzido . Em seguida, inverta todas as seqüências novamente e junte-as novamente com novas linhas.

Um agradecimento especial a Kevin Cruijssen por me lembrar que a última parte de um loop for acontece no final e uma economia total de bytes de 8 bytes.

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

Experimente online!

-4 bytes graças ao ceilingcat.

Usa as seqüências CSI para salvar / restaurar a posição do cursor. Apenas itera sobre a matriz de cadeias passadas (no mesmo formato que argv) e imprime <save position>string<restore position>para cada uma.

Isso deixa o cursor no canto superior esquerdo; portanto, ao executar no terminal, é importante deixar novas linhas suficientes posteriormente para que o prompt não atrapalhe a entrada.

Japt -P , 7 bytes

Recebe a entrada como uma matriz de seqüências de várias linhas, produz uma única sequência de várias linhas.

ú y_¸¬Ì

Tente

ú 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

Consulta T-SQL, 297 295 bytes

Usando ¶ como separador e uma variável de tabela como entrada.

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)

Experimente online

Javascript (navegador), 129 124 bytes

Minha primeira tentativa no código de golfe. Eu li os links fornecidos nas regras (brechas, regras padrão ...), então espero ter feito algo errado!

Eu mantive as entradas como estão no primeiro post (formulário de matriz plana).

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

Obrigado a Kevin Cruijssen por salvar 5 bytes.

Testes:

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

Pitão , 18 bytes

L.tb0VyQsme #dy #N

Experimente online!(nota: o próprio código avalia apenas um bloco, o modo de suíte de testes do intérprete executa o programa uma vez para cada linha de entrada)

Baseado na solução Python 2 da TFeld .

Explicação:

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

para uma explicação de por que o próprio algoritmo funciona, consulte a resposta do TFeld.

Carvão , 4 bytes

ＦθＰι

Experimente online (detalhado) ou online (puro) .

Explicação:

Faça um loop sobre a lista de entrada de strings de várias linhas:

For(q)
Ｆθ

E imprima a sequência de linhas múltiplas sem mover o cursor:

Multiprint(i);
Ｐι