Su tarea es aceptar como entrada dos "Arte ASCII" y alinear cada obra de arte una al lado de la otra horizontalmente.

Por ejemplo, digamos que tiene dos cadenas, "abc\ndef"y "123\n456". Necesitas alinearlos horizontalmente para producir la cadena "abc123\ndef456". Lo llamo" alinear horizontalmente "porque mientras las entradas, cuando se imprimen, se ven así:

abc
def

y:

123
456

La salida, cuando se imprima, se verá así:

abc123
def456

Tenga en cuenta cómo se coloca una entrada junto a la otra.

Entrada

• La entrada será cadenas y puede ser como dos argumentos separados, o como una secuencia de cadenas.
• Los personajes en las artes tendrán códigos decimales en el rango de 32-126 (inclusive).
• Está bien admitir un número arbitrario de artes para alinear en lugar de solo dos (pero obviamente debe admitir al menos dos).
• Puede suponer que cada arte tendrá las mismas dimensiones y que contendrán al menos una línea.

• Debes ser capaz de admitir al menos 100x100 artes de personajes.

• Para alinearse con las convenciones del sitio, el orden de los argumentos no importa. No importa qué arte esté a la izquierda o a la derecha.

Salida

• La salida será el arte alineado como se mencionó anteriormente, ya sea devuelto o enviado a la salida estándar.

• Cualquier espacio en blanco al final en opcional.

• No debe haber un separador visual entre las artes alineadas.

Las artes de entrada y salida deben ser \no \rcadenas delimitadas. Sería demasiado trivial permitir matrices 2D.

Las presentaciones pueden ser funciones o programas completos.

Casos de prueba:

"abc\ndef", "123\n456" -> "abc123\ndef456".

"qwertyuiop\n asdfghjkl", "Some other\nTextFiller" -> "qwertyuiopSome other\n asdfghjklTextFiller"

"  *  \n *** \n*****\n *** \n  *  \n", "  +  \n  +  \n+++++\n  +  \n  +  \n" -> "  *    +  \n ***   +  \n*****+++++\n ***   +  \n  *    +  \n"

Lienzo , 1 byte

×

Pruébalo aquí!

Haskell , 37 bytes

(unlines.).(.lines).zipWith(++).lines

Pruébalo en línea!

IO como listas de líneas simplemente sería zipWith(++). :PAG

Python 2 , 59 bytes

lambda y:'\n'.join(map(str.__add__,*map(str.splitlines,y)))

Pruébalo en línea!

05AB1E , 6 bytes

|¶¡øJ»

Pruébalo en línea!

Explicación

|        # push all input into a list
 ¶¡      # split on newlines
   ø     # zip
    J    # join the rows to single strings
     »   # merge on newlines

Jalea , 4 bytes

Ỵ€ZY

Pruébalo en línea!

Perl 5 -0F , 28 bytes

Incluye +2para el \nargumento de-F (es "código", por lo que debe contar)

Dé entradas directamente una tras otra en STDIN.

#!/usr/bin/perl -0F\n
say@F[$%++,$_]for@F/2..$#F

Pruébalo en línea!

Bash + coreutils, 14

• 4 bytes guardados gracias a @DavidFoerster.

paste -d "" $@

La entrada se proporciona como dos nombres de archivo como parámetros de línea de comandos.

Pruébalo en línea .

Perl 6 , 27 bytes

{join "\n",[Z~] $_>>.lines}

Pruébalo en línea!

Trabaja con un número arbitrario de artes. IO como lista de listas sería justo &[Z~].

APL (Dyalog Unicode) , ^{SBCS de} 9 bytes

Programa completo Solicitudes (STDIN) para cualquier lista de longitud de \rcadenas delimitadas. Las cadenas pueden ser desiguales y de diferentes anchos siempre que tengan el mismo número de líneas. Imprime (STDOUT) resultante ASCII art.

⊃,/⎕FMT¨⎕

Pruébalo en línea!

⎕ solicitud de entrada evaluada

⎕FMT¨ formato (evaluar todos los caracteres de control y devolver la matriz de caracteres) cada uno

,/ combinarlos horizontalmente (reducción de la catenificación)

⊃ revelar (porque la reducción redujo el rango de 1 a 0)

