Twoim zadaniem jest przyjęcie jako danych wejściowych dwóch „ASCII Art” i wyrównanie każdego dzieła obok siebie w poziomie.

Załóżmy na przykład, że masz dwa ciągi "abc\ndef"i "123\n456". Musisz wyrównać je w poziomie, aby utworzyć ciąg znaków "abc123\ndef456. Nazywam to „wyrównywaniem w poziomie”, ponieważ podczas gdy dane wejściowe, po wydrukowaniu, wyglądają tak:

abc
def

i:

123
456

Wydruk po wydrukowaniu będzie wyglądał następująco:

abc123
def456

Zwróć uwagę, jak jedno wejście jest umieszczane obok drugiego.

Wejście

• Dane wejściowe będą ciągami znaków i mogą być dwoma oddzielnymi argumentami lub sekwencją ciągów znaków.
• Znaki w sztuce będą miały kody dziesiętne w zakresie 32-126 (włącznie).
• Wspieranie dowolnej sztuki może być wyrównane zamiast tylko dwóch (ale oczywiście musisz wesprzeć co najmniej dwie).
• Możesz założyć, że każda sztuka będzie miała takie same wymiary i będzie zawierać co najmniej jedną linię.

• Musisz mieć możliwość obsługi co najmniej 100 x 100 sztuk postaci.

• Aby dostosować się do konwencji w witrynie, kolejność argumentów nie ma znaczenia. Nie ma znaczenia, która sztuka znajduje się po lewej lub prawej stronie.

Wynik

• Wyjście będzie zgodne ze sztukami, jak wspomniano powyżej, albo zwrócone, albo wyjście na standardowe wyjście.

• Dowolne końcowe białe spacje są opcjonalne.

• Pomiędzy dopasowanymi sztukami nie może istnieć żaden wizualny separator.

Sztuki wejściowe i wyjściowe muszą być \nlub \rogranicznikami. Byłoby zbyt trywialne zezwolenie na tablice 2D.

Zgłoszenia mogą być funkcjami lub pełnymi programami.

Przypadki testowe:

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

Płótno , 1 bajt

×

Wypróbuj tutaj!

Haskell , 37 bajtów

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

Wypróbuj online!

IO jako listy linii byłyby po prostu zipWith(++). : P

Python 2 , 59 bajtów

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

Wypróbuj online!

05AB1E , 6 bajtów

|¶¡øJ»

Wypróbuj online!

Wyjaśnienie

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

Galaretka , 4 bajty

Ỵ€ZY

Wypróbuj online!

Perl 5 -0F , 28 bajtów

Obejmuje +2dla \nargumentu -F(to „Kod”, więc należy go liczyć)

Podaj dane wejściowe bezpośrednio po sobie na STDIN.

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

Wypróbuj online!

Bash + coreutils, 14

• 4 bajty zapisane dzięki @DavidFoerster.

paste -d "" $@

Dane wejściowe podano jako dwie nazwy plików jako parametry wiersza polecenia.

Wypróbuj online .

Perl 6 , 27 bajtów

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

Wypróbuj online!

Współpracuje z dowolną liczbą sztuk. IO jako lista list byłaby sprawiedliwa &[Z~].

APL (Dyalog Unicode) , 9 bajtów ^SBCS

Pełny program Monity (STDIN) dla dowolnej długości listy \r-delimitowanych ciągów. Sznurki mogą być nierówne i o różnych szerokościach, o ile mają taką samą liczbę linii. Wydruki (STDOUT) wynikające z art ASCII.

⊃,/⎕FMT¨⎕

Wypróbuj online!

⎕ monit o podanie danych wejściowych

⎕FMT¨ formatuj (oceniaj wszystkie znaki kontrolne i zwracaj macierz znaków) każdy

,/ łącz je poziomo (redukcja catenation)

⊃ ujawnij (ponieważ redukcja zmniejszyła rangę z 1 do 0)

