[Question]
  [
## Challenge
Calculate the strange sum of two natural numbers (also known as lunar addition):
Given \$A=...a\_2 a\_1 a\_0\$ and \$B=... b\_2 b\_1 b\_0\$ two natural numbers written in the decimal base, the **strange sum** is defined, based on the **maximum** operation, as:
\$A+B=... \max(a\_2,b\_2) \max(a\_1,b\_1) \max(a\_0,b\_0)\$
```
   ...         a2         a1         a0
 + ...         b2         b1         b0
 ----------------------------------------
   ...  max(a2,b2) max(a1,b1) max(a0,b0)
```
## Input
Two natural numbers
All the following is allowed:
* Zero-padded strings (same length)
* Left-space-padded strings
* Right-space-padded strings
* Array of two padded strings
* 2D space-padded char array
## Output
A natural numbers
## Example
```
1999 + 2018 -> 2999
17210 + 701 -> 17711
32 + 17     -> 37
308 + 250   -> 358
308 + 25    -> 328
```
## Rules
* The input and output can be given [in any convenient format](http://meta.codegolf.stackexchange.com/q/2447/42963) (choose the most appropriate format for your language/solution).
* No need to handle **negative** values or **invalid input**
* Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
* If possible, please include a link to an online testing environment so other people can try out your code!
* [Standard loopholes](http://meta.codegolf.stackexchange.com/q/1061/42963) are forbidden.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so all usual golfing rules apply, and the shortest code (in bytes) wins.
  
[Answer]
# [Python 2](https://docs.python.org/2/), 20 bytes
```
lambda*a:map(max,*a)
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSvRKjexQCM3sUJHK1Hzf0FRZl6JQppGZl5BaYmGpg6U1vwfbaijYK6jYKSjAGQYxHJFGwApsBCQNIwFAA "Python 2 – Try It Online")
I/O as 0-pre-padded lists of digits.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 1 byte
```
»
```
[Try it online!](https://tio.run/##y0rNyan8///Q7v///0cb6iiY6ygY6SgAGQax/6MNgBRYCEgaxgIA "Jelly – Try It Online")
I/O as 0-pre-padded lists of digits.
[Answer]
# [R](https://www.r-project.org/), ~~68~~ 65 bytes
```
function(x)apply(outer(x,10^(max(nchar(x)):1-1),`%/%`)%%10,2,max)
```
[Try it online!](https://tio.run/##DclBCoAgEAXQq7QR5sNETquMzhKKJAWlIQZ2emv5eLmFbulbeKIvR4pU4e77fCk9ZctUWfRKl6sU/e5@A7P0ArZqUBZKieaR/0cL5EmMMdyNWiagfQ "R – Try It Online")
Input as integers, output as list of digits.
If zero-padding lists of digits was allowed, then simply `pmax` would suffice.
[Answer]
# [MATL](https://github.com/lmendo/MATL), 2 bytes
```
X>
```
> 
> Choose the most appropriate format for your language/solution
> 
> 
> 
The input format is: 2D char array of two rows, each corresponding to a line, with the shorter number left-padded with spaces. For example
```
17210
  701
```
which in MATL is defined as
```
['17210'; '  701']
```
[Try it online!](https://tio.run/##y00syfn/P8Lu//9odUNzI0MDdWsFdQUFcwND9VgA "MATL – Try It Online")
### Explanation
```
      % Implicit input: 2D char array with two rows 
X>    % Take maximum of (code points of) each column
      % Implicit display
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~73~~ ~~60~~ 56 bytes
```
lambda a,b:map(max,zip(a.rjust(len(b)),b.rjust(len(a))))
```
[Try it online!](https://tio.run/##bczPCsIwDAbwu08R8JAWOmkyRjtBn8RLiw4n@1PmBPXla@dlm/jdku@XhNd47TuO1eEUG9f6swOn/L51QbTuqd51EG433B73UTSXTngplV/MTqbEMNTdCJVAKssSQQGyJosStgBZdoQUTs1mdoZJowJAo2npyBii2eWMaZkcpJPVv4kunLb4dciFXru8sH/cBH8c2/gB "Python 2 – Try It Online")
Takes input as two strings, and returns a list of digits
---
Alternative:
Takes input as two integers; same output
# [Python 2](https://docs.python.org/2/), ~~60~~ 59 bytes
```
lambda*i:map(max,zip(*['%*d'%(len(`max(i)`),v)for v in i]))
```
[Try it online!](https://tio.run/##ZczRCoIwFMbx@57iQIjbmLAzkc2gXqQCFyYNdA4RqV5@LS9M6dx9f34c/xofvZOhOV5Ca7pbbZg9dMaTzjz523rCzmnC6jQh7d2RKlZiaUX5RJt@gAmsA3ulNPjBuhEagmVZAgcpUFPYA2TZCeLJmHeLURIFB1ACVwaVQlxMLmPic17/@e6fEXo2shAbkxf6z0S0NVKHDw "Python 2 – Try It Online")
[Answer]
# Java 10, ~~78~~ 57 bytes
```
a->b->{for(int i=a.length;i-->0;)if(a[i]<b[i])a[i]=b[i];}
```
Input as two space-padded character arrays.
Modifies the first input-array instead of returning a new one to save 21 bytes (thanks to *@OlivierGrégoire*).
[Try it online.](https://tio.run/##bZBBj4IwEIXv/ooJp5JAU9gYJCiJMdnbnjwaD0MFrWIhMLgxxt/OFmiy68ZL8/rea@fLnPGG/vlw6WWJbQtfqPRjBtASkpJwNinvSJW86LQkVWn@acVSnrDZ7b13nU2l2@6aN7aTplDACnr008xPH0XVMKUJ1Ap5mesjnRLl@6lIXFUw3Kn9MjOHO6jVoJJnn8wMU91lpWGyaLdKHeBqcNmWGqWPuz2gO6ADUN4Sc4I4jh0PnFAEC8dN/iZRGIghAohE8Jp9hEMQRP9csRi/mou3PoTzyX/Ofnc3Ao61CRDQA6sgs6TTfmBttoOcqo25rpsG78xOKTjWdXlna5ejlHlNLHut2d723lJ@5VVHvDYTqNRM5992nHlt4Z79Dw)
**Explanation:**
```
a->b->{            // Method with two char-array parameters and String return-type
  for(int i=a.length;i-->0;)
                   //  Loop `i` in the range (length, 0]:
    if(a[i]<b[i])  //   If the `i`'th character in input `a` is smaller than in input `b`:
      a[i]=b[i];}  //    Change the `i`'th character in `a` to the `i`'th character of `b`
```
[Answer]
# [J](http://jsoftware.com/), 14  12 bytes
-2 bytes thanks to Jonah
```
(>./@,:)&.|.
```
[Try it online!](https://tio.run/##ZYy9CoNAEIT7e4ohhT@gmz1F1APFdwlZQpoUtsmzX0ZPK5lmdr6PfUdbJ4EiQGMxy32pQpnJV2LpboLcJslR4Rdgq3PPx@uDBuOeOsAf1TgqryEZHj3jmd3pST25sdFKTsuDtCWzzTnXDkPalWX720FP1lxY/AM "J – Try It Online")
Input and output as list(s) of digits
[Answer]
# Japt, ~~9~~ ~~8~~ 7 bytes
Takes input as an array of digit arrays.
```
mÔÕÔËrw
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=bdTV1Mtydw==&input=WwpbMSw3LDIsMSwwXQpbNywwLDFdCl0KLVE=)
```
m            :Map
 Ô           :  Reverse
  Õ          :Transpose
   Ô         :Reverse
    Ë        :Map
     r       :  Reduce by
      w      :  Maximum
```
---
If taking zero-padded arrays as input is permitted (it would currently fall under a "convenient format" but I suspect that's not the challenger's intent) then this can be 3 bytes.
```
íwV
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=7XdW&input=WzEsNywyLDEsMF0KWzAsMCw3LDAsMV0KLVE=)
```
í       :Interleave the first input
  V     :With the second
 w      :Reduce each pair by maximum
```
[Answer]
# [Haskell](https://www.haskell.org/), 40 bytes
```
a#b=zipWith max(p b++a)$p a++b
p=(' '<$)
```
Input/output as strings, [try it online!](https://tio.run/##LY5BC4IwAIXv@xWPElSWsSmhguvStU4dOkTERkMlnUMXRfTfLavD4/E9vsOr5HDVTTOOcq7Es7aH2lVo5SOwUJTK0LOQlCpiReDDL7xwbGVtID6O3Z1RdliiqY0eIIoCpXabzjht3IB7pXtNMCmNwQtHuVAnFBHuXX8Zpk3A3tze9VsDDxKUYoZvKNSPovUPg8@7cOR5niNmPCM8jTlDyjhJYvCUJCxDvGL/fgM "Haskell – Try It Online")
### Explanation
The function `p` replaces each character by a space, using `p b++a` and `p a++b` are thus the same length. This way we can use `zipWith` without losing any elements, using `max` with it works because a  (space) has lower codepoint than any of the characters `['0'..'9']`.
[Answer]
# [Perl 6](http://perl6.org/), 37 bytes
```
{[R~] roundrobin($_».reverse)».max}
```
[Try it online!](https://tio.run/##RcpBCsIwFEXRrTyKiKKUn4imAdtFOC1FWk1AMI2kKJYQN@bMjcXYibNz4d6Uu@6iGTHXKKOvD68Gzt77s7PdpV/Mjp937tRDuUEtE037DHFoR2Q@r6kJWCGBJZTwGtN@sqYLGbR12DMpJTixolqnEJwRBLFfbDiYmEAF@Jb@rOIX "Perl 6 – Try It Online")
Takes input as a list of lists of digits.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~9 6~~ 5 bytes
-3 thanks to [Emigna](https://codegolf.stackexchange.com/users/47066/emigna)  
-1 thanks to [Shaggy](https://codegolf.stackexchange.com/users/58974/shaggy)
```
íζ€àR
```
Takes input as a list of lists of digits
```
í      # Reverse both inputs
 ζ     # Zip
  €à   # Keep the bigger digits
    R  # Reverse
```
[Try it online!](https://tio.run/##yy9OTMpM/f//8Npz2x41rTm8IOj//@hoQx1LEIzViTbSMdAx1LGIjQUA "05AB1E – Try It Online") or [Try all test cases](https://tio.run/##yy9OTMpM/W/q9v/w2nPbHjWtObwg6L/O/@hoQx1LEIzViTbSMdAx1LGIjeUCiZrrGAF5BkBxc5A4WNRYxwjIB8pBeQZA1SB9pkB1aCKxsQA "05AB1E – Try It Online")
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 15 bytes
```
{[~] [Zmax] $_}
```
[Try it online!](https://tio.run/##RcrRCoIwAIXhVzkMyw1jbIuag9yDJCJWDoqWYV0koq@@Zjfdff/hPNv@vg9@wNqhCGM5VyiPvvlUSOopvJoB/NZdHzRFhpTNBAXI7GhSW8udf1OyGjMe//zc@dN0ISzuCxlc1@MgjTFQQuZ2E0MrKaCFXGKrIPUPIofaiT9t@AI "Perl 6 – Try It Online")
Takes input as a list of space padded arrays of characters, though for this challenge the lax input format makes it rather boring. Alternatively, here's the program that takes a list of two integers instead:
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 41 bytes
```
{+[~] [Zmax] $_>>.fmt("%{.max}d")>>.comb}
```
[Try it online!](https://tio.run/##RYxLCsIwGAav8hHUtlTCn4imAZuDWIrUR0AxRqoLS2muHqMbdzOzmMe5v22iG7CwqONYNqFFs3Pdu8Vsbwy37pWz@chTmU6sSOXo3WGKz24Av/rLPc9QIisCQw0WeNpY32MrtNaQJCqzTKKkICgSX1lJCPUDqiDX9EcTPw "Perl 6 – Try It Online")
If you don't mind a huge amount of whitespace, you can also remove the `+` from the front.
### Explanation:
```
{                                       }  # Anonymous code block
             $_>>    # Map each integer to 
                 .fmt("%{.max}d") # The number padded by the max of the list spaces
                                 >>.comb   # And split each to list of characters
      [Zmax]  # Get the max of each digit at each index
              # This works because space is coerced to 0
              # Otherwise we would have to add a 0 to the formatting string
  [~]   # Join the list of digits and spaces
 +      # And coerce the string to a number to get rid of leading whitespace
```
[Answer]
# JavaScript (ES6), ~~51~~ 49 bytes
*NB: This answer was posted before the loose I/O formats were explicitly allowed. With zero-padded arrays of digits, this can be done in [33 bytes](https://tio.run/##dc7BDoMgDAbg@56CIySdAsYgS2APQjyg08VFwcxlr8/owcNm1h566df@D//2W/@c1tc5xNuQRpO8sZ2xvlj8SmmAiRkbbOem9houOFjqY9jiPBRzvNOROgEau2XUSeAgoGkZI1hlSYjUWp8OQoHMixwNz0ahQ5WFUEqIX1GBxN0M99t74Q9CKnUUHINgphofsW9R1c1fwXO4@ihkkz4), (but is much less interesting, IMHO).*
Takes input as two integers. Returns an integer.
```
f=(a,b,t=10)=>a|b&&(a%t<b%t?b:a)%t+t*f(a/t,b/t)|0
```
[Try it online!](https://tio.run/##bc1BDoIwEAXQvaeYDaTVajslpMWInqVFMBpCjUxccfdaYEec5f8vf17u68bm83zTcQj3NsauZk54QTUqXl/d5POcuYwuPqObPzue0YH2HXOShJfEJxWbMIyhb099eLCOYVVVArRCyzlICaBTsNsYo1EJMApXg8YgbkyhRcpTP9@8A1CYrVE2vSrVohZTlPa/WYdWo238AQ "JavaScript (Node.js) – Try It Online")
### Commented
```
f = (                     // f = recursive function taking:
  a,                      //   a = first integer
  b,                      //   b = second integer
  t = 10                  //   t = 10 (which is used 6 times below)
) =>                      //
  a | b                   // bitwise OR between a and b to test whether at least one of
                          // them still has an integer part
  &&                      // if not, stop recursion; otherwise:
  (                       //
    a % t < b % t ? b : a // if a % 10 is less than b % 10: use b; otherwise: use a
  ) % t +                 // isolate the last decimal digit of the selected number
  t *                     // add 10 times the result of
  f(a / t, b / t)         // a recursive call with a / 10 and b / 10
  | 0                     // bitwise OR with 0 to isolate the integer part
```
### Alternate version
Same I/O format.
```
f=(a,b)=>a|b&&[f(a/10,b/10)]+(a%10<b%10?b:a)%10|0
```
[Try it online!](https://tio.run/##bc3BDoIwDAbgu0/Ri2SLU9YRsmFEH8R46BCIhjAjxhPvPgvciD20Sfvl75O@NFTvx@uz78O9jrEpBSkvyzONPkmujaAUtfLc5G0naIv65Lld/JEkz1HHKvRD6OpDF1rRCCyKQoHR6KSENAUwvNisjDWcCVbjYtBaxJXJjOI936eacgAyuzba8atcz2o2We7@myVoMcbFHw "JavaScript (Node.js) – Try It Online")
[Answer]
# Python 3, 53 bytes
```
s=lambda p,q:p+q and 10*s(p//10,q//10)+max(p%10,q%10)
```
[Answer]
# [Tcl](http://tcl.tk/), 156 bytes
```
proc S a\ b {join [lmap x [split [format %0[set l [expr max([string le $a],[string le $b])]]d $a] ""] y [split [format %0$l\d $b] ""] {expr max($x,$y)}] ""}
```
[Try it online!](https://tio.run/##ZY7NCoMwEITveYqhpFDBQ6IU9Tk8xhziT4slatAUIuKzW2NLKXRP384uM2MrvW1mHCrkUAVKLI@h7SF0pwwcxGR0ayFuw9gpizMTU2OhIRpnRnTKXcRkx7a/QzegSoa/aykDKWsv43SSmP/dqC5q/3fcl68ndSGdg9XL63Y0eVcjPMsyRIynhCcRZ0gYJ3EEPzwhMUt3iK7sQzuSFYt52gki33v4qHV7AQ "Tcl – Try It Online")
Not very golfy, but I had to give a try on it. Will golf it later!
[Answer]
## Batch, 120 bytes
```
@set/aw=1,x=%1,y=%2,z=0
@for /l %%i in (0,1,9)do @set/a"z+=w*((v=y%%10)+(v-=x%%10)*(v>>4)),y/=10,x/=10,w*=10
@echo %z%
```
Takes input as command-line parameters. 188-byte version works on arbitrary length integers:
```
@set/px=
@set/py=
@set z=
:l
@if %x:~-1% gtr %y:~-1% (set z=%x:~-1%%z%)else set z=%y:~-1%%z%
@set x=%x:~,-1%
@set y=%y:~,-1%
@if "%x%" neq "" if "%y%" neq "" goto l
@echo %x%%y%%z%
```
Takes input on STDIN.
[Answer]
# [Twig](https://twig.symfony.com/), 125 bytes
When I saw this challenge, I though: "let me use a template language! sure is a good fit"
I was wrong ... so wrong .... ... But was fun!
```
{%macro a(a,b,s='')%}{%for k,x in a|reverse|split('')%}{%set s=max(x,(b|reverse|split('')[k]))~s%}{%endfor%}{{s}}{%endmacro%}
```
This requires that "strict\_variables" is set to `false` (default value).
To use this macro, you can do like this:
```
{% import 'file.twig' as my_macro %}
{{ my_macro.a(195,67) }}
```
Should display 167.
You can try this in <https://twigfiddle.com/rg0biy>  
("strict\_variables" set to off, it is on by default on the website)
[Answer]
# [Husk](https://github.com/barbuz/Husk), 5 bytes
```
↔¤żY↔
```
Conveniently takes input/output as list of digits, [try it online](https://tio.run/##yygtzv7//1HblENLju6JBNL///@PNtQx1zHSMdQxiP0fba5joGMYCwA "Husk – Try It Online") or [verify all!](https://tio.run/##yygtzv6fq3Foeb52graSgq6dgpKGl5KCtoJSuaZGccqh5YeWPGpqzE8petQ24VHbpHJNzUPb/j9qm3JoydE9kUD6////hpaWlgpGBoYWXIbmRoYGCuYGhlzGRgqG5lzGBhYKRqYGUBoA "Husk – Try It Online")
## Explanation
```
↔¤żY↔  -- example inputs [1,4] [3,2]
 ¤  ↔  -- reverse the arguments of: [4,1] [2,3]
  żY   -- | zipWith (keeping elements of longer) max: [4,3]
↔      -- reverse: [3,4]
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 5 bytes
```
|>E:o
```
[Run and debug it](https://staxlang.xyz/#c=%7C%3EE%3Ao&i=[%221999%22+%222018%22]%0A[%2217210%22+%22701%22]%0A[%2232%22+%2217%22]%0A[%22308%22+%22250%22]%0A[%22308%22+%2225%22]&a=1&m=2)
This program takes input as an array of strings.
```
|>  Right align inputs (filling with \0)
E   "Explode" array onto stack separately
:o  "Overlay" Keep the maximum element respective element from two arrays.
```
[Run this one](https://staxlang.xyz/#c=%7C%3EE%3Ao&i=[%221999%22+%222018%22]%0A[%2217210%22+%22701%22]%0A[%2232%22+%2217%22]%0A[%22308%22+%22250%22]%0A[%22308%22+%2225%22]&a=1&m=2)
This is the first time I've seen a use for the overlay instruction "in the wild".
[Answer]
# [SNOBOL4 (CSNOBOL4)](http://www.snobol4.org/csnobol4/), 153 bytes
```
	X =INPUT
	Y =INPUT
	Y =DUPL(0,SIZE(X) - SIZE(Y)) Y
S	X LEN(1) . A REM . X	:F(O)
	Y LEN(1) . B REM . Y
	O =O GT(A,B) A	:S(S)
	O =O B	:(S)
O	OUTPUT =O
END
```
[Try it online!](https://tio.run/##TY3NCsIwEITPm6fY4y7UUv9AAj0kNEqhJsWkkHj0LPbg@xNTKeJpZr5hmPdrfszPQ84Qse3tOAUB6d910zhQU/n@bigybvDrEjMm4ctoMJa2jDUqvJlr0QjyTI6X8a/Ta5cEOGwdXgKpSjMqkJ48r1SDXIIDN4VyX5Awtst535zE7vgB "SNOBOL4 (CSNOBOL4) – Try It Online")
[Answer]
# Pyth, 5 bytes
```
meSdC
```
Takes input as array of two space-padded strings.
```
meSd       map greatest
    C      on the transpose of input
```
Try it [here](http://pyth.herokuapp.com/?code=meSdC&input=%5B%271999%27%2C%272018%27%5D&test_suite=1&test_suite_input=%5B%271999%27%2C%272018%27%5D%0A%5B%2717210%27%2C%27++701%27%5D%0A%5B%2732%27%2C%2717%27%5D%0A%5B%27308%27%2C%27250%27%5D%0A%5B%27308%27%2C%27+25%27%5D&debug=0).
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 4 bytes
Input is taken as a an array of two 0-padded number arrays.
```
y_rw
```
[Try it online!](https://tio.run/##y0osKPn/vzK@qPz//2iuaEMdcx0jHUMdg1gdrmgDHQMg10DHMJYrlotLNwAA "Japt – Try It Online")
[Answer]
# Ceylon, 55 / 99
With 0- or space-padded strings of same length (returning an iterable of characters):
```
function t(String a,String b)=>zipPairs(a,b).map(max);
```
With 0- or space-padded strings (returning a String):
```
String t(String a,String b)=>String(zipPairs(a,b).map(max));
```
With strings of possibly different length (returning a String):
```
String u(String a,String b)=>String(zipPairs(a.padLeading(b.size),b.padLeading(a.size)).map(max));
```
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/learn/dotnet/what-is-dotnet), 57 bytes
```
a=>b=>a.Select((x,i)=>a[i]>b[i]?x:b[i])
```
*-1 bytes by adding currying*
[Try It Online](https://tio.run/##jY5PSwMxEMXv@RQhpwTWkO2lrtuNh6KiKIg9eBAP2XTUQJpgkpWK9LOviV3EPwjOYYbHG37v6XigfYBxiMY94tVrTLBp0VfFl95a0Ml4F/92@Bk4CEb/@Lg07rlF2qoY8TV@QzhPTCoZjV@8WeMrZRxlk1HmdHB6EVPIjOqbOD9xwwaC6i0s9JMKUkr8kH3c4VF1su@k4isodSjdVoZlfWfuZZ/X8faoHDa26DNnmTt7C/w2mAS5JdB9Dr/wuREhVWFTUjdNQxglM1EfEsZY@38AngjzWS0KQoi5qPeMX5AbUOsPxhSwQ7vxHQ)
[Answer]
# [Ruby](https://www.ruby-lang.org/), 25 bytes
```
->a,b{a.zip(b).map &:max}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y5RJ6k6Ua8qs0AjSVMvN7FAQc0qN7Gi9j9Q3Dba0NzI0EBHwdzAMBYkV12TUqOhpGpgmqKkmqKpl5yRWFQMEtdQsyrJj8/UrOUqUADq00mLBpKxeln5mXl6IIn/AA "Ruby – Try It Online")
Pre-padded list blah blah. (Although it feels a little like cheating.)
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 39 bytes
```
+`^(.*)(.)¶(.*)(.)
$1¶$3¶$2$4
%O`.
¶.?
```
[Try it online!](https://tio.run/##K0otycxL/K@qEZyg8187IU5DT0tTQ0/z0DYog0vF8NA2FWMgNlIx4VL1T9DjOrRNz57r/39DS0tLHSMDQwsuQ3MjQwMdBQVzA0MuYyMdQ3MuYwMLHSNTAzCtYGQKAA "Retina 0.8.2 – Try It Online") Link includes test suite. Previous 45-byte [Retina](https://github.com/m-ender/retina/wiki/The-Language) 1 version accepts unpadded strings:
```
P^`.+
+`^(.*)(.)¶(.*)(.)
$1¶$3¶$2$4
%O`.
¶.?
```
[Try it online!](https://tio.run/##LcYxCoAwDEDRPeeoUDWEJFVqJ4@g4C51cHBxEM/WA/Ri1aHD5/3nfK/7kNLYLWJZ90g99HG31LWW2pzqgJGcjPtTM0CzRIKcaIZSJISAyjKBeBVGzwJOUTw4nlBHrn4 "Retina – Try It Online") Link includes test suite. Explanation:
```
P^`.+
```
Pad both values to the same length. (Retina 1 only. There are ways of emulating this in Retina 0.8.2 but they are not very golfy.)
```
+`^(.*)(.)¶(.*)(.)
$1¶$3¶$2$4
```
Transpose the values.
```
%O`.
```
Sort each pair into order.
```
¶.?
```
Delete all the low digits and surplus newlines.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 8 bytes
```
⭆θ⌈⟦ι§ηκ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRCO4BEil@yYWaBTqKPgmVmTmluZqRGfqKDiWeOalpFZoZOgoZGvGampqWv//b2huZGjApaBgbmD4X7csBwA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
 θ          First input
⭆           Map over characters and join
  ⌈         Maximum of
   ⟦        List of
    ι       Current character of first input and
      η     Second input
     §      Indexed by
       κ    Current index
            Implicitly print
```
10-byte version "adds" any number of padded strings:
```
⭆§θ⁰⌈Ｅθ§λκ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRCO4BEil@yYWaDiWeOalpFZoFOooGGjqKPgmVmTmluZqgKSAQjDZHB2FbE0QsP7/PzqaS8nQ3MjQQEmHS0lBwdzAEMIwNrCAMBSMTJW4YmP/65blAAA "Charcoal – Try It Online") Link is to verbose version of code. Previous 14-byte version accepts unpadded strings:
```
⭆◧θＬη⌈⟦ι§◧ηＬθκ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRCO4BEil@yYWaAQkpvikppVoFOoo@KTmpZdkaGRoauoo@CZWZOaW5mpEZ@ooOJZ45qWkVsCVZsCVFoKUZsdqampa//9vaG5kaMBlbmD4X7csBwA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
  θ             First input
 ◧              Padded to
   Ｌ            Length of
    η           Second input
⭆               Map over characters and join
     ⌈          Maximum of
      ⟦         List of
       ι        Current character of first input and
          η     Second input
         ◧      Padded to
           Ｌ    Length of
            θ   First input
        §       Indexed by
             κ  Current index
                Implicitly print
```
17-byte version "adds" any number of strings:
```
≔⌈ＥθＬιη⭆η⌈Ｅθ§◧ληκ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/9@xuDgzPU/DN7EiM7c0F0gXaBTqKPik5qWXZGhkampq6ihkaFpzBRRl5pVoBJcAqXSQmgwdBTQtjiWeeSmpFRoBiSk@qWklGjkgjToK2ZogYP3/f3Q0l5KhuZGhgZIOl5K5gSGIMjawAFFGpkpcsbH/dctyAA "Charcoal – Try It Online") Link is to verbose version of code.
[Answer]
# [Wren](https://github.com/munificent/wren), 74 bytes
```
Fn.new{|i|(0...i.count/2).map{|j|i[j]>i[j+i.count/2]?i[j]:i[j+i.count/2]}}
```
[Try it online!](https://tio.run/##Ky9KzftfllikkFaal6xgq/DfLU8vL7W8uiazRsNAT08vUy85vzSvRN9IUy83saC6JqsmMzor1g5IaMOlYu1BYlaoYrW1/4Mri0tSc/UKijLzShxzcjRAVuglJwJZ0YY6CuY6CkY6CkCGgQ6XAm5gAFIAUgwkDWM1Nf8DAA "Wren – Try It Online")
Input is a single list of the two operands, e.g.
```
[1, 7, 2, 1, 0,
 0, 0, 7, 0, 1]
```
## Explanation
Now I need to figure out a formula for maximum.
```
Fn.new{|i|                                                               } // New anonymous function with the operand i
          (0...i.count/2)                                                  // Define an exclusive range from 0 to half the input
                         .map{|j|                                       }  // Turn every item of the list into ...
                                 i[j]>i[j+i.count/2]?i[j]:i[j+i.count/2]   // ... The maximum between i[j] and i[j+i.count/2]
                                                                           // (which is simply the other list's index at the same position)
```
[Answer]
# [Perl 5](https://www.perl.org/) `-MList::Util=max -F`, 22 bytes
```
say map{max $_,getc}@F
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVIhN7GgOjexQkElXic9tSS51sHt/38DQwMjLiMDQ@N/@QUlmfl5xf91fU31gKJA2iezuMTKKrQkM8cWqO2/rhsA "Perl 5 – Try It Online")
Input must be 0 or space padded so that the entries are the same length.
[Answer]
# APL(NARS), 51 chars, 102 bytes
```
{k←⌈/≢¨(a b)←⍎¨∘⍕¨⍺⍵⋄f←{((k-≢⍵)⍴0),⍵}⋄10⊥(f a)⌈f b}
```
test:
```
  h←{k←⌈/≢¨(a b)←⍎¨∘⍕¨⍺⍵⋄f←{((k-≢⍵)⍴0),⍵}⋄10⊥(f a)⌈f b}
  1999 h 2018
2999
  17210 h 701
17711
  32 h 17
37
  308 h 250
358
  308 h 25
328
```
]