Votre tâche consiste à accepter comme entrée deux "Art ASCII" et à aligner chaque œuvre d'art côte à côte horizontalement.

Par exemple, supposons que vous ayez deux chaînes "abc\ndef"et "123\n456". Vous devez les aligner horizontalement pour produire la chaîne "abc123\ndef456". J'appelle cela" aligner horizontalement "car pendant que les entrées, une fois imprimées, ressemblent à ceci:

abc
def

et:

123
456

La sortie, une fois imprimée, ressemblera à ceci:

abc123
def456

Notez comment une entrée est placée à côté de l'autre.

Contribution

• L'entrée sera des chaînes et peut être sous la forme de deux arguments distincts ou sous la forme d'une séquence de chaînes.
• Les caractères dans les arts auront des codes décimaux compris entre 32 et 126 (inclus).
• C'est bien de prendre en charge un nombre arbitraire d'arts à aligner au lieu de deux (mais vous devez évidemment en prendre au moins deux).
• Vous pouvez supposer que chaque art aura les mêmes dimensions et qu'elles contiendront au moins une ligne.

• Vous devez être capable de supporter au moins 100x100 arts des personnages.

• Pour s'aligner sur les conventions du site, l'ordre des arguments n'a pas d'importance. Peu importe quel art est à gauche ou à droite.

Production

• La sortie sera les arts alignés comme mentionné ci-dessus, soit retournés soit sortis vers la sortie standard.

• Tout espace de fin en option.

• Il ne doit pas y avoir de séparateur visuel entre les arts alignés.

Les arts d'entrée et de sortie doivent être \nou\r chaînes délimitées. Il serait trop trivial d'autoriser les tableaux 2D.

Les soumissions peuvent être des fonctions ou des programmes complets.

Cas de test:

"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"

Toile , 1 octet

×

Essayez-le ici!

Haskell , 37 octets

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

Essayez-le en ligne!

IO comme des listes de lignes serait juste zipWith(++). : P

Python 2 , 59 octets

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

Essayez-le en ligne!

05AB1E , 6 octets

|¶¡øJ»

Essayez-le en ligne!

Explication

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

Gelée , 4 octets

Ỵ€ZY

Essayez-le en ligne!

Perl 5 -0F , 28 octets

Comprend +2pour l' \nargument-F (c'est "code" donc ça devrait compter)

Donnez des entrées directement après l'autre sur STDIN.

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

Essayez-le en ligne!

Bash + coreutils, 14

• 4 octets enregistrés grâce à @DavidFoerster.

paste -d "" $@

L'entrée est donnée sous deux noms de fichiers en tant que paramètres de ligne de commande.

Essayez-le en ligne .

Perl 6 , 27 octets

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

Essayez-le en ligne!

Fonctionne avec un nombre arbitraire d'arts. IO comme liste de listes serait juste &[Z~].

APL (Dyalog Unicode) , 9 octets ^SBCS

Programme complet. Invite (STDIN) pour toute liste de longueur de \rchaînes délimitées. Les chaînes peuvent être irrégulières et de largeurs différentes tant qu'elles ont le même nombre de lignes. Imprime (STDOUT) résultant de l'art ASCII.

⊃,/⎕FMT¨⎕

Essayez-le en ligne!

⎕ invite pour l'entrée évaluée

⎕FMT¨ format (évaluer tous les caractères de contrôle et retourner la matrice de caractères) chacun

,/ les combiner horizontalement (réduction de caténation)

⊃ divulguer (car la réduction a réduit le rang de 1 à 0)

Java 8, 100 84 78 octets

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

Quitte avec un ArrayIndexOutOfBoundsExceptionvers STDERR après avoir imprimé le résultat dans STDOUT, ce qui est autorisé .

-6 octets grâce à @ OlivierGrégoire .

Explication:

Essayez-le en ligne.

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

Rubis , 48 octets

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

Essayez-le en ligne!

Un lambda prenant deux chaînes et renvoyant une chaîne. La définition du splitdélimiteur par défaut sur la nouvelle ligne avec $;=$/;ne sauvegarde aucun octet, mais rend le reste un peu plus agréable.

Ruby , 49 octets (arbitrairement plusieurs chaînes)

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

Essayez-le en ligne!

Juste pour le fun. Il s'avère que nous pouvons accepter un tableau de chaînes à un coût supplémentaire de seulement 1 octet.

JavaScript (ES6), 51 octets

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

Merveille , 21 octets

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

Exemple d'utilisation:

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

#nest utilisé au lieu de \npour désigner les nouvelles lignes.

Explication

Version détaillée:

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

Divisez chaque chaîne dans le tableau d'entrée le long des sauts de ligne, zippez avec la chaîne concaténée et sortez chaque élément.

Kotlin , 73 octets

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

Essayez-le en ligne!

Ajouter ++ , 24 octets

L,c10CdVAptA$pG$tBcB@£+n

Essayez-le en ligne!

C, 96 octets

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

Essayez-le en ligne!

JavaScript (ES6), 52 octets

Prend une entrée dans la syntaxe de curry (a)(b).

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

Essayez-le en ligne!

Julia 0,6 , 41 octets

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

Essayez-le en ligne!

PowerShell , 51 49 octets

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

Essayez-le en ligne!

Prend l'entrée sous forme de chaînes littérales avec des retours à la ligne. Vous pouvez également utiliser `n(le délimiteur de nouvelle ligne dans PowerShell, non \n) à la place.

Nous commençons par -splitla chaîne d'entrée gauche sur les sauts de ligne, ce qui crée un tableau, et bouclons à travers cela |%{...}. À chaque itération, nous enchaînons la chaîne avec la chaîne d'entrée droite à nouveau divisée sur les nouvelles lignes, indexée et incrémentée.

Celles-ci sont laissées sur le pipeline et l'implicite Write-Outputà la fin nous donne une sortie sous forme de tableau de chaînes, qui sont imprimées avec des retours à la ligne entre.

APL (Dyalog Unicode) , 22 octets ( SBCS d'Adám )

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

Essayez-le en ligne!

Rouge , 78 octets

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

Essayez-le en ligne!

Japt -R , 8 7 octets

·íV· m¬

Essayez-le

Explication

             :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

Alternative

·Ë+V·gE

Essayez-le

             :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 octets

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

Essayez-le en ligne!

Non 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

Exemples:

$ 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

J'en ai également une plus courte mais elle échoue si la deuxième readinstruction renvoie une valeur non nulle.

Bash , 55 octets

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

Remarque: <&3ne semble pas fonctionner sur tio.run

Celui-ci utilise des descripteurs de fichiers ( 1et 3) au lieu d'arguments:

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

Fusain , 8 octets

ＰθＭ⌕θ¶→η

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

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

Ajoutez 2 octets pour accepter plusieurs entrées:

ＦＡ«ＰιＭ⌕ι¶→

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

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

Ajoutez 4 octets pour accepter l'entrée non complétée:

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

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

JavaScript (Node.js) , 79 octets

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

Essayez-le en ligne!

Prend en charge un nombre arbitraire d'arts ASCII se réunissant plutôt que seulement 2 (comme dans les 2 réponses JS précédentes).

Nettoyer , 61 octets

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

Essayez-le en ligne!

Swift 4 , 119 octets

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

Explication

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

Essayez-le en ligne!