Il tuo compito è quello di accettare come input due "ASCII Art" e di allineare ogni opera una accanto all'altra in senso orizzontale.

Ad esempio, supponiamo di avere due stringhe "abc\ndef"e "123\n456". È necessario allinearli orizzontalmente per produrre la stringa "abc123\ndef456". Lo chiamo" allineando orizzontalmente "perché mentre gli input, una volta stampati, assomigliano a questo:

abc
def

e:

123
456

L'output, una volta stampato, sarà simile al seguente:

abc123
def456

Nota come un input è posizionato accanto all'altro.

Ingresso

• L'input sarà stringhe e può essere come due argomenti separati o come una sequenza di stringhe.
• I personaggi nelle arti avranno codici decimali nell'intervallo 32-126 (incluso).
• Va bene supportare un numero arbitrario di arti da allineare anziché solo due (ma ovviamente devi supportarne almeno due).
• Puoi presumere che ogni disegno avrà le stesse dimensioni e che conterrà almeno una linea.

• Devi essere in grado di supportare almeno 100x100 personaggi artistici.

• Per allinearsi con le convenzioni sul sito, l'ordine degli argomenti non ha importanza. Non importa quale arte sia a sinistra o a destra.

Produzione

• L'output saranno le arti allineate come menzionato sopra, o restituite o output allo stdout.

• Qualsiasi spazio bianco finale in facoltativo.

• Non ci deve essere un separatore visivo tra le arti allineate.

Le arti di input e output devono essere stringhe \no \rdelimitate. Sarebbe eccessivamente banale consentire array 2D.

Gli invii possono essere funzioni o programmi completi.

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

Tela , 1 byte

×

Provalo qui!

Haskell , 37 byte

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

Provalo online!

IO come elenchi di linee sarebbe solo zipWith(++). : P

Python 2 , 59 byte

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

Provalo online!

05AB1E , 6 byte

|¶¡øJ»

Provalo online!

Spiegazione

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

Gelatina , 4 byte

Ỵ€ZY

Provalo online!

Perl 5 -0F , 28 byte

Include +2per l' \nargomento -F(è "codice", quindi dovrebbe contare)

Dare input direttamente uno dopo l'altro su STDIN.

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

Provalo online!

Bash + coreutils, 14

• 4 byte salvati grazie a @DavidFoerster.

paste -d "" $@

L'input viene dato come due nomi di file come parametri della riga di comando.

Provalo online .

Perl 6 , 27 byte

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

Provalo online!

Funziona con un numero arbitrario di arti. IO come elenco di elenchi sarebbe giusto &[Z~].

APL (Dyalog Unicode) , ^{SBCS da} 9 byte

Programma completo. Richiede (STDIN) un elenco di lunghezze di \rstringhe -delimate. Le stringhe possono essere sfilacciate e di larghezza diversa purché abbiano lo stesso numero di linee. Stampe (STDOUT) risultanti ASCII art.

⊃,/⎕FMT¨⎕

Provalo online!

⎕ richiesta di input valutato

⎕FMT¨ formato (valuta tutti i caratteri di controllo e restituisce la matrice di caratteri) ciascuno

,/ combinarli orizzontalmente (riduzione della catenazione)

⊃ divulgare (perché la riduzione ha ridotto il grado da 1 a 0)

Java 8, 100 84 78 byte

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

Esce da an ArrayIndexOutOfBoundsExceptiona STDERR dopo aver stampato il risultato su STDOUT, che è consentito .

-6 byte grazie a @ OlivierGrégoire .

Spiegazione:

Provalo online.

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

Rubino , 48 byte

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

Provalo online!

Una lambda che prende due stringhe e restituisce una stringa. L'impostazione del splitdelimitatore predefinito su newline con $;=$/;non salva alcun byte, ma rende il resto un po 'più bello.

Ruby , 49 byte (arbitrariamente molte stringhe)

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

Provalo online!

Solo per divertimento. Si scopre che possiamo accettare una matrice di stringhe ad un costo aggiuntivo di solo 1 byte.

JavaScript (ES6), 51 byte

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

Meraviglia , 21 byte

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

Esempio di utilizzo:

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

#nviene utilizzato invece di \nindicare nuove righe.

Spiegazione

Versione dettagliata:

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

Dividi ogni stringa nell'array di input lungo le nuove righe, comprimi con concatenazione di stringhe e genera ogni elemento.

Kotlin , 73 byte

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

Provalo online!

Aggiungi ++ , 24 byte

L,c10CdVAptA$pG$tBcB@£+n

Provalo online!

C, 96 byte

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

Provalo online!

JavaScript (ES6), 52 byte

Accetta input nella sintassi del curry (a)(b).

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

Provalo online!

Julia 0.6 , 41 byte

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

Provalo online!

PowerShell , 51 49 byte

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

Provalo online!

Accetta input come stringhe letterali con newline. In alternativa `n, puoi anche utilizzare (il delimitatore newline in PowerShell \n).

Prima di tutto -splitla stringa di input a sinistra su newline, che crea un array, e lo attraversiamo |%{...}. Ogni iterazione, concateniamo la stringa con la stringa di input corretta nuovamente suddivisa su newline, indicizzata e incrementata.

Questi vengono lasciati sulla pipeline e l'implicito Write-Outputal completamento ci dà l'output come una matrice di stringhe, che sono stampate con una nuova riga tra.

APL (Dyalog Unicode) , 22 byte ( Adám's SBCS )

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

Provalo online!

Rosso , 78 byte

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

Provalo online!

Japt -R , 8 7 byte

·íV· m¬

Provalo

Spiegazione

             :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

Provalo

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

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

Provalo online!

Ungolfed:

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

Esempi:

$ 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

Ne ho anche uno più corto ma non riesce se la seconda readistruzione restituisce un valore diverso da zero.

Bash , 55 byte

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

Nota: <&3non sembra funzionare su tio.run

Questo utilizza descrittori di file ( 1e 3) invece di argomenti:

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

Carbone , 8 byte

ＰθＭ⌕θ¶→η

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

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

Aggiungi 2 byte per accettare più input:

ＦＡ«ＰιＭ⌕ι¶→

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

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

Aggiungi 4 byte per accettare input non riempiti:

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

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

JavaScript (Node.js) , 79 byte

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

Provalo online!

Supporta un numero arbitrario di arti ASCII che si uniscono piuttosto che solo 2 (come nelle 2 precedenti risposte JS).

Pulito , 61 byte

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

Provalo online!

Swift 4 , 119 byte

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

Spiegazione

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

Provalo online!