Java 8, 100 84 78 bajtów

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

Wychodzi z ArrayIndexOutOfBoundsExceptionSTDERR po wydrukowaniu wyniku do STDOUT, co jest dozwolone .

-6 bajtów dzięki @ OlivierGrégoire .

Wyjaśnienie:

Wypróbuj 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

Rubinowy , 48 bajtów

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

Wypróbuj online!

Lambda bierze dwa łańcuchy i zwraca łańcuch. Ustawienie domyślnesplit separatora na nowy wiersz za pomocą $;=$/;nie zapisuje żadnych bajtów, ale sprawia, że ​​reszta wygląda nieco ładniej.

Ruby , 49 bajtów (dowolnie wiele ciągów)

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

Wypróbuj online!

Dla żartu. Okazuje się, że możemy zaakceptować tablicę ciągów za dodatkową opłatą wynoszącą tylko 1 bajt.

JavaScript (ES6), 51 bajtów

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

Cud , 21 bajtów

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

Przykład użycia:

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

#n jest używany zamiast \n do oznaczenia nowego wiersza.

Wyjaśnienie

Pełna wersja:

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

Podziel każdy ciąg znaków w tablicy wejściowej wzdłuż znaków nowej linii, skompresuj zip za pomocą konkatenacji łańcucha i wyślij każdy element.

Kotlin , 73 bajty

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

Wypróbuj online!

Dodaj ++ , 24 bajty

L,c10CdVAptA$pG$tBcB@£+n

Wypróbuj online!

C, 96 bajtów

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

Wypróbuj online!

JavaScript (ES6), 52 bajty

Pobiera dane wejściowe w składni curry (a)(b).

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

Wypróbuj online!

Julia 0.6 , 41 bajtów

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

Wypróbuj online!

PowerShell , 51 49 bajtów

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

Wypróbuj online!

Pobiera dane wejściowe jako ciągi literalne z znakami nowej linii. Możesz także użyć `n(separatora nowego wiersza w programie PowerShell, a nie \n).

Najpierw -splitlewy ciąg wejściowy na znakach nowej linii, który tworzy tablicę, i przechodzimy przez niego |%{...}. W każdej iteracji łączymy ciąg znaków z właściwym ciągiem wejściowym ponownie dzielonym na znaki nowej linii, indeksowanym i zwiększanym.

Są one pozostawione w potoku, a domniemane Write-Outputpo zakończeniu daje nam wynik jako tablicę ciągów, które są drukowane z nowymi liniami między nimi.

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

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

Wypróbuj online!

Czerwony , 78 bajtów

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

Wypróbuj online!

Japt -R , 8 7 bajtów

·íV· m¬

Spróbuj

Wyjaśnienie

             :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

Alternatywny

·Ë+V·gE

Spróbuj

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

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

Wypróbuj online!

Nie golfowany:

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

Przykłady:

$ 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

Mam też krótszy, ale kończy się niepowodzeniem, jeśli druga readinstrukcja zwraca wartość niezerową.

Bash , 55 bajtów

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

Uwaga: <&3nie działa na tio.run

Ten używa deskryptorów plików ( 1i 3) zamiast argumentów:

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

Węgiel drzewny , 8 bajtów

ＰθＭ⌕θ¶→η

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

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

Dodaj 2 bajty, aby zaakceptować wiele danych wejściowych:

ＦＡ«ＰιＭ⌕ι¶→

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

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

Dodaj 4 bajty, aby zaakceptować niepakowane dane wejściowe:

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

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

JavaScript (Node.js) , 79 bajtów

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

Wypróbuj online!

Obsługuje dowolną liczbę sztuk ASCII łączących się ze sobą, a nie tylko 2 (jak w 2 poprzednich odpowiedziach JS).

Czysty , 61 bajtów

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

Wypróbuj online!

Swift 4 , 119 bajtów

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

Wyjaśnienie

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

Wypróbuj online!