Java 8, 100 84 78 bytes

a->b->{for(int i=0;;)System.out.println(a.split("\n")[i]+b.split("\n")[i++]);}

Sale con un ArrayIndexOutOfBoundsExceptionSTDERR después de haber impreso el resultado en STDOUT, que está permitido .

-6 bytes gracias a @ OlivierGrégoire .

Explicación:

Pruébalo en línea.

a->b->{                        // Method with two String parameters and no return-type
  for(int i=0;;)               //  Loop over the substrings of the first input
    System.out.println(        //   Print:
     a.split("\n")[i]          //    The substring of the first input
     +b.split("\n")[i++]);}    //    plus the same-indexed substring of the second input

Ruby , 48 bytes

->a,b{$;=$/;a.split.zip(b.split).map(&:join)*$/}

Pruébalo en línea!

Una lambda que toma dos hilos y devuelve un hilo. Establecer el splitdelimitador predeterminado en nueva línea con$;=$/; no guarda ningún byte, pero hace que el resto se vea un poco mejor.

Ruby , 49 bytes (arbitrariamente muchas cadenas)

->s{s.map{|a|a.split$/}.transpose.map(&:join)*$/}

Pruébalo en línea!

Solo por diversión. Resulta que podemos aceptar una serie de cadenas a un costo adicional de solo 1 byte.

JavaScript (ES6), 51 bytes

f=
(a,b)=>a.replace(/.+/g,a=>a+b.shift(),b=b.split`
`)
;document.write("<pre>"+f("abc\ndef", "123\n456")+"</pre>")

Maravilla , 21 bytes

->#oN.zip#++.-> <>"
"

Ejemplo de uso:

