挑战

计算两个自然数的奇数和（也称为月球加法）：

给定A=... a2 a1 a0和B=... b2 b1 b0两个以十进制为基础的自然数，根据最大运算将奇数和定义为： A+B=... max(a2,b2) max(a1,b1) max(a0,b0)

   ...         a2         a1         a0
 + ...         b2         b1         b0
 ----------------------------------------
   ...  max(a2,b2) max(a1,b1) max(a0,b0)

输入项

两个自然数

允许以下所有内容：

• 零填充字符串（相同长度）
• 左空格填充的字符串
• 右空格填充的字符串
• 两个填充字符串的数组
• 2D空格填充的char数组

输出量

自然数

例

1999+2018-->2999
17210+701-->17711
32+17-->37
308+250-->358
308+25-->328

规则

• 输入和输出可以任何方便的格式给出（为您的语言/解决方案选择最合适的格式）。
• 无需处理负值或无效输入
• 完整的程序或功能都是可以接受的。如果是函数，则可以返回输出而不是打印输出。
• 如果可能，请提供一个在线测试环境的链接，以便其他人可以尝试您的代码！
• 禁止出现标准漏洞。
• 这是代码高尔夫球，因此所有常用的高尔夫规则都适用，并且最短的代码（以字节为单位）获胜。

Python 2，20个字节

lambda*a:map(max,*a)

在线尝试！

I / O为0预先填充的数字列表。

果冻，1字节

»

在线尝试！

I / O为0预先填充的数字列表。

R，68 65字节

function(x)apply(outer(x,10^(max(nchar(x)):1-1),`%/%`)%%10,2,max)

在线尝试！

输入为整数，输出为数字列表。

如果允许零填充数字列表，那么pmax就足够了。

MATL，2个字节

X>

选择最适合您的语言/解决方案的格式

输入格式为：两行的2D char数组，每行对应于一行，较短的数字用空格填充。例如

17210
  701

在MATL中定义为

['17210'; '  701']

在线尝试！

说明

      % Implicit input: 2D char array with two rows 
X>    % Take maximum of (code points of) each column
      % Implicit display

Python 2中，73个 60 56字节

lambda a,b:map(max,zip(a.rjust(len(b)),b.rjust(len(a))))

在线尝试！

将输入作为两个字符串，并返回一个数字列表

选择：

将输入作为两个整数；相同的输出

Python 2中，60 59个字节

lambda*i:map(max,zip(*['%*d'%(len(`max(i)`),v)for v in i]))

在线尝试！

Java 10，78 57字节

a->b->{for(int i=a.length;i-->0;)if(a[i]<b[i])a[i]=b[i];}

输入为两个带空格的字符数组。

修改第一个输入数组，而不是返回一个新的数组以节省21个字节（感谢@OlivierGrégoire）。

在线尝试。

