Reto:

Dada una lista de cadenas de líneas múltiples, superpongalas (en la esquina superior izquierda) y muestre el resultado.

Ejemplo:

Entrada: ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
Salida:

cbaa
bbaa
bbaa
aaaa

Reglas de desafío:

• El formato de entrada es flexible. Se le permite obtener la entrada como una lista 2D de líneas (es decir [["aaaa","aaaa","aaaa","aaaa"],["bb","bb","bb"],["c"]]) o una lista 3D de caracteres (es decir [[["a","a","a","a"],["a","a","a","a"],["a","a","a","a"],["a","a","a","a"]],[["b","b"],["b","b"],["b","b"]],[["c"]]]). Se le permite tomar todas las entradas una por una a través de STDIN. Etc.
• El formato de salida es estricto. Puede elegir imprimir o devolver la cadena de varias líneas. (Si su idioma no tiene cadenas, la salida como una lista 2D de caracteres está permitida como alternativa. Pero solo si su idioma no tiene cadenas).
• El orden de la lista de entrada es, por supuesto, importante (pero se le permite tomar la entrada a la inversa si así lo desea).
• Las entradas solo contendrán ASCII imprimible en el rango unicode $[33,126]$ (!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ ).
• Las entradas solo serán rectángulos (por lo que no hay formas extrañas). Sin embargo, la salida no son rectángulos necesarios.
• Se permiten espacios finales y una nueva línea final. Espacios iniciales y / o líneas nuevas no.

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta con las reglas de E / S predeterminadas , por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código (es decir, TIO ).
• Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba:

Entrada: ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
Salida:

cbaa
bbaa
bbaa
aaaa

Entrada: ["12345\n54321","00\n00\n00\n00","001\n011\n012"]
Salida:

00145
01121
012
00

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

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

Jalea , 3 bytes

a/Y

Pruébalo en línea!

No había usado a Jelly en mucho tiempo, pero pensé que el desafío en los comentarios era superable. Utiliza directamente y lógicamente ( a) para realizar la operación de apilamiento entre cada elemento de la entrada ( /). Yse utiliza para imprimir en el formato requerido.

JavaScript (Node.js) , 24 bytes

Guardado 2 bytes gracias a @Grimy

Se supone que la cadena devuelta se imprime en un terminal que admite códigos de escape ANSI . Contiene el carácter no imprimible ESC, que se escapa (sin juego de palabras) como se \x1Bmuestra a continuación.

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

Esto no funciona en TIO, pero puedes probarlo en línea.para ver la salida sin formato en su lugar.

¿Cómo?

Las secuencias CSI utilizadas son:

