[Question]
  [
## Challenge:
Given a list of multi-line strings, overlap them (in the top-left) and output the result.
**Example:**
Input: `["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]`  
Output:
```
cbaa
bbaa
bbaa
aaaa
```
## Challenge rules:
* Input-format is flexible. You are allowed to get the input as a 2D list of lines (i.e. `[["aaaa","aaaa","aaaa","aaaa"],["bb","bb","bb"],["c"]]`) or 3D list of characters (i.e. `[[["a","a","a","a"],["a","a","a","a"],["a","a","a","a"],["a","a","a","a"]],[["b","b"],["b","b"],["b","b"]],[["c"]]]`). You are allowed to take all the inputs one by one through STDIN. Etc.
* Output format is strict. You can choose to print or return the multi-line string. (If your language doesn't have any strings, outputting as a 2D list of characters is allowed as alternative. But only if your language doesn't have strings at all.)
* The order of the input-list is of course important (but you are allowed to take the input in reverse if you choose to).
* Inputs will only contain printable ASCII in the unicode range \$[33,126]\$ (`!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~`).
* Inputs will only be rectangles (so no weird shapes). The output aren't necessary rectangles, though.
* Trailing spaces and a single trailing newline is allowed. Leading spaces and/or newlines not.
## General rules:
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins.  
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
* [Standard rules apply](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/2422#2422) for your answer with [default I/O rules](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/), so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
* [Default Loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* If possible, please add a link with a test for your code (i.e. [TIO](https://tio.run/#)).
* Also, adding an explanation for your answer is highly recommended.
## Test cases:
Input: `["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]`  
Output:
```
cbaa
bbaa
bbaa
aaaa
```
Input: `["12345\n54321","00\n00\n00\n00","001\n011\n012"]`  
Output:
```
00145
01121
012
00
```
Input: `["sm\noo\nmr\nee\nt!\nh_\ni_\nn_\ng_","!@#$%^\n&*()_+\nqwerty\nuiopas","this\nis_a\ntest"]`  
Output:
```
this%^
is_a_+
testty
uiopas
t!
h_
i_
n_
g_
```
  
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 24 bytes
*Saved 2 bytes thanks to @Grimy*
Assumes that the returned string is printed on a terminal that supports [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code). Contains the unprintable character `ESC`, which is escaped (no pun intended) as `\x1B` below.
```
a=>`\x1B[2J\x1B[H`+a.join`\x1B[H`
```
This doesn't work on TIO, but you can [Try it online!](https://tio.run/##FYzLDoIwEEU/hBX1kSLKwj3GpfEXGG0bLFACM9ipGr@@1sVJ7uLcM5q34da7JRyQHjZ2dTT1SWfN8Zo1F12aaiSH@r9jS8g02WqiXnayETwDEgHOHtBawJADDgrQJTDRK7EX@Xm13twBtztZqBLw@bE@fAFfjhbDSQiD4/RhZVLBchC3oog/ "JavaScript (Node.js) – Try It Online") to see the raw output instead.
### How?
The [CSI sequences](https://en.wikipedia.org/wiki/ANSI_escape_code#CSI_sequences) used are:
* ED (Erase in Display):
`ESC``[``2``J`
where \$2\$ means *"clear entire screen"*
* CUP (Cursor Position):
`ESC``[``H`
which means *"moves the cursor to row \$n\$, column \$m\$"* where both \$n\$ and \$m\$ are omitted and implicitly set to \$1\$ (top-left corner of the screen).
### Example output
[![output](https://i.stack.imgur.com/l9kya.png)](https://i.stack.imgur.com/l9kya.png)
[Answer]
# [R](https://www.r-project.org/), ~~120~~, ~~111~~ ~~110~~ 107 bytes
```
function(x,`!`=ncol,M=array('',Reduce(pmax,Map(dim,x)))){for(m in x)M[1:!t(m),1:!m]=m
write(t(M),1,!M,,'')}
```
[Try it online!](https://tio.run/##lVLBbtswDL3rK2hnm6VVG@q0vRQzsFsv82XXKEsVRW4EWJQnKavbIt@e0t7WYcMuFUCKEh4fHyXG0wL2th9shO6AJruAYAL@sDE7vIO8dwm6EL3OcA2Gl/Xy4vJK4dXlxbIuZXl@rvCPzRc1RfXslqVgC8gBNPQuZQgdEE904xSZvY7aZBsTu2l@l@aP4okBfGkmPBcUOvj0AWoKSATX4BBSjmnoXeaPslJYiTmDclYrt15P6F34aHTf87h1uJMvcC0rAs/YmdTB2Ux8nAqyI2Njc8OpQ01L4b@eWttuFf40OpiSuLrm9KJ8lLfFbYMm9LJtdIz6gVeV/Gp3B2P54PUoWz3wnfNyFLSepn781M8o2lV9XWTuhaTdrxvP7qPLlmfe0pUsWjlJP546/kqBghmd@fxK7FfyK//vfxTJKwxBoY8KrVWYC4X7jUJHhmR3G@IpPi/evP2m8N17LjZnCr/f00Q9KDy4MOhEgGmyKCdtSH@2Kf9d6/QM "R – Try It Online")
A function accepting a list of matrix of characters (3D input is accepted).
(as you can notice from the byte count, this is not very easy to do in R...)
* -9 bytes thanks to @Giuseppe
* -4 bytes thanks to @RobinRyder
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 bytes
```
a/Y
```
[Try it online!](https://tio.run/##y0rNyan8/z9RP/L/4fZHTWuyHjXM4eL6/z@aSwEIoqOVEoFASQcbFasTrZSUBOTBCJBAslJsrA5Mr6GRsYkpUM7UxNjIECxtYADkohAQUUMQxxBCGiEbUZwLFMvPBxK5RUAiNRVIlCgCiYx4IJEJIvJARHo82CRFB2UV1TggX01LQzNeG8goLE8tKqkEMkoz8wsSi8GqSjIyi0G6i@NBnilJLS4BWskVCwA "Jelly – Try It Online")
Hadn't used Jelly in a while but I thought the challenge in the comments was beatable. Very directly uses logical and (`a`) to perform the stacking operation between each element of the input (`/`). `Y` is used to print in the required format.
[Answer]
# [Python 2](https://docs.python.org/2/), 88 bytes
```
n,f=None,filter
for l in map(n,*input()):print''.join(f(n,x)[-1]for x in map(n,*f(n,l)))
```
[Try it online!](https://tio.run/##bY1NbsMgEIX3nILQH4xLq2Anm0qReoJeANHKcXFNZAPBRHVO7zJYlVqpLD5m3rw346@xd7ZaWvehD4SQxfLu8Oqs5p0Zog6ocwEP2Fg8Nr6wvDTWX2LB2LMPxkZKn07O2KJLo5nJR6HAP//yw2RgjC3Zj9IJhPSsWwwXy3qRkoiq3u0JJ/tdXQmiuCTbbWr/YFUFNGJlRZRCKd2kl4R/Psgcj6n7AQjtGqPTSDmmzgHHANQaGDfAHgNNps38xFRxLOnm5eb27g2U@7Jg7w9Qnb90iFeoLsb5ZlqdsTdT3jLhJm/WU6RKfQM "Python 2 – Try It Online")
---
### Explanation (with example):
Takes a 2D list as input.
```
Input: [["12345","54321"],["00","00","00","00"],["001","011","012"]]
```
First the input list is zipped, to get the rows of each input rectangle (`map(None,l)` is the same a zip longest):
```
map(n,*input())   gives:
('12345', '00', '001')
('54321', '00', '011')
(None, '00', '012')
(None, '00', None)
```
Each of these rows are then filtered to removed `None`s, and zipped again:
```
map(None,*filter(None,l))
filter(None,l) for each l gives:
('12345', '00', '001')
('54321', '00', '011')
('00', '012')
('00',)
map*... gives:
[('1', '0', '0'), ('2', '0', '0'), ('3', None, '1'), ('4', None, None), ('5', None, None)]
[('5', '0', '0'), ('4', '0', '1'), ('3', None, '1'), ('2', None, None), ('1', None, None)]
[('0', '0'), ('0', '1'), (None, '2')]
['0', '0']
```
Which is a list of characters for each position of the desired result. These lists are filtered again, and the last one is taken:
```
filter(None,x)   gives:
[('1', '0', '0'), ('2', '0', '0'), ('3', '1'), ('4',), ('5',)]
[('5', '0', '0'), ('4', '0', '1'), ('3', '1'), ('2',), ('1',)]
[('0', '0'), ('0', '1'), ('2',)]
['0', '0']
and with [-1]:
['0', '0', '1', '4', '5']
['0', '1', '1', '2', '1']
['0', '1', '2']
['0', '0']
```
Lastly the resulting lists are joined and printed:
```
print''.join(..)
00145
01121
012
00
```
[Answer]
# R, ~~107~~ 97 bytes
```
function(x)for(i in 1:max(lengths(x))){for(m in x)if(i<=length(m))cat(m[i],'\r',sep='');cat('
')}
```
Doesn't appear to work on TIO, which might be related to the use of the `\r` carriage return character. It does work on my local installation of R.
Takes input as a list containing a vector of rows: 
```
x <- list(c("aaaa","aaaa","aaaa","aaaa"),c("bb","bb","bb"),c("c"))
```
Loops over the rows of each rectangle, printing a carriage return after each, restarting the line.
If we stretch the rules a little, we can do away with checking the length of the input and just loop infinitely, printing a huge amount of newlines:
# R, 85 bytes
```
function(x)for(i in 1:8e8){for(m in x)if(i<=length(m))cat(m[i],'\r',sep='');cat('
')}
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 22 [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")
Anonymous tacit prefix function taking list of 2D character arrays as argument. Prints.
```
(⊃{⍺@(⍳⍴⍺)⊢⍵}/)⌽,∘⊂1⌷↑
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT//vmfeobcKjvqluviGHVjzqmAFkegX7@6nHxOSpA9lBQEaR@n@NR13N1Y96dzloPOrd/Kh3C5Cp@ahr0aPerbX6mo969uqAdHY1GT7q2f6obeL/NJCZvX1A/Z7@QJ2H1hsDRYG84CBnIBni4Rn8P03BM089WikRCGLy0EklHaWkpJg8CAZykpVi1bl0dXW5oLoMjYxNTGPyTE2MjQyB0gYGMXkIDBYwBLIMwYQRmt7i3Ji8/PyYvNyimLzU1Ji8EsWYvIz4mLxMIM4D4vR4oAGKDsoqqnExeWpaGprx2jF5heWpRSWVMXmlmfkFicVABSUZmcVAPcXxQBeXpBaXAC0BAA "APL (Dyalog Unicode) – Try It Online")
This works by creating a canvas, then appending that to the list of blocks, and reducing (folding) with a function that places blocks in the corner.
`↑` mix the 2D block to create an orthogonal 3D block, padding them with spaces as needed
`1⌷` take the first layer
`⊂` enclose that  
 `∘` then  
`⌽,` prepend the reversed list of blocks
`(`…`)` apply the following tacit function:
 `{`…`}/` reduce using the following anonymous lambda:
  `⊢⍵` with the right argument as canvas…
  `⍺@(`…`)` amend with the elements of the left argument, placed **at** the following indices:
   `⍴⍺` the shape of the left argument
   `⍳` the **ɩ**ndices of an array of that shape
 `⊃` disclose (because the reduction enclosed to reduce rank)
[Answer]
## Haskell, 66 bytes
```
unlines.foldl((const?)?)[]
(g?(a:b))(c:d)=g a c:(g?b)d;(_?a)b=a++b
```
Input is taken as a list of list of strings in reverse order, e.g. for the first test case: `[["c"],["bb","bb","bb"],["aaaa","aaaa","aaaa","aaaa"]]`.
[Try it online!](https://tio.run/##XY7bTsMwDIbv9xRZOSihY1q77aaoKg8AV1zWJUrT9CBStzQpiJenWJ0EEpY@y/7tX3ar3JuxdqlTWGa0HRq3rwdbWc71gM5nIhN5seFNxlVSCsF1Uom0YYrphMRSVA9cZkqUqQrDculVhyxlvRqfJePj7F/89IRsz2qCVLZeoHoyH2ZyRrB8wxjLA0UB@D8Hu6AsAS9Qo4Nid9mP4uPpDHg@HeOIBocD4B@rEFEVrSn@dbkecBgA@wnQGEC/BWwlYEcg0Uiybh@vrm9eAW/vuJAh4PunmfwX4NwNo3K04NvOkcdJ@tIb54OiWL51bVXjlns9jj8 "Haskell – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 12 bytes
Port of [TFeld's python solution](https://codegolf.stackexchange.com/a/186373/47066)  
2 bytes saved thanks to *Grimy*
```
ζεðKζðδK€θJ,
```
[Try it online!](https://tio.run/##TY9LDoIwEIavgvURH3AH13KEBk1NGiERKhZjcOl5XLBQ4p59D@FFan9GSTdfvsnMtP8oLfaZtNa05tU1sWm7xjzjz/1h3pvQWs450ywMWM6SMOBMwRV5Dj@TS7gkr@Aj8hS@I888Lzw//BwFd4uuWgNjYAJMgS1Nz@BLYA4saNlhRf0SfqU4fT6HPlFN/Qs8ozMcToAA9D9BP50OY9pLr4ffhHerHFqVeyOxUVSo6Chu9Rc "05AB1E – Try It Online")
**Explanation**
```
ζ             # transpose input with space as filler
 ε            # apply to each
  ðK          # remove spaces
    ζ         # transpose with space as filler
     ðδK      # deep remove spaces
        €θ    # get the tail of each
          J   # join each
           ,  # print
```
**Alternative 14 byte version**
```
õζεÅ»DŠg.$J}θ,
```
[Try it online!](https://tio.run/##yy9OTMpM/f//8NZz285tPdx6aLfL0QXpeipeted26Pz/Hx2tVJyrpKOUnw8kcouARGoqkChRBBIZCkAiE0TkgYh0BaVYHYVoJUUHZRXVOKCAmpaGZrw2kFFYnlpUUglklGbmFyQWQ5SVZGQWg/QXKySCDEwtLlGKjf2vq5uXr5uTWFUJAA "05AB1E – Try It Online")
**Explanation**
```
õζ              # zip with empty string as filler
  ε             # apply to each
   Å»      }    # cumulative reduce by
     D          # duplicate second input
      Š         # move down twice on stack
       g.$      # remove len(other_copy) elements from the other input
          J     # join with other copy
            θ,  # print the last element
```
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 5 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
Ｈ１１╋╋
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXVGRjI4JXVGRjExJXVGRjExJXUyNTRCJXUyNTRC,i=JTVCJTIyJTIxJTIxJTIxJTVDJTVDJTIyJTJDJTIyYWFhLyU1Q25hYWFhJTVDbmFhYWElNUNuYWFhYSUyMiUyQyUyMmJiJTVDbmJiJTVDbmJiJTIyJTJDJTIyYyUyMiU1RA__,v=8)
If overlapping `/`+`\` → `X`, `-` + `|` → `+`, etc. would be fine, [2 bytes](https://dzaima.github.io/Canvas/?u=JXVGRjI4JXVGRjRF,i=JTVCJTIyJTIxJTIxJTIxJTVDJTVDJTIyJTJDJTIyYWFhLyU1Q25hYWFhJTVDbmFhYWElNUNuYWFhYSUyMiUyQyUyMmJiJTVDbmJiJTVDbmJiJTIyJTJDJTIyYyUyMiU1RA__,v=8) would work.
[Answer]
# [Python 2](https://docs.python.org/2/), 77 bytes
```
for t in map(None,*input()):
 r=''
 for s in t:
	if s:r=s+r[len(s):]
 print r
```
[Try it online!](https://tio.run/##bYxNbsMgEIXX5RQT@oOdsAhOskGKlBP0AohWTkRqpBgoECU5vctgdVGps/hm3tObFx558K6bboO9GBDS3M2JUjqdfYQM1sHYh@bdO8OX1oVrbtpWEoh7xghgJmEmS/Jkz5Bk3KdVVBfjmtRKTSBE6zLEqW6CvUpR0W22O8rpbrvpBNVc0fW6yD@YXYFCzOyo1qR892WK8c/Cn@OxqF@gcZrfWBoZB@Y9coxIY5B5gRwAaStd5RcwzUGxxeH55fUDnbdl036u8Pq@mZgfeF2tD32ak3mwqbYk6GuzSZlp/QM "Python 2 – Try It Online")
[Answer]
# [PowerShell 6](https://github.com/TryItOnline/TioSetup/wiki/Powershell), console only, 20 bytes
based on Arnauld's [answer](https://codegolf.stackexchange.com/a/186374/80745).
This work with console only and doesn't work on TIO.
```
cls
$args-join"`e[H"
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfmvkqZgq1D9PzmnmEslsSi9WDcrPzNPKSE12kPpfy0XlxpQXikRCBLy0EklBaWkpIQ8CAZykpX@AwA "PowerShell – Try It Online")
---
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 103 bytes
```
$args|%{$l=$_-split'
';$r=&{$r+($l|%{''})|%{($x=$l[$j++])+($_-replace"^.{0,$("$x"|% Le*)}")}|?{$_}}}
$r
```
[Try it online!](https://tio.run/##hVJtbqMwEP3PKRxnCFBIFWjyaxVtDrA3WDU2od6ElTNQ7GgTEc6eDtAPqKruSGPzZt48D/aUxT9VmYPS@gZ/2JrVN0irvbm6Neg1iLkpdW49x/sB1XpWQxX6oCnpeU1Amw/nNejf8DcMHwNKiXmlSp1mim/v60UEPoczv7rsl7oLGh401581iKZpHKhujeNsfIeRRf3W2sbnKZnEzyuP@G4nsXcCGQ@i9yov26WpN8C7/@BW0etg4HzRQpw8LFcSV8uHJKazFguJH94FYvqKuyUZNUKZ5Wp4ErGSeBxIRnDxTR/mKLEoJB4riUpJtBOJByExJ0fyvaBmJpspuFuJszs/EKHEZ3pQe5F4yosyNUSwh9xQjRF0lVYZO2q4TbrbYUctUYTDSFtkL8NIrz3iTIboIEaKI4QjtBdv/x@wK3NZ3SHQOSoTgTqXKrPqiQYTRJ@plDlpS4EZzeum47EpozFNrc1x35H4K4vP1TN/F@FdbvqmMGUnzIrjUaFl7S2wVovZgj3lrdqF9TzjNM7tBQ "PowerShell – Try It Online")
Unrolled:
```
$args|%{
    $l=$_-split"`n"
    $r=&{                           # run this scriptblock in a new scope
        $r+($l|%{''})|%{
            $x=$l[$j++]             # a new line or $null
            $w="$x"|% Length
            $y=$_-replace"^.{0,$w}" # remove first chars from the current line
            $x+$y                   # output the new line plus tail of the overlapped line
        }|?{$_}                     # filter out not empty lines only
    }                               # close the scope and remove all variables created in the scope
}
$r
```
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 68 + 23 = 91 bytes
```
n=>{C.Clear();n.ForEach(k=>{C.SetCursorPosition(0,0);C.Write(k);});}
```
23 bytes is for the import, `using C=System.Console;`
Does not work in TIO, since it isn't a console.
[Try it online!](https://tio.run/##XU5Na8MwDD0nv8Lk5EBnencTGKYbOwwKPezQ9uB4ambqyCA5GyPkt2deu@0wIQn00PtwfOciwTKyx16YZv/JCQZlInIMoEsXLLPYUezJDmIqOdnknfh5u3fJR9z8kUKAK8LqERDIO/W0xXEAsl2ADSfKJm17bhZs2skoE8CSrDWqh0hb697k5YrvIZmRONIusv/Wk@vVutZGvZBPIC@1nnMv@jfNe/Sv4tl6lDeLw0lY6rnOeYviLBE@DqepsrmO@H9Xq6rrjnibfLgqa5fFXM7LFw "C# (.NET Core) – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 67 bytes
Input is a list of lines. Builds a list of lines and does overwriting as it goes through the inputs, then joins them with a newline (represented by the variable `$/`) at the end to match the strict output.
```
->i,*r{i.map{|e|j=-1;e.map{|l|r[j+=1]||='';r[j][0,l.size]=l}};r*$/}
```
[Try it online!](https://tio.run/##RYzRCoMgAEXf/YqQoNXKqdVTcz@SPjRmYFiI1cOWfrtrGyO45@FeONeu92foGQ/FTeWZ3RQaO7M56QZWkEb@mna2Hc6MCOdYkjR7ES3ONZrVSwqmvW9sFl98UJNZl4hF8RVZ2T3QbLRaTpBPfILp/1geM0w92I056tuvKgKhZVWDuiopAQDjIzsEYPKBvgE "Ruby – Try It Online")
[Answer]
# C (GCC, MinGW) 138 bytes
Assumes that CR puts the cursor at the start of the current line.
```
d,i,l;f(S,n,p,t)char**S,*p,*t;{for(d=i=0;i<n;d+=l)p=strchr(t=S[i],10),printf("\n%.*s\r"+!!i,l=p?p-t:strlen(t),t),S[i++]+=l+!!p;d&&f(S,n);}
```
Tested with:
```
int main()
{
    char *test1[] = {"aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"};
    char *test2[] = {"12345\n54321","00\n00\n00\n00","001\n011\n012"};
    char *test3[] = {"sm\noo\nmr\nee\nt!\nh_\ni_\nn_\ng_","!@#$%^\n&*()_+\nqwerty\nuiopas","this\nis_a\ntest"};
    
    f(test1, 3);
    f(test2, 3);
    f(test3, 3);
}
```
[Answer]
# [Octave](https://www.gnu.org/software/octave/), ~~71~~ 67 bytes
```
function y=f(x)
for k=1:size(x)
y(1:(t=size(x{k})),1:t(2))=x{k};end
```
Function that takes a vertical cell array of char matrices, and returns a char matrix.
[Try it online!](https://tio.run/##y08uSSxL/f8/rTQvuSQzP0@h0jZNo0KTKy2/SCHb1tCqOLMqFcSv1DC00iixhXCrs2s1NXUMrUo0jDQ1bUFc69S8lP9AzJWSWVygkaZRHa2eCATq1ihUrLVCtHpSEpALJMCcZPVYoFH/AQ) Or [verify all test cases](https://tio.run/##fZBLbsIwEIb3nMKoD9ttF9iBTSJLvQeiVghOsRAxxANtijh7Os5QVdlgyZ/nn6c8oYLy7Pq@PjUV@NCwztTiW07q0LKdUXn0Py7pTqhcgCF52V2lfFM5CC2lSbJwzabHOwEXwSpm2GXJSzy8GD2rgi35eo0SMYiKr64FlWkqUzqbLzBjMc@0oqTZDPUIN7dKShH1f6eMOsU9BkJA7FuEcwiYIrYW4ROahE9L/abvD49PH@h4fhHSvqJx/HItdGicfDiUkdJg62Oqjzb9Kw0cJm98PIha0AZwP2xwcMb/zFtM34llo1j/Cw).
[Answer]
# [Javascript (browser)](https://developer.mozilla.org/en-US/), ~~216~~ ~~208~~  204 bytes
My attempt at this. I'm not happy about the size, and there must certainly be more for improvement, but I'm not that experienced at golfing.
```
var n='\n',x=s=>s.split``.reverse().join``,i,j,f=a=>a.map(s=>s.split(n).map(y=>x(y))).reduce((a,b)=>{for(i=0;i<b.length;i++){j=a[i];if(!j)j=b[i];a[i]=b[i].padStart(j.length,j)}return a}).map(s=>x(s)).join(n)
```
Anyways, what it does is first split all the strings, then reverse all the strings, then whilst looping in a reduce operation [padStart](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart) all the strings together. Then reverse all the strings again and then join them back with newlines. 
Special thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen) for reminding me that the last part in a for loop happens at the end and a total byte savings of 8 bytes.
```
var n='\n',x=s=>s.split``.reverse().join``,i,j,f=a=>a.map(s=>s.split(n).map(y=>x(y))).reduce((a,b)=>{for(i=0;i<b.length;a[i]=b[i++].padStart(j.length,j))if(!(j=a[i]))j=b[i];return a}).map(s=>x(s)).join(n)
console.log(f(["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]));
console.log(f(["12345\n54321","00\n00\n00\n00","001\n011\n012"]));
console.log(f(["sm\noo\nmr\nee\nt!\nh_\ni_\nn_\ng_","!@#$%^\n&*()_+\nqwerty\nuiopas","this\nis_a\ntest"]));
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~51~~ 47 bytes
```
f(char**s){for(;*s;printf("\e[s%s\e[u",*s++));}
```
[Try it online!](https://tio.run/##bU/RCsIwDHzfV4SJ0HZT8bnij6gPtctmcWtHU6cy/Pba@iAIJiHkyOXI6VWndVwYq/tbg7Cj0Bi3vuxhI2BAj/0TggOPg5sQ7spbYzsCsSkmZ5pMUj25/5TYMn1RXgjic@s8k4Lk6I0NLSuPeKAlpX4ra0FVxbl8xbSCQRnL8qB8p2vIAiDSPB1OHOYCoGUZVVsuE/jK2f9Zcvkxoq5IQKPSCOkTsPgI6dYNY8hWXjGqFMVvi@dz8amo3w "C (gcc) – Try It Online")
-4 bytes thanks to ceilingcat.
Uses the CSI sequences for save/restore cursor position. Just iterates over the passed string array (in the same format as `argv`) and prints `<save position>string<restore position>` for each. 
This does leave the cursor at the top left, so when running at the terminal it is important to leave enough newlines afterwards so that the prompt doesn't clobber the input.
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-P`](https://codegolf.meta.stackexchange.com/a/14339/), 7 bytes
Takes input as an array of multi-line strings, outputs a single multi-line string.
```
ú y_¸¬Ì
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVA&code=%2biB5X7iszA&input=WyJzbQpvbwptcgplZQp0IQpoXwppXwpuXwpnXyIsIiFAIyQlXgomKigpXysKcXdlcnR5CnVpb3BhcyIsInRoaXMKaXNfYQp0ZXN0Il0)
```
ú y_¸¬Ì     :Implicit input of array
ú           :Right pad each line of each element with spaces to the length of the longest
  y         :Transpose
   _        :Map
    ¸       :  Split on spaces
     ¬      :  Join
      Ì     :  Last character
            :Implicitly join and output
```
[Answer]
# T-SQL query, ~~297~~ 295 bytes
Using ¶ as separator and a table variable as input.
```
DECLARE @ table(a varchar(max),k int identity(1,1))
INSERT @ values('aaaa¶aaaa¶aaaa¶aaaa'),('bb¶bv¶bb'),('c');
WITH c as(SELECT k,row_number()over(partition
by k order by k)s,value v FROM @ CROSS APPLY
string_split(a,'¶')s),m(i,l,e)as(SELECT*FROM c
WHERE k=1UNION ALL
SELECT k,s,STUFF(e,1,len(v),v)FROM m
JOIN c ON-~i=k and s=l)SELECT
top 1with ties e FROM m
ORDER BY rank()over(partition by l order by-i)
```
**[Try it online](https://data.stackexchange.com/stackoverflow/query/1061453/overlapping-string-blocks)**
[Answer]
# Javascript (browser), ~~129~~ 124 bytes
My first attempt at code golfing. I read the links given in the rules (loopholes, standard rules...), so I hope I did anything wrong!
---
I kept the inputs as they are in the first post (flat array form).
```
_=o=>{o=o.map(i=>i.split`\n`),r=o.shift();for(a of o)for(l in a)b=a[l],r[l]=r[l]?b+r[l].slice(b.length):b;return r.join`\n`}
```
Thanks to **[Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)** for saving 5 bytes.
---
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 18 bytes
```
L.tb0VyQsme #dy #N
```
[Try it online!](http://pythtemp.herokuapp.com/?code=L.tb0VyQsme+%23dy+%23N&test_suite=1&test_suite_input=%5B%5B%2212345%22%2C%2254321%22%5D%2C%5B%2200%22%2C%2200%22%2C%2200%22%2C%2200%22%5D%2C%5B%22001%22%2C%22011%22%2C%22012%22%5D%5D%0A%5B%5B%22aaaa%22%2C%22aaaa%22%2C%22aaaa%22%2C%22aaaa%22%5D%2C%5B%22bb%22%2C%22bb%22%2C%22bb%22%5D%2C%5B%22c%22%5D%5D%0A%5B%5B%27sm%27%2C+%27oo%27%2C+%27mr%27%2C+%27ee%27%2C+%27t%21%27%2C+%27h_%27%2C+%27i_%27%2C+%27n_%27%2C+%27g_%27%5D%2C+%5B%27%21%40%23%24%25%5E%27%2C+%27%26%2a%28%29_%2B%27%2C+%27qwerty%27%2C+%27uiopas%27%5D%2C+%5B%27this%27%2C+%27is+a%27%2C+%27test%27%5D%5D&debug=0) (note: the code itself evaluates only one block, the interpreter's test suite mode runs the program once for each line of input)
Based on [TFeld's Python 2 solution](https://codegolf.stackexchange.com/a/186373/71803).
Explanation:
```
L.tb0         # define a lambda function called y which does a transpose, padding with integer 0's
VyQ           # loop over transposed first input line (Q = eval(input()) ) (loop index = N)
   s          # concatenate array of strings (implicitly printed)
    m         # map over
         y #N # transpose of non-falsy values of N
     e        # for each item: last element of array
       #d     # relevant space at the start! filter with identity function, removes falsy values
```
for an explanation of why the algorithm itself works, see TFeld's answer.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal/wiki/Tutorial), 4 [bytes](https://github.com/somebody1234/Charcoal/wiki/Code-page)
```
ＦθＰι
```
[Try it online (verbose)](https://tio.run/##DYw7DsIwEAV7TpGYj2w@J6BJhWjo6LLBsiILr@SsE3sD4vRmi2me5s0YXB6Ti7XeUtaL2TTNY42Mc0ZijeZaa9@rMgGlBDRlIO@BuAUKFggFEt5WnVXbbXf7F9DhqI09AS1fn/kHtGKaXRGBAxb5FOuk4AvL9Ly3ahjq5RP/) or [try it online (pure)](https://tio.run/##S85ILErOT8z5///9nmXndrzfs@Hczv//o6OVinNj8vLzY/Jyi2LyUlNj8koUY/Iy4mPyMoE4D4jT45V0lBQdlFVU42Ly1LQ0NOO1Y/IKy1OLSipj8koz8wsSi4EKSjIyi4F6iuMTgSakFpcAhUI8FJViYwE).
**Explanation:**
Loop over the input-list of multi-line strings:
```
For(q)
Ｆθ
```
And print the multi-line string without moving the cursor:
```
Multiprint(i);
Ｐι
```
]