(->#oN.zip#++.-> <>"
")["abc#ndef" "abc#ndef"]

#n se usa en lugar de \n denotar nuevas líneas.

Explicación

Versión detallada:

(map #oN) . (zip #con) . (map split "#n")

Dividir cada cadena en la matriz de entrada a lo largo de nuevas líneas, comprimir con concatenación de cadena y generar cada elemento.

Kotlin , 73 bytes

a,b->a.split("\n").mapIndexed{i,s->s+b.split("\n")[i]}.joinToString("\n")

Pruébalo en línea!

Añadir ++ , 24 bytes

L,c10CdVAptA$pG$tBcB@£+n

Pruébalo en línea!

C, 96 bytes

#define L(s)for(;*s++>10;)putchar(s[-1]);
i;f(s,t)char*s,*t;{for(;i=!!s[-i];puts("")){L(s)L(t)}}

Pruébalo en línea!

JavaScript (ES6), 52 bytes

Toma entrada en la sintaxis de curry (a)(b).

a=>b=>a.split`
`.map((s,i)=>s+b.split`
`[i]).join`
`

Pruébalo en línea!

Julia 0.6 , 41 bytes

(a,b)->map(*,split(a,'\n'),split(b,'\n'))

Pruébalo en línea!

PowerShell , 51 49 bytes

param($a,$b)$a-split"
"|%{$_+($b-split"
")[$i++]}

Pruébalo en línea!

Toma la entrada como cadenas literales con nuevas líneas. También podría usar `n(el delimitador de nueva línea en PowerShell, no \n) en su lugar.

Nosotros primero -split la cadena de entrada izquierda en las nuevas líneas, que crea una matriz, y la recorremos |%{...}. En cada iteración, la cadena se concatena con la cadena de entrada correcta nuevamente dividida en nuevas líneas, indexada e incrementada.

Los que quedan en la tubería y lo implícito Write-Outputal finalizar nos da salida como una serie de cadenas, que se imprimen con nuevas líneas entre ellas.

APL (Dyalog Unicode) , 22 bytes ( SBCS de Adám )

{⊃,/↑¨⍵}'[^\n]+'⎕S'&'¨

Pruébalo en línea!

Rojo , 78 bytes

func[a b][b: split b"^/"foreach c split a"^/"[prin c print first b b: next b]]

Pruébalo en línea!

Japt -R , 8 7 bytes

·íV· m¬

Intentalo

Explicación

             :Implicit input of strings U & V
·            :Split U on newlines
  V·         :Split V on newlines
 í           :Interleave
     m       :Map
      ¬      :  Join
             :Implicitly join with newlines and output

Alternativa

·Ë+V·gE

Intentalo

             :Implicit input of strings U & V
·            :Split U on newlines
 Ë           :Map over each element at index E and rejoin with newlines
   V·        :  Split V on newlines
     gE      :  Get the element at index E
  +          :  Append to the current element
             :Implicitly join with newlines and output

Bash , 92 bytes

a=();for b;do c=;while IFS= read -r d;do a[c++]+=$d;done<<<"$b";done;printf '%s\n' "${a[@]}"

Pruébalo en línea!

Sin golf:

array=()                             # Initialize the array
for argument in "${@}"; do           # Loop over the arguments list
  index='0'                          # Reset the index
  while IFS='' read -r 'line'; do    # Loop over every line of the current argument
    array[index]+="${line}"          # Append the line to its corresponding place
    (( index++ ))                    # Increment the index
  done <<< "${argument}"             # End while loop
done                                 # End for loop
printf '%s\n' "${array[@]}"          # Print array's content

Ejemplos:

$ foo $'abc\ndef' $'123\n456'
abc123
def456

$ foo $'qwertyuiop\n asdfghjkl' $'Some other\nTextFiller'
qwertyuiopSome other
 asdfghjklTextFiller

$ foo \
>   $'  *  \n *** \n*****\n *** \n  *  \n' \
>   $'  +  \n  +  \n+++++\n  +  \n  +  \n'
  *    +  
 ***   +  
*****+++++
 ***   +  
  *    +  


# https://gist.github.com/nxnev/dad0576be7eb2996b860c320c01d0ec5
$ foo "$(< input1)" "$(< input2)" "$(< input3)" > output

También tengo uno más corto pero falla si la segunda readdeclaración devuelve un valor distinto de cero.

Bash , 55 bytes

while IFS= read -r a;IFS= read b<&3;do echo "$a$b";done

Nota: <&3no parece funcionar en tio.run

Este usa descriptores de archivo ( 1y 3) en lugar de argumentos:

$ foo <<< $'qwertyuiop\n asdfghjkl' 3<<< $'Some other\nTextFiller'
qwertyuiopSome other
 asdfghjklTextFiller

Carbón de leña , 8 bytes

ＰθＭ⌕θ¶→η

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

 θ          First input
Ｐ           Print without moving the cursor
    θ       First input
     ¶      Literal newline
   ⌕        Find index
  Ｍ   →     Move that many squares right
       η    Implicitly print second input

Agregue 2 bytes para aceptar múltiples entradas:

ＦＡ«ＰιＭ⌕ι¶→

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

 Ａ          Input
Ｆ «         Loop over all entries
   Ｐι       Print current entry
     Ｍ⌕ι¶→  Move to next entry

Agregue 4 bytes para aceptar la entrada sin relleno:

ＰθＭ⌈Ｅ⪪θ¶Ｌι→η

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

      θ         First input
       ¶        Literal newline
     ⪪          Split
    Ｅ           Map over each string
         ι      Current string
        Ｌ       Length
   ⌈            Maximum
  Ｍ       →     Move that many squares right

JavaScript (Node.js) , 79 bytes

a=>(b=a.map(x=>x.split`
`))[i=0].map(y=>b.map(z=>c+=z[i],c="")&&++i&&c).join`
`

Pruébalo en línea!

Admite un número arbitrario de artes ASCII que se unen en lugar de solo 2 (como en las 2 respuestas anteriores de JS).

Limpio , 61 bytes

import StdEnv
$a b=flatlines[u++v\\u<-mklines a&v<-mklines b]

Pruébalo en línea!

Swift 4 , 119 bytes

func f(s:[String])->String{return s[0].split{$0=="\n"}.enumerated().map{$0.1+s[1].split{$0=="\n"}[$0.0]+"\n"}.joined()}

Explicación

func f(s: [String]) -> String {
    return s[0].split{ $0=="\n" }       //splitting the first string after every \n
    .enumerated()                       //create a tuple of offsets and elements
    .map {
        $0.1 +                          //current element
        s[1].split{$0 == "\n"}[$0.0] +  //splitting the second string + indexing
        "\n"                            //new line after every line
     }
     .joined()
}

Pruébalo en línea!