Nhiệm vụ của bạn là chấp nhận làm hai "Nghệ thuật ASCII" đầu vào và căn chỉnh từng tác phẩm nghệ thuật cạnh nhau theo chiều ngang.

Ví dụ: giả sử bạn có hai chuỗi "abc\ndef"và "123\n456". Bạn cần căn chỉnh chúng theo chiều ngang để tạo ra chuỗi "abc123\ndef456". Tôi gọi đây là" căn chỉnh theo chiều ngang "bởi vì trong khi các đầu vào, khi được in, trông như thế này:

abc
def

và:

123
456

Đầu ra, khi được in, sẽ trông như thế này:

abc123
def456

Lưu ý cách một đầu vào được đặt bên cạnh đầu vào khác.

Đầu vào

• Đầu vào sẽ là các chuỗi và có thể là hai đối số riêng biệt hoặc là một chuỗi các chuỗi.
• Các nhân vật trong nghệ thuật sẽ có mã thập phân trong phạm vi 32-126 (đã bao gồm).
• Thật tốt khi hỗ trợ một số lượng nghệ thuật tùy ý để căn chỉnh thay vì chỉ hai (nhưng rõ ràng bạn phải hỗ trợ ít nhất hai).
• Bạn có thể giả định rằng mỗi nghệ thuật sẽ có cùng kích thước và chúng sẽ chứa ít nhất một dòng.

• Bạn phải có khả năng hỗ trợ ít nhất 100x100 nhân vật nghệ thuật.

• Để phù hợp với các quy ước trên trang web, thứ tự đối số không quan trọng. Không quan trọng nghệ thuật ở bên trái hay bên phải.

Đầu ra

• Đầu ra sẽ là nghệ thuật căn chỉnh như đã đề cập ở trên, được trả về hoặc xuất ra thiết bị xuất chuẩn.

• Bất kỳ khoảng trắng dấu trong tùy chọn.

• Không được có sự phân tách thị giác giữa các nghệ thuật liên kết.

Nghệ thuật đầu vào và đầu ra phải là \nhoặc \rchuỗi phân cách. Sẽ là quá tầm thường khi cho phép mảng 2D.

Đệ trình có thể là chức năng hoặc chương trình đầy đủ.

Các trường hợp thử nghiệm:

"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

×

Hãy thử nó ở đây!

Haskell , 37 byte

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

Hãy thử trực tuyến!

IO là danh sách các dòng sẽ được zipWith(++). : P

Python 2 , 59 byte

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

Hãy thử trực tuyến!

05AB1E , 6 byte

|¶¡øJ»

Hãy thử trực tuyến!

Giải trình

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

Thạch , 4 byte

Ỵ€ZY

Hãy thử trực tuyến!

Perl 5 -0F , 28 byte

Bao gồm +2cho \nđối số -F(đó là "mã" để nó được tính)

Cung cấp đầu vào trực tiếp cho nhau trên STDIN.

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

Hãy thử trực tuyến!

Bash + coreutils, 14

• 4 byte được lưu nhờ @DavidFoerster.

paste -d "" $@

Đầu vào được đưa ra dưới dạng hai tên tệp dưới dạng tham số dòng lệnh.

Hãy thử trực tuyến .

Perl 6 , 27 byte

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

Hãy thử trực tuyến!

Hoạt động với số lượng nghệ thuật tùy ý. IO là danh sách các danh sách sẽ chỉ &[Z~].

APL (Dyalog Unicode) , 9 byte ^SBCS

Chương trình đầy đủ. Nhắc (STDIN) cho bất kỳ danh sách độ dài nào của các \rchuỗi được phân tách. Các chuỗi có thể bị rách và có độ rộng khác nhau miễn là chúng có cùng số dòng. In (STDOUT) kết quả nghệ thuật ASCII.

⊃,/⎕FMT¨⎕

Hãy thử trực tuyến!

⎕ nhắc nhở đánh giá đầu vào

⎕FMT¨ định dạng (đánh giá tất cả các ký tự điều khiển và ma trận ký tự trả về) mỗi

