Ihre Aufgabe ist es, zwei "ASCII Art" als Eingabe zu akzeptieren und jedes Kunstwerk horizontal nebeneinander auszurichten.

Angenommen, Sie haben zwei Zeichenfolgen "abc\ndef"und "123\n456". Sie müssen sie horizontal ausrichten, um die Zeichenfolge zu erzeugen. "abc123\ndef456"Ich bezeichne dies als" horizontal ausrichten ", da die Eingaben beim Drucken wie folgt aussehen:

abc
def

und:

123
456

Die Ausgabe sieht beim Drucken folgendermaßen aus:

abc123
def456

Beachten Sie, wie ein Eingang neben dem anderen platziert wird.

Eingang

• Die Eingabe erfolgt als Zeichenfolge und kann als zwei separate Argumente oder als Folge von Zeichenfolgen erfolgen.
• Die Zeichen in den Künsten haben Dezimalcodes im Bereich von 32-126 (einschließlich).
• Es ist in Ordnung, eine beliebige Anzahl von Künsten anstelle von nur zwei zu unterstützen (aber offensichtlich müssen Sie mindestens zwei unterstützen).
• Sie können davon ausgehen, dass jedes Bild die gleichen Abmessungen hat und mindestens eine Zeile enthält.

• Sie müssen mindestens 100x100 Zeichen unterstützen können.

• Um sich an die Konventionen auf der Site anzupassen, spielt die Reihenfolge der Argumente keine Rolle. Es ist egal, welche Kunst links oder rechts ist.

Ausgabe

• Die Ausgabe erfolgt nach den oben genannten Regeln, entweder als Rückgabe oder als Ausgabe an die Standardausgabe.

• Alle nachfolgenden Leerzeichen sind optional.

• Es darf keine visuelle Trennung zwischen den ausgerichteten Künsten geben.

Eingabe- und Ausgabekünste müssen Zeichenfolgen sein \noder voneinander getrennt werden \r. Es wäre zu trivial, 2D-Arrays zuzulassen.

Einsendungen können Funktionen oder vollständige Programme sein.

Testfälle:

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

Canvas , 1 Byte

×

Probieren Sie es hier aus!

Haskell , 37 Bytes

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

Probieren Sie es online!

IO als Zeilenlisten wäre eben zipWith(++). : P

Python 2 , 59 Bytes

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

Probieren Sie es online!

05AB1E , 6 Bytes

|¶¡øJ»

Probieren Sie es online!

Erläuterung

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

Gelee , 4 Bytes

Ỵ€ZY

Probieren Sie es online!

Perl 5 -0F , 28 Bytes

Includes +2für das \nArgument to -F(es ist "Code", also sollte es zählen)

Geben Sie die Eingaben direkt nacheinander auf STDIN.

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

Probieren Sie es online!

Bash + Coreutils, 14

• 4 Bytes gespart dank @DavidFoerster.

paste -d "" $@

Die Eingabe erfolgt als zwei Dateinamen als Befehlszeilenparameter.

Probieren Sie es online aus .

Perl 6 , 27 Bytes

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

Probieren Sie es online!

Arbeitet mit beliebig vielen Künsten. IO als Liste von Listen wäre halt &[Z~].

APL (Dyalog Unicode) , 9 Byte ^SBCS

Volles Programm. Fordert (STDIN) zur Eingabe einer beliebigen \rLängenliste von Zeichenfolgen mit Begrenzung auf. Die Saiten können ungleichmäßig und unterschiedlich breit sein, solange sie die gleiche Anzahl von Linien haben. Druckt (STDOUT) die resultierenden ASCII-Grafiken.

⊃,/⎕FMT¨⎕

Probieren Sie es online!

⎕ Eingabeaufforderung für ausgewertete Eingabe

⎕FMT¨ jeweils formatieren (alle Steuerzeichen auswerten und Zeichenmatrix zurückgeben)

,/ horizontal kombinieren (Verkettungsreduzierung)

⊃ enthüllen (weil die Reduktion den Rang von 1 auf 0 reduziert hat)