说明：

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`

J，14 12字节

-2字节感谢乔纳

(>./@,:)&.|.

在线尝试！

输入和输出为数字列表

Japt，9 8 7字节

将输入作为数字数组的数组。

mÔÕÔËrw

尝试一下

m            :Map
 Ô           :  Reverse
  Õ          :Transpose
   Ô         :Reverse
    Ë        :Map
     r       :  Reduce by
      w      :  Maximum

如果允许使用填充零的数组作为输入（当前它属于“便捷格式”，但我怀疑这不是挑战者的意图），则可以为3个字节。

íwV

尝试一下

í       :Interleave the first input
  V     :With the second
 w      :Reduce each pair by maximum

Perl 6、37个字节

{[R~] roundrobin($_».reverse)».max}

在线尝试！

将输入作为数字列表。

05AB1E，9 6 5字节

-3感谢Emigna
-1感谢Shaggy

íζ€àR

将输入作为数字列表

í      # Reverse both inputs
 ζ     # Zip
  ۈ   # Keep the bigger digits
    R  # Reverse

在线尝试！或尝试所有测试用例

Perl 6、15个字节

{[~] [Zmax] $_}

在线尝试！

将输入作为由空格填充的字符数组的列表，尽管对于此挑战，松散的输入格式使其相当无聊。另外，下面是使用两个整数列表的程序：

Perl 6，41个字节

{+[~] [Zmax] $_>>.fmt("%{.max}d")>>.comb}

在线尝试！

如果您不介意使用大量空格，也可以+从前面删除。

说明：

{                                       }  # 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

Haskell，40个字节

a#b=zipWith max(p b++a)$p a++b
p=(' '<$)

输入/输出为字符串，在线尝试！

说明

该函数p使用p b++a并p a++b用相同的长度将每个字符替换为一个空格。这样，我们可以使用zipWith而不会丢失任何元素，可以max使用它，因为（空格）的代码点低于任何字符['0'..'9']。

JavaScript（ES6），51 49字节

注意：此答案是在明确允许使用宽松的I / O格式之前发布的。使用零填充数字数组，可以用33个字节完成此操作（恕我直言，这没那么有趣了）。

将输入作为两个整数。返回一个整数。

f=(a,b,t=10)=>a|b&&(a%t<b%t?b:a)%t+t*f(a/t,b/t)|0

在线尝试！

已评论

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

替代版本

相同的I / O格式。

f=(a,b)=>a|b&&[f(a/10,b/10)]+(a%10<b%10?b:a)%10|0

在线尝试！

Tcl，156字节

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

在线尝试！

不太打高尔夫球，但我不得不尝试一下。以后再打高尔夫球吧！

批处理，120字节

@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%

将输入作为命令行参数。188字节版本适用于任意长度的整数：

@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%

在STDIN上输入。

小枝，125字节

当我看到这个挑战时，我虽然说：“让我使用模板语言！当然很合适”

我错了...错了.....但是很有趣！

{%macro a(a,b,s='')%}{%for k,x in a|reverse|split('')%}{%set s=max(x,(b|reverse|split('')[k]))~s%}{%endfor%}{{s}}{%endmacro%}

这要求将“ strict_variables”设置为false（默认值）。

要使用此宏，可以执行以下操作：

{% import 'file.twig' as my_macro %}

{{ my_macro.a(195,67) }}

应显示167。

您可以在https://twigfiddle.com/rg0biy中尝试一下
（“ strict_variables”设置为off，默认情况下在网站上处于启用状态）

外壳，5个字节

↔¤żY↔

方便地将输入/输出作为数字列表，在线尝试或验证所有功能！

说明

↔¤ż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]

Stax，5个字节

|>E:o

运行并调试

该程序将输入作为字符串数组。

|>  Right align inputs (filling with \0)
E   "Explode" array onto stack separately
:o  "Overlay" Keep the maximum element respective element from two arrays.

运行这个

这是我第一次看到“在野外”使用叠加指令。

SNOBOL4（CSNOBOL4），153个字节

	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

在线尝试！

Pyth，5个字节

meSdC

将输入作为两个空格字符串的数组。

meSd       map greatest
    C      on the transpose of input

在这里尝试。

Japt，4个字节

输入被当作两个零填充数字数组的数组。

y_rw

在线尝试！

锡兰，55/99

使用长度为0或带空格的字符串（返回一个可迭代的字符）：

function t(String a,String b)=>zipPairs(a,b).map(max);

使用0或空格填充的字符串（返回字符串）：

String t(String a,String b)=>String(zipPairs(a,b).map(max));

对于长度可能不同的字符串（返回字符串）：

String u(String a,String b)=>String(zipPairs(a.padLeading(b.size),b.padLeading(a.size)).map(max));

C＃（.NET Core），57字节

a=>b=>a.Select((x,i)=>a[i]>b[i]?x:b[i])

-1字节，通过添加currying

在线试用

Ruby，25个字节

->a,b{a.zip(b).map &:max}

在线尝试！

预先填充的列表等等。（尽管感觉有点像作弊。）

视网膜0.8.2，39字节

+`^(.*)(.)¶(.*)(.)
$1¶$3¶$2$4
%O`.
¶.?

在线尝试！链接包括测试套件。先前的45字节Retina 1版本接受未填充的字符串：

P^`.+
+`^(.*)(.)¶(.*)(.)
$1¶$3¶$2$4
%O`.
¶.?

在线尝试！链接包括测试套件。说明：

P^`.+

将两个值填充到相同的长度。（仅适用于Retina1。在Retina 0.8.2中有许多方法可以模拟这一点，但它们并不是很容易打高尔夫。）

+`^(.*)(.)¶(.*)(.)
$1¶$3¶$2$4

转置值。

%O`.

将每对按顺序排序。

¶.?

删除所有低位数字和多余的换行符。

木炭，8字节

⭆θ⌈⟦ι§ηκ

在线尝试！链接是详细版本的代码。说明：

 θ          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字节版本“添加”任意数量的填充字符串：

⭆§θ⁰⌈Ｅθ§λκ

在线尝试！链接是详细版本的代码。先前的14字节版本接受未填充的字符串：

⭆◧θＬη⌈⟦ι§◧ηＬθκ

在线尝试！链接是详细版本的代码。说明：

  θ             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字节版本“添加”任意数量的字符串：

≔⌈ＥθＬιη⭆η⌈Ｅθ§◧ληκ

在线尝试！链接是详细版本的代码。

Mathematica 50字节

a = 543; b = 791；

FromDigits@MapThread[Max, IntegerDigits /@ {a, b}]

（* 793 *）