[Question]
  [
 This was inspired by a function I recently added to my language [Add++](https://github.com/SatansSon/AddPlusPlus). Therefore I will submit an short answer in Add++ but I won't accept it if it wins (it wouldn't be fair)
Don't you hate it when you can multiply numbers but not strings? So you should correct that, right?
You are to write a function or full program that takes two non-empty strings as input and output their multiplied version.
How do you multiply strings? I'll tell you!
To multiply two strings, you take two strings and compare each character. The character with the highest code point is then added to the output. If they are equal, simply add the character to the output.
Strings are not guaranteed to be equal in length. If the lengths are different, the length of the final string is the length of the shortest string. The input will always be lowercase and may contain any character in the printable ASCII range (`0x20 - 0x7E`), excluding uppercase letters.
You may output in any reasonable format, such as string, list etc. Be sensible, integers aren't a sensible way to output in this challenge.
With inputs of `hello,` and `world!`, this is how it works
```
hello,
world!
w > h so "w" is added ("w")
o > e so "o" is added ("wo")
r > l so "r" is added ("wor")
l = l so "l" is added ("worl")
d < o so "o" is added ("worlo")
! < , so "," is added ("worlo,")
```
So the final output for `hello,` and `world!` would be `worlo,`.
# More test cases
(without steps)
```
input1
input2 => output
programming puzzles & code golf!?
not yet graduated, needs a rehaul => prtgyetmirgduuzzlesneedsde rolful
king
object => oing
blended
bold => boln
lab0ur win.
the "super bowl" => the0usuwir.
donald j.
trumfefe! => trumlefj.
```
This is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so shortest code wins! Luok!
  
[Answer]
## Haskell, 11 bytes
```
zipWith max
```
[Try it online!](https://tio.run/##XcxLDgIhEEXRuat4EuPILXRchuOyKT42v0CR2GweGTu/9zhqB4cwp9mGLy8vDpG@M5JP2KDzBUCpPgluMFClZlspRp8sSh8jcMMde9YMm4O5PhVUyoKTBSvUnYT1A4lZNxAqO@pB/aHH0taX3x/eRc0f "Haskell – Try It Online")
Nothing much to explain.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 4 bytes
```
øΣà?
```
Uses the **05AB1E** encoding. [Try it online!](https://tio.run/##MzBNTDJM/f//8I5ziw8vsP//v6AoP70oMTc3My9doaC0qiontVhBTSE5PyVVIT0/J03Rnisvv0ShMrVEAagspTSxJDVFRyEvNTWlWCFRoSg1I7E0BwA "05AB1E – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 16 bytes
```
ñl g îUy ®¬ñ oÃq
```
[Test it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=8WwgZyDuVXkgrqzxIG/DcQ==&input=WyJraW5nIiAib2JqZWN0Il0=) Takes input as an array of two strings.
Lack of min and max built-ins hurt Japt here, but it still manages to pull off a somewhat decent score...
### Explanation
```
 ñl g îUy ®   ¬ ñ oÃ q
Uñl g îUy mZ{Zq ñ o} q
                        // Implicit: U = input array     ["object", "king"]
       Uy               // Transpose the strings of U.   ["ok", "bi", "jn", "eg", "c ", "t "]
          mZ{      }    // Map each string Z to
             Zq ñ o     //   the larger of the two chars. (Literally Z.split().sort().pop())
                        //                               ["o", "i", "n", "g", "c", "t"]
                     q  // Join into a single string.    "oingct"
Uñl g                   // Sort the two input strings by length and take the shorter.
      î                 // Trim the previous result to this length.
                        //            "king"î"oingct" -> "oing"
                        // Implicit: output result of last expression
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
```
żœ-"«
```
[Try it online!](https://tio.run/##NY09EoIwEIV7TrFSSIM/N/AcDkORsAuCS8KEZBgovYKHsNAjWOl4ES8SzYjdm2@/fa8h5tH71/11XsWPq39eNu/Tbe99FkGW1KpzNklhDnkaYGd0ZUTb1qqCzk0TUw9LKDQSVJrLxS48KG1hJAtfE52whCkoIuxBgKGDcDyXHb8twdeyoeK/IJkUEgYuNeNMWcitMzDUah0u9kAQ964jA1IPHM8WaiUYofk5xrUllbRI8ij/AA "Jelly – Try It Online")
### How it works
```
żœ-"«  Main link. Arguemts: s, t (strings)
ż      Zipwith; form all pairs of corresponding characters from s and t.
       If one of the strings is longer than the other, its extra characters are 
       appended to the array of pairs.
    «  Dyadic minimum; get all minima of corresponding characters.
       This yields the characters themselves for unmatched characters.
 œ-"   Zipwith multiset subtraction; remove a single occurrence of the minimum from
       each character pair/singleton.
       This yields the maximum for pairs, but an empty string for singletons.
```
### Example
Let **s = blended** and **t = bold**.
`ż` yields `["bb", "lo", "el", "nd", 'd', 'e', 'd']`. The last three elements are characters.
`«` is the vectorizing, dyadic minimum, so it yields `['b', 'l', 'e', 'd', 'd', 'e', 'd']`.
`œ-"` removes exactly one occurrence of the **n**th character in the second array from the **n**th string/character in the first array, yielding `["b", "o", "l", "n", "", "", ""]`. `œ-` is the *multiset subtraction* atom, and the quick `"` makes it vectorize.
When printed, this simply reads **boln**.
[Answer]
# PHP>=7.1, 52 Bytes
```
for(;$t=min(~$argv[1][$i],~$argv[2][$i++]);)echo~$t;
```
[PHP Sandbox Online](http://sandbox.onlinephpfunctions.com/code/c6373f01fe411441e74865d25e7600b8aef6e259)
# PHP>=7.1, 69 Bytes
```
for([,$a,$b]=$argv;(~$c=$a[$i])&&~$d=$b[$i++];)$r.=max($c,$d);;echo$r;
```
[PHP Sandbox Online](http://sandbox.onlinephpfunctions.com/code/6c981e474956faddb84243a4d5565cfc9dd43b39)
# PHP>=7.1, 70 Bytes
```
for([,$a,$b]=$argv;(~$c=$a[$i])&&~$d=$b[$i++];)$r.=$c>$d?$c:$d;echo$r;
```
[PHP Sandbox Online](http://sandbox.onlinephpfunctions.com/code/458e9e9ea8c8f858dea9b6b8f10c9cfff42e54a3)
[Answer]
## [Alice](https://github.com/m-ender/alice), 8 bytes
```
/oI\
@m+
```
[Try it online!](https://tio.run/##S8zJTE79/18/3zOGyyFX@///pJzUvJTUFK6k/JwUAA "Alice – Try It Online")
### Explanation
Alice also has this operator (which I called *superimpose*) but it doesn't limit the output to the shorter string's length (instead, the remaining characters of the longer string are appended). However, it also has an operator to truncate the longer of two strings to the length of the shorter one.
```
/   Reflect to SE, switch to Ordinal. The IP bounces diagonally up and down
    through the code.
m   Truncate, doesn't really do anything right now.
I   Read a line of input.
    The IP bounces off the bottom right corner and turns around.
I   Read another line of input.
m   Truncate the longer of the two input lines to the length of the shorter.
+   Superimpose: compute their elementwise maximum. 
o   Output the result.
@   Terminate the program.
```
[Answer]
## JavaScript (ES6), ~~47~~ 45 bytes
```
f=
(a,b)=>a.replace(/./g,(c,i)=>c>b[i]?c:[b[i]])
```
```
<div oninput=o.textContent=f(a.value,b.value)><input id=a><input id=b><pre id=o>
```
Conveniently `c>b[i]` returns false past the end of `b`. Edit: Saved 2 bytes thanks to @ETHproductions.
[Answer]
# [Perl 6](http://perl6.org/), 22 bytes
```
{[~] [Zmax] @_».comb}
```
As a bonus, it accepts any number of multiplicands, not just two.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
żḊ€ṁ@»
```
[Try it online!](https://tio.run/##ATQAy/9qZWxsef//xbzhuIrigqzhuYFAwrv///9sYWIwdXIgd2luLv90aGUgInN1cGVyIGJvd2wi "Jelly – Try It Online")
[Answer]
## [Retina](https://github.com/m-ender/retina), 28 bytes
```
{O^`
G`.
^.+$
M!\*`^.
Rm`^.
```
[Try it online!](https://tio.run/##K0otycxL/P@/2j8ugcs9QY8rTk9bhYvLVzFGKyFOjysoF0j@/5@Uk5qXkprClZSfkwIA "Retina – Try It Online")
### Explanation
```
{O^`
```
The `{` tells Retina to run the entire program in a loop until it fails to change the working string. `O` makes this a sorting stage which sorts non-empty lines by default. The `^` option reverses the result. So in effect, we get a reverse sort of the two lines if they're non-empty, putting the line with the larger leading character at the top.
```
G`.
```
Discard empty lines if there are any.
```
^.*$
```
If only one line is left, one of the lines was empty, and we remove the other one as well to stop the process.
```
M!\*`^.
```
Lots of configuration going on here. This matches (`M`) the first character in the working string (`^.`), returns it (`!`), prints it without a trailing linefeed (`\`) and then reverts the working string to its previous value (`*`). In other words, we simply print the first character of the working string (which is the maximal leading character) without actually changing the string.
```
Rm`^.
```
Finally, we remove the first character from each line, so that the next iteration processes the next character.
[Answer]
# C, 58 bytes
```
f(char*s,char*t){putchar(*s>*t?*s:*t);*++s&&*++t&&f(s,t);}
```
[**Try Online**](https://tio.run/##NYxLCsMgGIT3OcVfF0aNvUADzUW6EV8JGA0@KE3I2a0tZBYzwzB88m6lrNUQOYvIEv9HpsdW8q8Slp4sTyw92jiyYUgYN88YG5J4m866@AyrWDyh3dFBkyFo1s4Fjjh6h@jUDdHx4vUv39Px@m0x2CjWdfEWtrLvTifAIIPSYIMzt6khfMjw0RnaURWRteLgtVYJBEQ9i@IavTvrFw)
* -8 bytes @Steadybox
[Answer]
# [Husk](https://github.com/barbuz/Husk), 2 bytes
```
z▲
```
[Try it online!](https://tio.run/##yygtzv7/v@rRtE3///9XSspJzUtJTVECsvJzUpQA "Husk – Try It Online")
### "Ungolfed"/Explained
Makes use of `zip f` that truncates the shorter list such that there are always two arguments for `f`, e.g. `zip f [1,2] [3,4,5] == zip f [1,2] [3,4] == [f 1 3, f 2 4]`:
```
z   -- zip the implicit lists A,B with  - e.g. "ab" "bcd" (lists of characters)
 ▲  -- maximum                          -      [max 'a' 'b', max 'b' 'c']
    -- implicitly print the result      -      "bc"
```
[Answer]
## Mathematica, 78 bytes
```
FromCharacterCode[Max/@Thread[#~Take~Min[Length/@x]&/@(x=ToCharacterCode@#)]]&
```
There is another answer in *Mathematica* already. This answer take input as a list of strings, so `/@` can be used on `#` instead of `{##}`. And we can just `Map` the long function name on object instead of assigning it to variables. (in fact, each Mathematica built-in symbol name is used at most once in the function)
[Answer]
# [Python 2](https://docs.python.org/2/), ~~47~~ ~~44~~ 34 bytes
*-3 bytes thanks to musicman523. -10 bytes thanks to Blender.*
Takes input as a list of strings.
```
lambda a:''.join(map(max,zip(*a)))
```
[Try it online!](https://tio.run/##TZDRasMwDEXf8xVqH@ZkhDL2WCj7kK4MOZYTZ4plHJus@fksWccygUD43HuFFe6pE/@62Mv7wjhog4BnpU69OF8OGNb@qmcXymesqmpJNKaPBkca4QLXAta6qo6YpVY1qEkim4O61b/E@ZDTBh7D33uI0kYcBudbCHmeec17gkYMQStsD2@bx0uCOyVYlSZjIlODJzIjIETqMPOe97kGbRbRPTX/9mgmb8hsSAubHTDqlxxhcv60wdQRHMccKIKWiY@70IhHNtA/ZDEPliytPyxuRWElggPnYb/K@ccWovMJbOmq5Rs "Python 2 – Try It Online")
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~28, 24~~, 21 bytes
```
Í./&ò
dd{JdêHPÎúúx
Íî
```
[Try it online!](https://tio.run/##K/v//3Cvnr7a4U1cKSnVXimHV3kEHO47vOvwrgquw72H1/3/n5Gak5NfBQRc5flFOSn2AA "V – Try It Online")
Hexdump:
```
00000000: cd2e 2f26 f20a 6464 7b4a 64ea 4850 cefa  ../&..dd{Jd.HP..
00000010: fa78 0acd ee                             .x...
```
*Three bytes saved thanks to @nmjcman101!*
Explanation:
```
Í             " Globally substitute:
 .            "   Any character
  /           " With:
   &          "   That character
    ò         "   And a newline
dd            " Delete this line
  {           " Move to the first empty line
   J          " Delete this line
    dê        " Columnwise delete the second word
      HP      " Move to the first line, and paste the column we just deleted
        Î     " On every line:
         úú   "   Sort the line by ASCII value
           x  "   And delete the first character
Í             " Remove all:
 î            "   Newlines
```
[Answer]
# Javascript (ES2015), 66 63 49 bytes
```
a=>b=>[...a].map((c,i)=>c>b[i]?c:b[i]||'').join``
```
**Explanation:**
```
a=>b=>                       // Function with two string parameters
  [...a]                     // Split a into array of characters
    .map((c, i) =>           // Iterate over array
      c>b[i] ? c : b[i]||'') //   Use the character with the larger unicode value until the end of the larger string
    .join``                  // Join the array into a string
```
**Previous Versions:**
```
//ES2015
a=>b=>[...a].map((c,i)=>c>b[i]?c:b[i]).slice(0,b.length).join``    //63
a=>b=>a.split``.map((c,i)=>c>b[i]?c:b[i]).slice(0,b.length).join`` //66
a=>b=>a.split``.map((c,i)=>c>b[i]?c:b[i]).slice(0,Math.min(a.length,b.length)).join``   //85
a=>b=>{for(i=-1,c='';++i<Math.min(a.length,b.length);)c+=a[i]>b[i]?a[i]:b[i];return c}  //86
a=>b=>{for(i=-1,c='';++i<Math.min(a.length,b.length);)c+=a[d='charCodeAt'](i)>b[d](i)?a[i]:b[i];return c}   //105
a=>b=>a.split``.map((c,i)=>c[d='charCodeAt']()>b[d](i)?c:b[i]).slice(0,Math.min(a.length,b.length)).join``  //106
//With array comprehensions
a=>b=>[for(i of a.split``.map((c,i)=>c>b[i]?c:b[i]))i].slice(0,b.length).join``                             //79
a=>b=>[for(i of a.split``.map((c,i)=>c>b[i]?c:b[i]))i].slice(0,Math.min(a.length,b.length)).join``          //98
a=>b=>[for(i of ' '.repeat(Math.min(a.length,b.length)).split``.map((_,i)=>a[i]>b[i]?a[i]:b[i]))i].join``   //105
a=>b=>[for(i of Array.apply(0,Array(Math.min(a.length,b.length))).map((_,i)=>a[i]>b[i]?a[i]:b[i]))i].join`` //107
a=>b=>[for(i of a.split``.map((c,i)=>c[d='charCodeAt']()>b[d](i)?c:b[i]))i].slice(0,Math.min(a.length,b.length)).join``        //119
a=>b=>[for(i of ' '.repeat(Math.min(a.length,b.length)).split``.map((_,i)=>a[d='charCodeAt'](i)>b[d](i)?a[i]:b[i]))i].join``   //124
a=>b=>[for(i of Array.apply(0,Array(Math.min(a.length,b.length))).map((_,i)=>a[d='charCodeAt'](i)>b[d](i)?a[i]:b[i]))i].join`` //127
```
[Answer]
# Java 8, ~~124~~ ~~120~~ ~~117~~ 63 bytes
```
a->b->{for(int i=0;;i++)System.out.print(a[i]>b[i]?a[i]:b[i]);}
```
-4 bytes thanks to *@Khaled.K*.  
-3 bytes thanks to *@Jakob*.
Inputs are two character-arrays, and it stops with an `ArrayIndexOutOfBoundsException`.
**Explanation:**
[Try it here.](https://tio.run/##bVLBbtswDL3nK1gdVht2jJ6b1cVQbNhlpx52SHKgLDpRKkuCTLVLg3x7JsceNhe7CE96jxQfyQO@4tJ5sgf1cmkM9j38QG1PC4CekXUDh6SoImtTtdE2rJ2tvk3gc7PHsN6W/9M8OdvHjsKkqWto4QEuuKzlsj61LmTaMuiHu9VKF0X@fOyZuspFrnxITIZrva1lOh4HdD@gfHW@rBapMh@lSZVNBb46raBLRWfPnEJ36y1gPhgAYOo5E9/JGFeKEsRPF4y6EfnqH1ZbH3kgRzDjfHC7gF2XsqZP398N9fAJGqcIds60N49DnHUMR2JIShWRSZVgiVQPCIH2GM0850tKNoQ5eaCGYU5KQ1aRGnjpjJqTBuVdDPCmbTUIeE@wEX30FEC6N7MRc7lyFo2CwygOsWuppcn8efF3wNf@XUPG/gGWMCH5p4/hOAKAtkLvzTHDit1TGu2XEPCY5XmFTUOeM/nhfazo3CA3@@zrr0GT1gMoP00jpxDGkRub3YrbAguxEYBWJXOikNdbz857Usk67xMFKcaFexAFpZ24fvBxf1Kyyej58hs)
```
a->b->{                       // Method with two char-array parameters and no return-type
  for(int i=0;;i++)           //  Loop `i` from 0 up indefinitely (until an error is given)
    System.out.print(         //   Print:
      a[i]>b[i]?a[i]:b[i]);}  //    The character that has the highest unicode value
```
[Answer]
# C#, 81 78 bytes
```
a=>b=>{var s="";try{for(int q=0;;q++)s+=a[q]>b[q]?a[q]:b[q];}catch{}return s;}
```
C# has implicit `char` to `int` conversion (because a `char` is actually an `int` underneath) which is nice, and instead of looking for shortest string just try until failure
[Answer]
# [MATL](https://github.com/lmendo/MATL), 8 bytes
```
otX>cwA)
```
Input is a cell array of strings, in the format `{'abcd' 'efg'}`
[Try it online!](https://tio.run/##y00syfn/P78kwi653FHz//9q9aSc1LyU1BR1BfWk/JwU9VoA "MATL – Try It Online")
As an aside, this also works [for more than two strings](https://tio.run/##y00syfn/P78kwi653FHz//9q9aSc1LyU1BR1BfWk/BwQlZiUXJeSmqZeCwA).
### Explanation
Consider input `{'blended' 'bold'}`. The stack is shown upside down, with more recent elements below.
```
o    % Implicitly input a cell array of strongs. Convert to numeric
     % vector of code points. This right-pads with zeros if needed
     %   STACK: [98 108 101 110 100 101 100;
                 98 111 108 100   0   0   0]
tX>  % Duplicate. Maximum of each column
     %   STACK: [98 108 101 110 100 101 100;
                 98 111 108 100   0   0   0],
                [98 111 108 110 100 101 100]
c    % Convert to char
     %   STACK: [98 108 101 110 100 101 100;
                 98 111 108 100   0   0   0],
                'bolnded'
w    % Swap
     %   STACK: 'bolnded'
                [98 108 101 110 100 101 100;
                 98 111 108 100   0   0   0]
A    % All: gives true (shown as 1) for columns containing only nonzeros
     %   STACK: 'bolnded'
                [1 1 1 1 0 0 0]
)    % Use as logical index (mask). Implicitly display
     %   STACK: 'boln'
```
[Answer]
## R, 103 bytes
Code:
```
n=min(sapply(y<-strsplit(scan(,"",sep="\n"),""),length));cat(mapply(max,el(y)[1:n],y[[2]][1:n]),sep="")
```
Test cases:
```
> n=min(sapply(y<-strsplit(scan(,"",sep="\n"),""),length));cat(mapply(max,el(y)[1:n],y[[2]][1:n]),sep="")
1: programming puzzles & code golf!?
2: not yet graduated, needs a rehaul
3: 
Read 2 items
prtgretmirgduuzzlesneedsde rolful
> x <- scan(,"",sep=NULL)
1: asd asd 
3: 
Read 2 items
> n=min(sapply(y<-strsplit(scan(,"",sep="\n"),""),length));cat(mapply(max,el(y)[1:n],y[[2]][1:n]),sep="")
1: king
2: object
3: 
Read 2 items
oing
> n=min(sapply(y<-strsplit(scan(,"",sep="\n"),""),length));cat(mapply(max,el(y)[1:n],y[[2]][1:n]),sep="")
1: lab0ur win.
2: the "super bowl"
3: 
Read 2 items
the0usuwir.
```
[Answer]
# Kotlin, ~~50~~ ~~41~~ 37 bytes
-9 bytes with function reference syntax
-4 bytes with extension function
```
fun String.x(o:String)=zip(o,::maxOf)
```
If s, and x are in scope, and not in a function, this method is only 16 bytes
```
s.zip(x,::maxOf)
```
[Demo](https://try.kotlinlang.org/#/UserProjects/nubfa8m87ehb35729vbh64f439/jnj1je8dmgim992ti2c5dtakr4)
[Answer]
# Excel, 86 bytes
```
=LET(x,SEQUENCE(MIN(LEN(A1),LEN(A2))),d,MID(A1,x,1),e,MID(A2,x,1),CONCAT(IF(d>e,d,e)))
```
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 12 bytes
```
q~z{1/~e>o}%
```
Input is a list of two strings. The program exits with an error (after producing the right output) if the two strings have different lengths.
[**Try it online!**](https://tio.run/##S85KzP3/v7CuqtpQvy7VLr9W9f//aKXszLx0JQWl/KSs1OQSpVgA "CJam – Try It Online")
### Explanation
```
q~              e# Read input and evaluate
  z             e# Zip: list of strings of length 2, or 1 if one string is shorter
   {      }%    e# Map this block over list
    1/          e# Split the string into array of (1 or 2) chars
      ~         e# Dump the chars onto the stack
       e>       e# Maximum of two chars. Error if there is only one char
         o      e# Output immediately, in case the program will error
```
[Answer]
## Clojure, 31 bytes
```
#(map(comp last sort list)% %2)
```
Yay for function composition :) Returns a sequence of characters instead of a string, but they mostly work the same way in Clojure except when printing or regex matching.
Sadly `max` does not work with characters.
[Answer]
# JavaScript (ES6), 47 bytes
```
f=([S,...s],[T,...t])=>S&&T?(S>T?S:T)+f(s,t):''
```
A recursive solution, which walks the string, always outputting the largest character.
**Snippet:**
```
f=([S,...s],[T,...t])=>S&&T?(S>T?S:T)+f(s,t):''
console.log(f('programming puzzles & code golf!?','not yet graduated, needs a rehaul'));
console.log(f('king','object'));
console.log(f('blended','bold'));
console.log(f('lab0ur win.','the "super bowl"'));
console.log(f('donald j.','trumfefe!'));
```
[Answer]
# [Julia 0.5](http://julialang.org/), 33 bytes
Pretty much the same concept as Python2, but shorter.
```
a->join(map(maximum,(zip(a...))))
```
[Try it online!](https://tio.run/##ZZDBasMwDIbveQo1hzWBNOyyY9cHGWMosdw4ky3j2GTLe@@cOSujbBEIBP/3/xIaExt8WvV5xdPzKMZVFn3uD2OTbarF@Arbtq1zrZGm@NbjRBOc4aWAe1XlQMzSlA2UswRWh7Ju/gLG@RQ3/Tb8l32Qa0BrjbuCT8vCeckD9KIIrsL6cNmsTiJ8UoRMqoSRVAOOSE2AEGjAxLvY95y3OaUbqd9v7ZicIrURnbDa6YzdYwowG9duTBwIjlPyFKCTmY87XolDVjDe6JCsJk35F7/Ua1FoCWDAOLh/80f1wbhY6crUdZGPWr@cnHrsB/oG "Julia 0.5 – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~55~~ 36 bytes
```
^
¶
{O`¶.*
}`¶.(.*)¶(.)
$2¶$1¶
1!`.*
```
[Try it online!](https://tio.run/##K0otycxL/P8/juvQNq5q/4RD2/S0uGpBlIaeluahbRp6mlwqRoe2qRgC5Q0VE/S0/v/PzsxL58pPykpNLgEA "Retina – Try It Online") Explanation: A line is prefixed to hold the result. While both strings still have characters left the inputs are sorted and the leading character with the highest code point is moved to the result while the other leading character is deleted. Finally the result is printed.
[Answer]
# J, 25 bytes
```
>./&.(a.&i.)@(<.&#{."1,:)
```
# explanation
half the bytes go to solving ensuring both inputs have the shorter inputs length (would love to see an improvement on this portion, if anyone has one):
```
(<.&#{."1,:)
```
`<.&#` is the minimum of the two lengths, and `{."1,:` takes that many characters from both rows of the 2-row table consisting of the left string stacked on top of the right one.
```
>./&.(a.&i.)
```
Use the Under verb `&.` to convert each character to its ascii index, take the maximum of the two numbers, and then convert back to characters.
[Try it online!](https://tio.run/##LctBCoMwFATQvaf4REgUytduS1tKD9A7GPPV2JCUaMjCw6dB3Q0zb@aUhgfCExuOVYdcY/2q7sjLDdn1cqsL6icH4qvtKGAA4eRM/Srg80ZwuTx3acgqUjuRzqgD5GRPYDrZBg9RW9zROhGwJfzIZxUNOw65bcMSovZYpPQH "J – Try It Online")
[Answer]
# [Add++](https://github.com/SatansSon/AddPlusPlus), 8 bytes
```
D,f,@@,^
```
[Try it online!](https://tio.run/##S0xJKSj4/99FJ03HwUEn7r9Kmo69jj2XO5f///9KHqk5Ofk6Sv@VwvOLclIUlf7lF5Rk5ucV/9fVLUstKgYybQ30TAA "Add++ – Try It Online")
In versions 0.4 through 1.11, `^` exponents two numbers or "multiplies" two strings, depending on the type of the arguments.
[Answer]
# [Python 3](https://docs.python.org/3/), 29 bytes
```
lambda*a:''.join(map(max,*a))
```
[Try it online!](https://tio.run/##TZDBasMwEETv/opNDrVjTCj0Fgj5kDSUlbWy5a61QpZwk5935abUFQjEvplZNP4ee3Fvizm/L4yj0ljjqSyPg1hXjejz/WpqPByWSFP8aHGiCc5wLSCfa9kTszRlA@UsgfWuvDW/xDqf4gqej7@5D9IFHEfrOvDp8eCc9wKtaIJO2Owuq8dJhDtFyEqdMJJuwBHpCRAC9Zh4y/vMQatF1EDtvz2KyWnSK1LCegOM6jUFmK07rjD2BPspeQqgZOb9JtTikDUMT1lIoyFD@YfFrSiMBLBgHWytnH5sPlgXK1PVNlf2DQ "Python 3 – Try It Online")
---
# [Coconut](http://coconut-lang.org/), 17 bytes
```
''.join<..map$max
```
[Try it online!](https://tio.run/##TZBdTsMwEITfc4pthTCgKOIALRykVMixN4nTtdfyjwIVdw@2ikj9Ymu/mVl5FCt2Oa3D8WMVopvZuEPXWekfrPxaE8b0qWTECEc4NVDOSUxIxK1oQSwcSO/Euf0jxvmcKrg9/uc@8BiktcaN4PP1SiXvERRrhJFp2L1Xj@ME35igKHWWCXULDlFHkBBwkpm2vEsJqhbuZ1R3e3pCp1FX1DPpDZDsX3OAxbiuwjQh7GP2GKDnhfabULOTpGG@yUK2Aw5Yfticm@aujJ83qBU9@WBcglIYDHB4KReZmJ4rLq3GbHH9BQ "Coconut – Try It Online")
]