Java 8, 100 84 78 Bytes

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

Beendet mit einem ArrayIndexOutOfBoundsExceptionan STDERR, nachdem das Ergebnis an STDOUT ausgegeben wurde, was zulässig ist .

-6 Bytes dank @ OlivierGrégoire .

Erläuterung:

Probieren Sie es online aus.

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)*$/}

Probieren Sie es online!

Ein Lambda, der zwei Saiten nimmt und eine Saite zurückgibt. Wenn Sie das Standardtrennzeichen splitauf newline with setzen $;=$/;, werden keine Bytes gespeichert , aber der Rest sieht ein bisschen besser aus.

Ruby , 49 Bytes (beliebig viele Strings)

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

Probieren Sie es online!

Nur zum Spaß. Es stellt sich heraus, dass wir ein Array von Zeichenfolgen gegen einen Aufpreis von nur 1 Byte akzeptieren können.

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

Wunder , 21 Bytes

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

Anwendungsbeispiel:

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

#nwird anstelle von \nZeilenumbrüchen verwendet.

Erläuterung

Ausführliche Version:

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

Teilen Sie jede Zeichenfolge im Eingabearray entlang von Zeilenumbrüchen auf, komprimieren Sie sie mit verketteten Zeichenfolgen und geben Sie die einzelnen Elemente aus.

Kotlin , 73 Bytes

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

Probieren Sie es online!

Add ++ , 24 Bytes

L,c10CdVAptA$pG$tBcB@£+n

Probieren Sie es online!

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

Probieren Sie es online!

JavaScript (ES6), 52 Byte

Übernimmt Eingaben in der Currying-Syntax (a)(b).

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

Probieren Sie es online!

Julia 0,6 , 41 Bytes

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

Probieren Sie es online!

PowerShell , 51 bis 49 Byte

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

Probieren Sie es online!

Nimmt Eingaben als wörtliche Zeichenfolgen mit Zeilenumbrüchen an. Sie können stattdessen auch `n(den Zeilenumbruchbegrenzer in PowerShell, nicht \n) verwenden.

Zuerst setzen wir -splitden linken Eingabestring in Zeilenumbrüche, wodurch ein Array erstellt wird, und durchlaufen diesen |%{...}. Bei jeder Iteration verketten wir die Zeichenfolge mit der richtigen Eingabezeichenfolge, die wiederum in Zeilenumbrüche aufgeteilt, indiziert und inkrementiert wird.

Diese Write-Outputverbleiben in der Pipeline, und der implizite Abschluss gibt die Ausgabe als Array von Zeichenfolgen aus, die mit Zeilenumbrüchen dazwischen gedruckt werden.

APL (Dyalog Unicode) , 22 Byte ( Adáms SBCS )

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

Probieren Sie es online!

Rot , 78 Bytes

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

Probieren Sie es online!

Japt -R , 8 7 Bytes

·íV· m¬

Versuch es

Erläuterung

             :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

Versuch es

             :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[@]}"

Probieren Sie es 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

Beispiele:

$ 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

Ich habe auch eine kürzere, aber es schlägt fehl, wenn die zweite readAnweisung einen Wert ungleich Null zurückgibt.

Bash , 55 Bytes

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

Hinweis: Scheint<&3 auf tio.run nicht zu funktionieren

Dieser verwendet Dateideskriptoren ( 1und 3) anstelle von Argumenten:

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

Kohle , 8 Bytes

ＰθＭ⌕θ¶→η

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

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

Fügen Sie 2 Bytes hinzu, um mehrere Eingaben zu akzeptieren:

ＦＡ«ＰιＭ⌕ι¶→

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

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

Fügen Sie 4 Bytes hinzu, um ungepolsterte Eingaben zu akzeptieren:

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

      θ         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`
`

Probieren Sie es online!

Unterstützt eine beliebige Anzahl von ASCII-Künsten, die zusammengefügt werden, anstatt nur 2 (wie in den beiden vorherigen JS-Antworten).

Sauber , 61 Bytes

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

Probieren Sie es online!

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

Erläuterung

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

Probieren Sie es online!