[Question]
  [
Your task is to accept as input two "ASCII Art"s, and align each piece of art next to each other horizontally.
For example, say you have two strings, `"abc\ndef"` and `"123\n456"`. You need to align them horizontally to produce the string `"abc123\ndef456`". I'm calling this "aligning horizontally" because while the inputs, when printed, look like this:
```
abc
def
```
and:
```
123
456
```
The output, when printed, will look like this:
```
abc123
def456
```
Note how one input is placed next to the other.
---
# Input
* Input will be strings, and can be as two separate arguments, or as a sequence of strings.
* The characters in the arts will have decimal codes in the range 32-126 (inclusive).
* It's fine to support an arbitrary number of arts to align instead of just two (but obviously you must support at least two).
* You can assume that each art will have the same dimensions, and that they will contain at least one line.
* You must be able to support at least 100x100 character arts.
* To align with conventions on the site, the argument order does not matter. It does not matter which art is on the left or right.
---
# Output
* Output will be the aligned arts as mentioned above, either returned or output to the stdout.
* Any trailing whitespace in optional.
* There must be no visual separator between the aligned arts.
---
Input and output arts must be `\n` or `\r` delimited strings. It would be overly trivial to allow 2D-arrays.
Submissions may be functions or full programs.
Test Cases:
```
"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"
```
  
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 1 [byte](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
×
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JUQ3,i=JTIycXdlcnR5dWlvcCU1Q24lMjBhc2RmZ2hqa2wlMjIlMEElMjJTb21lJTIwb3RoZXIlNUNuVGV4dEZpbGxlciUyMg__,v=1)
[Answer]
# [Haskell](https://www.haskell.org/), 37 bytes
```
(unlines.).(.lines).zipWith(++).lines
```
[Try it online!](https://tio.run/##y0gszk7NyfmfZhvzX6M0LyczL7VYT1NPQw/M0tSryiwIzyzJ0NDW1oQI/c9NzMxTsFUoKC0JLilSUFFIU1BKTEqOyUtJTVNSUDI0Mo7JMzE1U/r/LzktJzG9@L9uckEBAA "Haskell – Try It Online")
IO as lists of lines would just be `zipWith(++)`. :P
[Answer]
# [Python 2](https://docs.python.org/2/), 59 bytes
```
lambda y:'\n'.join(map(str.__add__,*map(str.splitlines,y)))
```
[Try it online!](https://tio.run/##NcpLCoAgFADAq4SbNCTouwg6SYa8Msmwp6QbT29t2g7jUzwdtlnPIlu4NwVFmkqBZX05g/QGT0N8ailBKSl59UPw1kRr8Ag8McayfwxGqulCYNsFqkMTTpq2E9gPI1m/8QI "Python 2 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 6 bytes
```
|¶¡øJ»
```
[Try it online!](https://tio.run/##MzBNTDJM/f@/5tC2QwsP7/A6tPv/fyUlJQUFLQUFLgUtLS0FLi0QgLIh4kAFXGBF2iBFYFIbBLiQRYAKAA "05AB1E – Try It Online")
**Explanation**
```
|        # push all input into a list
 ¶¡      # split on newlines
   ø     # zip
    J    # join the rows to single strings
     »   # merge on newlines
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes
```
Ỵ€ZY
```
[Try it online!](https://tio.run/##y0rNyan8///h7i2PmtZERf7//18pMSk5Ji8lNU1JR0HJ0Mg4Js/E1EwJAA "Jelly – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-0F`, 28 bytes
Includes `+2` for the `\n` argument to `-F` (it's "code" so it should count)
Give inputs directly after each other on STDIN.
```
#!/usr/bin/perl -0F\n
say@F[$%++,$_]for@F/2..$#F
```
[Try it online!](https://tio.run/##K0gtyjH9/784sdLBLVpFVVtbRyU@Ni2/yMFN30hPT0XZ7f//xKRkrpTUNC5DI2MuE1Mzrn/5BSWZ@XnF/3UN3GLy/uv6muoZGugZAAA "Perl 5 – Try It Online")
[Answer]
# Bash + coreutils, 14
* 4 bytes saved thanks to @DavidFoerster.
```
paste -d "" $@
```
Input is given as two filenames as command-line parameters.
[Try it online](https://tio.run/##RYw7DoAgEER7TzFBqzUWfkvjQWgWxWhDjHB/FFGc5mV2961iu/nj3I1bIQACpAER3aCQ1N6dwAjOfqF8hIgyJLUXQVBZ/hmsZmkWvcY/aVw3rTRdP8Rrqx0Yyh9snUa1QAgUk/cX).
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 27 bytes
```
{join "\n",[Z~] $_>>.lines}
```
[Try it online!](https://tio.run/##PYzNDoIwEITP8hSbhoMWYuIfFyNHX0BPUkJQWimWFgtGidFXrxQJc5nMzjdbUS0CU7bgMtiZd6G4BEQk8qPTNwY3CcO54JLWH7N16tRiUzeZ@T0DTGlnEqH0fCEyowx158VyReR6E6DYt9X9SXXTPriqiIS0ztg1L27CggdVUlBNTjWRR/pq9lwIqocZAAboFhjjzrDVmIbO/gDweuxvntWYBkOx@QE "Perl 6 – Try It Online")
Works with arbitrary number of arts. IO as list of lists would be just `&[Z~]`.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 9 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Full program. Prompts (STDIN) for any length list of `\r`-delimited strings. The strings may be ragged and of different widths as long as they have the same number of lines. Prints (STDOUT) resulting ASCII art.
```
⊃,/⎕FMT¨⎕
```
[Try it online!](https://tio.run/##dU8xbgIxEOx5xcYNkjkUAUmeQIEEKaCLU5h47XMwZ7Ln6Lg6BREFHX/gHXnKfeRiE0QVphnN7O7srty4vqql86Ztvne6bfZf2X1zOI6ni59T5OS2cIbuRD2ZP8@g@8Lk8k2QQs0yYIPhSNDD4xN77Xb@af2okEL9af1GEMhSaZO/r1wanPs1gg85kqAFbsPYOod0IwaAA8QEznkknnBVl1rKBOid2/6ol3BVF7qxYC2LWhBJY1AJkmRKljGv45tWayQsgqDKqpAnv/K0KkW8W9sC72LiLw "APL (Dyalog Unicode) – Try It Online")
`⎕` prompt for evaluated input
`⎕FMT¨` format (evaluate all control characters and return character matrix) each
`,/` combine them horizontally (catenation reduction)
`⊃` disclose (because the reduction reduced the rank from 1 to 0)
[Answer]
# Java 8, ~~100~~ ~~84~~ 78 bytes
```
a->b->{for(int i=0;;)System.out.println(a.split("\n")[i]+b.split("\n")[i++]);}
```
Exits with an `ArrayIndexOutOfBoundsException` to STDERR after it has printed the result to STDOUT, [which is allowed](https://codegolf.meta.stackexchange.com/questions/4780/should-submissions-be-allowed-to-exit-with-an-error/4781#4781).
-6 bytes thanks to *@OlivierGrégoire*.
**Explanation:**
[Try it online.](https://tio.run/##bY89a8MwEIZ3/4ojk4RrkfRrceMlkK1TRtfDWZaLXFkS1ikQgn@7qlIvhcIN9/Fw7/tOeMXKeWWn4StJgyHAO2p7LwACIWkJUyZEJG3EGK0k7aw4b83bhRZtPx/@Y07OhjirZWOaBiQcE1ZNXzX30S1MWwJ93Nc1v9wCqVm4SMJnloxlKII3mtjuw@54q7uy/7soy47Xa6qzzVw@9iY73QxfnR5gziHYr3TbIf/JAyAFem9uDNt9xwVKqTzl4ZB/5ftarClhL4tBjenw@FQ8v7x@Aw)
```
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
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 48 bytes
```
->a,b{$;=$/;a.split.zip(b.split).map(&:join)*$/}
```
[Try it online!](https://tio.run/##VZDPUoMwEMbvfYqdDONAinT8e2gHvfkCegMOARZJTUOEMLZanx0ToIC57H7f/r5NJnWbnroi7K6fmJ/@OLvQ2exY0CjBdfDNlZsOvRccmHKvtvuKS486m98uWgFEhKVZLHMsiA/k5vYulvcPj7Y3fi/NyDqJ39OfX1jrU8srFUtgTV68l/sPYfnX6oBQ6RLrWL7hUb9wIbC2kzmzZOb0gh5vAaAABqGUmkLtmdQ4s4sB1j02lLU9kxrLgJnExbZLxr7fe0kt/JknySoJkGUl5BWcmQ@pD3hUmGnMz@alNTat0BBCEZm/T4yjWt1MdjjB8AzEVaxpPAJb0xaMC4/850e1Qpl3fw "Ruby – Try It Online")
A lambda taking two strings and returning a string. Setting the default `split` delimiter to newline with `$;=$/;` doesn't save any bytes, but it makes the rest look a little nicer.
# [Ruby](https://www.ruby-lang.org/), 49 bytes (arbitrarily many strings)
```
->s{s.map{|a|a.split$/}.transpose.map(&:join)*$/}
```
[Try it online!](https://tio.run/##dU5BDoIwELzzig0xRgvi3UQ/UjhUKBGjpaEl0YCJ8ezBAwffx0dwCxS9uGk6uzvT6RTl/tql2261U5UKzkxWNatZoOQp07P1LdAFE0rmihtuMd8c80wsCTIddQAodQEIQCiAEIJATE3TyLk@SgFQ6vXSATxT0zSClbbNs23u9rxC0TYP3OP9v21@XrzRKjJeQz77iYk19n1Sm@Fn/9W7kRMFnMUHSHKoMyFLrXzgF8ljzZMazc0GUjpQkcNF0n0A "Ruby – Try It Online")
Just for fun. It turns out we can accept an array of strings at an additional cost of only 1 byte.
[Answer]
## JavaScript (ES6), 51 bytes
```
f=
(a,b)=>a.replace(/.+/g,a=>a+b.shift(),b=b.split`
`)
;document.write("<pre>"+f("abc\ndef", "123\n456")+"</pre>")
```
[Answer]
# [Wonder](https://github.com/wonderlang/wonder), 21 bytes
```
->#oN.zip#++.-> <>"
"
```
Usage example:
```
(->#oN.zip#++.-> <>"
")["abc#ndef" "abc#ndef"]
```
`#n` is used instead of `\n` to denote newlines.
## Explanation
Verbose version:
```
(map #oN) . (zip #con) . (map split "#n")
```
Split each string in the input array along newlines, zip with string concatenate, and output each item.
[Answer]
# [Kotlin](https://kotlinlang.org), 73 bytes
```
a,b->a.split("\n").mapIndexed{i,s->s+b.split("\n")[i]}.joinToString("\n")
```
[Try it online!](https://tio.run/##bY3LasMwEEX3@YpBK0l@QJ8LQ70MdJ3s6i7kWnKUyCNHVtIU42935diEUnJB3Jk7M0cH643GUZ0QGqGRnoUTrobwugw23mmsGfQrCDoLAyqjIpvjuFwKluRz8daPIi6TXKRda7SnpEDC0ka071jJi6x6HXdJ3kXl3/mH/hzSvdW4tTNljkeAYXX9tg2hN0gVJaL8KgJKkRjIw@NTgc8vr4Sx/2vHb@n8z0nbtkAQXaXq3f5gpqONbSRYv5OuwK28@LU2Rro7CAAOEK4558H4pFu3zCYeQHRdmy2adOsWm@DD@As "Kotlin – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `j`, 4 bytes
```
↵∩vṅ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJqIiwiIiwi4oa14oipduG5hSIsIiIsIltcIiAgKiAgXFxuICoqKiBcXG4qKioqKlxcbiAqKiogXFxuICAqICBcXG5cIixcIiAgKyAgXFxuICArICBcXG4rKysrK1xcbiAgKyAgXFxuICArICBcXG5cIl0iXQ==)
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), ~~15~~ 14 bytes
```
"\n"/,'/"\n"\'
```
[Try it online!](https://ngn.codeberg.page/k#eJxLs1KKyVPS11HXB9Ex6lxcaQoaSolJyTF5KalpStZKhkbGMXkmpmZKmlxcAAHECtE=)
-1 byte thanks to ngn
[Answer]
# [Add++](https://github.com/cairdcoinheringaahing/AddPlusPlus), 24 bytes
```
L,c10CdVAptA$pG$tBcB@£+n
```
[Try it online!](https://tio.run/##S0xJKSj4/99HJ9nQwDklzLGgxFGlwF2lxCnZyeHQYu28/yo5iblJKYkKhnZKiUnJMXkpqWlKdkqGRsYxeSamZkpc/lxcFVaGBlwBXFxISgvLU4tKKksz8wti8hQSi1PS0jOysnOAGoPzc1MV8ksyUoti8kJSK0rcMnNyUotwGaOgoKWgADRBS0sLSGmBAJwHlVMCqdIGq4JQ2iAA50EpoAX/AQ "Add++ – Try It Online")
[Answer]
# 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)}}
```
[Try it online!](https://tio.run/##bY29csIwEIR7P8WhNDrZzGD@Gk1SpqILXUzhCMkWGJlIYpKMx89uJAKu2Gbn7vbbE9NKiGF42UuljYQNdahaSzlzafqWzzieL17UpaXuc5rvkCeaK@oyj3HJXMY8726Afp1MQkbveCAcJQSxi20b6rHvB208nEptKCZdAkGKkvJLFCY8JhmQfL4ozHK1Jjjy/JH7/pHW/110ey4MlG6vqvpwbCL10Z4ktL6WtjBb@evfddNI@6wDgAEEnDEWjEWN0/0WCwHSW@zf0qhxulss7Ycr)
[Answer]
# JavaScript (ES6), 52 bytes
Takes input in currying syntax `(a)(b)`.
```
a=>b=>a.split`
`.map((s,i)=>s+b.split`
`[i]).join`
`
```
[Try it online!](https://tio.run/##bUzNEoIgGLz3FAwnwHKm3xsee4G6RTOiomIIBvT39CbleGjay3673@42/M5dbmXnF9oUoi9pz2mS0YTHrlPSp7M0bnmHkJtLTBMXZZN/kmccN0bq4e5zo51RIlamQiWCPMuZLkQJMYLL1ZrpzXYHMZ79xK4PYf3rJk3HNOCuKKu6uahQOphWAONrYZk@iqffS6WE/TMBAAFgaBNCBiIBkxp/YQ@A6BP7UhQwqZGG8f4N "JavaScript (Node.js) – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~51~~ 49 bytes
```
param($a,$b)$a-split"
"|%{$_+($b-split"
")[$i++]}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/vyCxKDFXQyVRRyVJUyVRt7ggJ7NEiUupRrVaJV5bQyUJLqIZrZKprR1b@///fyUFBS0FBS4FLS0tBS4tEICyIeJKIAXaIAVgUhsEuJBFlAA "PowerShell – Try It Online")
Takes input as literal strings with newlines. You could also use ``n` (the newline delimiter in PowerShell, not `\n`) instead.
We first `-split` the left input string on newlines, which creates an array, and loop through that `|%{...}`. Each iteration, we string concatenate with the right input string again split on newlines, indexed and incremented.
Those are left on the pipeline and the implicit `Write-Output` at completion gives us output as an array of strings, which are printed with newlines between.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 22 bytes ([Adám's SBCS](https://github.com/abrudz/SBCS))
```
{⊃,/↑¨⍵}'[^\n]+'⎕S'&'¨
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///v/pRV7OO/qO2iYdWPOrdWqseHReTF6ut/qhvarC6mvqhFf//pyk8apugQEgdV3weWB1QIMQ52iiWiytNQz0xKVldJz5PRz0lNU1dU0Pd0MgYwjcxNVPXBAA "APL (Dyalog Unicode) – Try It Online")
[Answer]
# [Red](http://www.red-lang.org), 78 bytes
```
func[a b][b: split b"^/"foreach c split a"^/"[prin c print first b b: next b]]
```
[Try it online!](https://tio.run/##PYxNDoIwEIX3nGLCsiwafxccwAOoO0KTtkylioAFooZw9jpFwmzevDffG4eFP2MBWR6Z1Juh1pkElWcqha6tbA8qFjw2jUOpS9BLKEOYtc7WFAXpwVjXEQ1UrPFDW557A6NUWvACzQTjZrsTfH84ThHlrze6/jvYphUcZFeYW3l/VERdmidC05foBL/So5OtKnRzB4ABEM4YI2FhVrfcpkAlM/WXJMzqFpn8Dw "Red – Try It Online")
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 92 bytes
```
a=();for b;do c=;while IFS= read -r d;do a[c++]+=$d;done<<<"$b";done;printf '%s\n' "${a[@]}"
```
[Try it online!](https://tio.run/##PY1BCsMgFESvMojFVvEEKnRV6LrLNAuNhgSKKRroovTsttqQ2bz/mIHvbJ5KDiukBGUAB@4RnPMfeM1uW8faTLTZH6Jmtw2sWHM8qXFJcMovGIx6TfMj4Hq5GaRgPWSCr5XtBiF6YWi1GLTWhDrSbvVMc1xHsEOunwl92@7cf0gpXw "Bash – Try It 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
```
**Examples:**
```
$ 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
```
---
I also have a shorter one but it fails if the second `read` statement returns a non-zero value.
# [Bash](https://www.gnu.org/software/bash/), 55 bytes
```
while IFS= read -r a;IFS= read b<&3;do echo "$a$b";done
```
Note: `<&3` doesn't seem to work on [tio.run](https://tio.run/)
This one uses file descriptors (`1` and `3`) instead of arguments:
```
$ foo <<< $'qwertyuiop\n asdfghjkl' 3<<< $'Some other\nTextFiller'
qwertyuiopSome other
 asdfghjklTextFiller
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 8 bytes
```
ＰθＭ⌕θ¶→η
```
[Try it online!](https://tio.run/##S85ILErOT8z5/9@3NKcks6AoM69Eo1DTmss3vyxVwy0zL0WjUEdBKSZPSVNHwSooMz2jBCgZAFaWoWn9/3@0koKCloJCTJ6ClpYWkNICATgPKqcENEJBQRusDEJpgwCcB6WUYv/rluUAAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
 θ          First input
Ｐ           Print without moving the cursor
    θ       First input
     ¶      Literal newline
   ⌕        Find index
  Ｍ   →     Move that many squares right
       η    Implicitly print second input
```
Add 2 bytes to accept multiple inputs:
```
ＦＡ«ＰιＭ⌕ι¶→
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z8tv0hBwzOvoLREQ1NToZqL07c0pySzoCgzr0QjU9MayM8vS9Vwy8xL0cjUUVCKyVPS1FGwCspMzygBytb@/x8draSgoKWgEJOnoKWlBaS0QADOg8opAfUqKGiDlUEobRCA86CUUmzsf92yHAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
 Ａ          Input
Ｆ «         Loop over all entries
   Ｐι       Print current entry
     Ｍ⌕ι¶→  Move to next entry
```
Add 4 bytes to accept unpadded input:
```
ＰθＭ⌈Ｅ⪪θ¶Ｌι→η
```
[Try it online!](https://tio.run/##LYxBDsIwDATvvMLyKU7LB@gXiITgSDlEVdVYStNQpRW/N27Ah1mvrd0h@HVYfBRxWyycV07FvKk7uWUfjfMfnrdZNZtHjqyvFrBPSC1cxzSVYJhIzeXOUygau9WCQJ3IEwFsn8BapbVVfqbeUZsAmsMpmmP@ewW@5LzHLw "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
      θ         First input
       ¶        Literal newline
     ⪪          Split
    Ｅ           Map over each string
         ι      Current string
        Ｌ       Length
   ⌈            Maximum
  Ｍ       →     Move that many squares right
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 79 bytes
```
a=>(b=a.map(x=>x.split`
`))[i=0].map(y=>b.map(z=>c+=z[i],c="")&&++i&&c).join`
`
```
[Try it online!](https://tio.run/##hU7LboMwELznK1Y@IB4p6vtSmQtSfUVqb4AUY0xi6tgUaEvy89R2UaqokbqH2Z2Z3dG29JMOrBfdeKV0zecGzxQnfoVpvKedP@FkiodOinGz2gRBLvB16YwDTio3HHHCInzMRblmGKHA86JIeB4L4lYLZa7mJ6bVoCWPpd76jZ8jWrFC1bxBa0A3t3eFun94RGUQrP5svn/xfjx8CN0VCuhQN9td@ybt3Yvec9DjjveFeuXT@Cyk5P3lFIAQwASEYWhaaOvEFs9GAkRu7adFtk5saZfzsywzXgYOlxkWtMH/@WmaGpY67QyNbn1CiGHEaQTILxrdfjR/Aw "JavaScript (Node.js) – Try It Online")
Supports arbitrary number of ASCII arts joining together rather than just 2 (as in the 2 previous JS answers).
[Answer]
# [Clean](https://clean.cs.ru.nl), 61 bytes
```
import StdEnv
$a b=flatlines[u++v\\u<-mklines a&v<-mklines b]
```
[Try it online!](https://tio.run/##S85JTcz7n5ufUpqTqpCbmJn3PzO3IL@oRCG4JMU1r4xLJVEhyTYtJ7EkJzMvtTi6VFu7LCam1EY3NxssoJCoVobgJMX@Dy5JBGq2VVBRiFZPTEqOyUtJTVOPjVY3NDKOyTMxNVOP/f8vGWheevF/XU@f/y6VeYm5mckQTgDQmrT8olwA "Clean – Try It Online")
[Answer]
# [Swift 4](https://iswift.org/playground), 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()}
```
**Explanation**
```
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()
}
```
[Try it online!](https://iswift.org/playground?6JEIqO&v=4)
[Answer]
# [Julia 1.0](http://julialang.org/), 34 bytes
```
^,x=split,"\n"
a\b=join(a^x.*b^x,x)
```
[Try it online!](https://tio.run/##yyrNyUw0rPj/P06nwra4ICezREeJS4krMSbJNis/M08jMa5CTysprkKnQvN/QVFmXklOnoZSYlJyTF5KappSjJKhkXFMnompmZLmfwA "Julia 1.0 – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 43 bytes (41 chars)
```
Column[StringJoin/@(#~StringSplit~"
")]&
```
 is an unprintable character in the private use area which represents Transpose in Mathematica.
This function takes input as a list of any number of strings and returns a Column object, which displays in a Mathematica notebook in the required manner (although it doesn't on TIO). For an additional ten bytes, replacing `Column[---]` with `StringRiffle[---," "]` will cause an output in the form of a single string. This code can take input of any number of strings with varied-length lines, as long as each string has the same number of lines.
---
Explanation:
`#~StringSplit~` Split the input (implicitly applied to each string in the list)
`" "` at each newline.
`` Then, transpose this list of lists of strings
`StringJoin/@` and join together each of the sublists.
`Column` Finally, convert this list of strings to a Column object.
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b73zk/pzQ3Lzq4pCgzL90rPzNP30FDuQ7CDS7IySypU@JSet/frhmr9j/NoVopMSmZKzWNKz0jU0lHQcnQyJjLxNTMgMvcUqlWXz8AqKvkPwA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), ~~8~~ ~~7~~ 5 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
·í+V·
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI&code=t%2b0rVrc&input=ImFiYwpkZWYKZ2hpIgoiMTIzCjQ1NiI)
```
·í+V·     :Implcict input of strings U & V
·         :Split U on newlines
 í        :Interleave with
   V·     :  V split on newlines
  +       :  Reduce by concatenation
          :Implicit output, joined by newlines
```
]