,/ kết hợp chúng theo chiều ngang (giảm catenation)

⊃ tiết lộ (vì giảm thứ hạng từ 1 xuống 0)

Java 8, 100 84 78 byte

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

Thoát với ArrayIndexOutOfBoundsExceptionSTDERR sau khi nó đã in kết quả sang STDOUT, được phép .

-6 byte nhờ @ OlivierGrégoire .

Giải trình:

Hãy thử trực tuyến.

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 byte

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

Hãy thử trực tuyến!

Một lambda lấy hai chuỗi và trả về một chuỗi. Đặt splitdấu phân cách mặc định thành dòng mới $;=$/;mà không lưu bất kỳ byte nào, nhưng nó làm cho phần còn lại trông đẹp hơn một chút.

Ruby , 49 byte (nhiều chuỗi tùy ý)

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

Hãy thử trực tuyến!

Chỉ để cho vui. Hóa ra chúng ta có thể chấp nhận một chuỗi các chuỗi với chi phí bổ sung chỉ 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>")

Kỳ quan , 21 byte

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

Ví dụ sử dụng:

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

#nđược sử dụng thay vì \nđể biểu thị dòng mới.

Giải trình

Phiên bản dài dòng:

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

Tách từng chuỗi trong mảng đầu vào dọc theo dòng mới, zip với chuỗi nối và xuất từng mục.

Kotlin , 73 byte

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

Hãy thử trực tuyến!

Thêm ++ , 24 byte

L,c10CdVAptA$pG$tBcB@£+n

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

JavaScript (ES6), 52 byte

Đưa đầu vào theo cú pháp currying (a)(b).

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

Hãy thử trực tuyến!

Julia 0,6 , 41 byte

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

Hãy thử trực tuyến!

PowerShell , 51 49 byte

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

Hãy thử trực tuyến!

Đưa đầu vào dưới dạng chuỗi ký tự với dòng mới. Thay vào đó `n, bạn cũng có thể sử dụng (dấu phân cách dòng mới trong PowerShell \n).

Đầu tiên chúng ta -splitlà chuỗi đầu vào bên trái trên dòng mới, tạo ra một mảng và lặp qua đó |%{...}. Mỗi lần lặp, chúng tôi nối chuỗi với chuỗi đầu vào bên phải một lần nữa phân chia trên dòng mới, được lập chỉ mục và tăng dần.

Những cái còn lại trên đường ống và ẩn Write-Outputkhi hoàn thành cung cấp cho chúng ta đầu ra dưới dạng một chuỗi các chuỗi, được in với dòng mới giữa.

APL (Dyalog Unicode) , 22 byte ( SBCS của Adám )

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

Hãy thử trực tuyến!

Màu đỏ , 78 byte

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

Hãy thử trực tuyến!

Japt -R , 8 7 byte

·íV· m¬

Thử nó

Giải trình

             :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

Thay thế

·Ë+V·gE

Thử nó

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

Hãy thử trực tuyến!

Ung dung:

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

Ví dụ:

$ 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

Tôi cũng có một cái ngắn hơn nhưng nó thất bại nếu readcâu lệnh thứ hai trả về giá trị khác không.

Bash , 55 byte

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

Lưu ý: <&3dường như không hoạt động trên tio.run

Cái này sử dụng mô tả tập tin ( 1và 3) thay vì đối số:

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

Than , 8 byte

ＰθＭ⌕θ¶→η

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

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

Thêm 2 byte để chấp nhận nhiều đầu vào:

ＦＡ«ＰιＭ⌕ι¶→

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

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

Thêm 4 byte để chấp nhận đầu vào không được đệm:

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

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

Hãy thử trực tuyến!

Hỗ trợ số lượng nghệ thuật ASCII tùy ý kết hợp với nhau chứ không chỉ là 2 (như trong 2 câu trả lời JS trước đó).

Sạch , 61 byte

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

Hãy thử trực tuyến!

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

Giải trình

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

Hãy thử trực tuyến!