• ED (Borrar en pantalla):

  ESC[2J

  donde $2$ significa "borrar toda la pantalla"

• CUP (Posición del cursor):

  ESC[H

  que significa "se mueve el cursor a la fila $n$ , columna $m$ " donde ambos $n$ y $m$ se han omitido e implícitamente establecen en $1$ (esquina superior izquierda de la pantalla).

Salida de ejemplo

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

Pruébalo en línea!

Una función que acepta una lista de matriz de caracteres (se acepta la entrada 3D).

(Como puede observar en el recuento de bytes, esto no es muy fácil de hacer en R ...)

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

Pruébalo en línea!

Explicación (con ejemplo):

Toma una lista 2D como entrada.

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

Primero se comprime la lista de entrada, para obtener las filas de cada rectángulo de entrada ( map(None,l)es el mismo zip más largo):

map(n,*input())   gives:

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

Cada una de estas filas se filtra a Nonelos correos electrónicos eliminados y se comprime de nuevo:

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

Que es una lista de caracteres para cada posición del resultado deseado. Estas listas se vuelven a filtrar y se toma la última:

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 último, las listas resultantes se unen e imprimen:

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

No parece funcionar en TIO, lo que podría estar relacionado con el uso del \rcarácter de retorno de carro. Funciona en mi instalación local de R.

Toma la entrada como una lista que contiene un vector de filas:

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

Recorre las filas de cada rectángulo, imprime un retorno de carro después de cada uno y reinicia la línea.

Si estiramos un poco las reglas, podemos eliminar la verificación de la longitud de la entrada y simplemente hacer un bucle infinito, imprimiendo una gran cantidad de nuevas líneas:

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

Función de prefijo tácito anónimo que toma la lista de matrices de caracteres 2D como argumento. Huellas dactilares.

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

Pruébalo en línea!

Esto funciona creando un lienzo, luego anexándolo a la lista de bloques y reduciendo (plegando) con una función que coloca los bloques en la esquina.

↑ Mezcle el bloque 2D para crear un bloque 3D ortogonal, rellenándolos con espacios según sea necesario

1⌷ toma la primera capa

⊂ adjunte eso y
 ∘ luego
⌽, anteponga la lista de bloques invertida

(... ) aplique la siguiente función tácita:

 {… }/ Reduzca utilizando la siguiente lambda anónima:

  ⊢⍵ con el argumento correcto como lienzo ...

  ⍺@(… ) Enmendar con los elementos del argumento izquierdo, colocados en los siguientes índices:

   ⍴⍺ la forma del argumento izquierdo

   ⍳ el ɩ nices de una matriz de esa forma

 ⊃ revelar (porque la reducción incluida para reducir el rango)

Haskell, 66 bytes

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

Entrada se toma como una lista de lista de cadenas en el orden inverso, por ejemplo, para el primer caso de prueba: [["c"],["bb","bb","bb"],["aaaa","aaaa","aaaa","aaaa"]].

Pruébalo en línea!

05AB1E , 12 bytes

Puerto de la solución de Python de TFeld
2 bytes guardados gracias a Grimy

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

Pruébalo en línea!

Explicación

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

Versión alternativa de 14 bytes

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

Pruébalo en línea!

Explicación

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

Lienzo , 5 bytes.

Ｈ１１╋╋

Pruébalo aquí!

Si la superposición de /+ \→ X, -+ |→ +, etc. estaría bien, funcionarían 2 bytes .

Python 2 , 77 bytes

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

Pruébalo en línea!

PowerShell 6 , solo consola, 20 bytes

basado en la respuesta de Arnauld . Esto funciona solo con la consola y no funciona en TIO.

cls
$args-join"`e[H"

Pruébalo en línea!

PowerShell , 103 bytes

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

Pruébalo en línea!

Desenrollado:

$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 son para la importación, using C=System.Console;

No funciona en TIO, ya que no es una consola.

Pruébalo en línea!

Rubí , 67 bytes

La entrada es una lista de líneas. Crea una lista de líneas y sobrescribe a medida que avanza por las entradas, luego las une con una nueva línea (representada por la variable $/) al final para que coincida con la salida estricta.

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

Pruébalo en línea!

C (GCC, MinGW) 138 bytes

Asume que CR coloca el cursor al comienzo de la línea actual.

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

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

Octava , 71 67 bytes

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

Función que toma una matriz de celdas verticales de matrices de caracteres y devuelve una matriz de caracteres.

Pruébalo en línea! O verificar todos los casos de prueba .

Javascript (navegador) , 216 208 204 bytes

Mi intento de esto. No estoy contento con el tamaño, y ciertamente debe haber más para mejorar, pero no tengo tanta experiencia en el 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)

De todos modos, lo que hace primero es dividir todas las cadenas, luego revertir todas las cadenas, luego, mientras realiza un bucle en una plataforma de operación reducida todas las cadenas juntas. Luego invierta todas las cadenas nuevamente y luego únalas nuevamente con nuevas líneas.

Un agradecimiento especial a Kevin Cruijssen por recordarme que la última parte de un bucle for ocurre al final y un total de bytes de ahorro 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++));}

Pruébalo en línea!

-4 bytes gracias a ceilingcat.

Utiliza las secuencias CSI para guardar / restaurar la posición del cursor. Simplemente itera sobre el conjunto de cadenas pasado (en el mismo formato que argv) e imprime <save position>string<restore position>para cada uno.

Esto deja el cursor en la esquina superior izquierda, por lo tanto, cuando se ejecuta en la terminal, es importante dejar suficientes líneas nuevas después para que el indicador no bloquee la entrada.

Japt -P , 7 bytes

Toma la entrada como una matriz de cadenas de varias líneas, genera una sola cadena de varias líneas.

ú y_¸¬Ì

Intentalo

ú 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 y una variable de tabla 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)

Pruébalo en línea

Javascript (navegador), 129124 bytes

Mi primer intento de golf de código. Leí los enlaces que figuran en las reglas (lagunas, reglas estándar ...), ¡así que espero haber hecho algo mal!

Mantuve las entradas como están en la primera publicación (forma 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`}

Gracias a Kevin Cruijssen por guardar 5 bytes.

Pruebas:

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

Pruébalo en línea! (nota: el código mismo evalúa solo un bloque, el modo de suite de prueba del intérprete ejecuta el programa una vez para cada línea de entrada)

Basado en la solución Python 2 de TFeld .

Explicación:

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 obtener una explicación de por qué funciona el algoritmo, consulte la respuesta de TFeld.

Carbón , 4 bytes

ＦθＰι

Pruébelo en línea (detallado) o pruébelo en línea (puro) .

Explicación:

Pase por la lista de entrada de cadenas de varias líneas:

For(q)
Ｆθ

E imprima la cadena de varias líneas sin mover el cursor:

Multiprint(i);
Ｐι