许多编程语言都提供了用于操作整数的二进制（以2为基数）的运算符。这是将这些运算符推广到其他基础的一种方法：

令x和y为基数B中的一位数字。定义一元运算符~和二元运算&，|以及^这样的：

• 〜x =（B-1）-x
• x＆y = min（x，y）
• x | y =最大值（x，y）
• x ^ y =（x＆〜y）| （y＆〜x）

注意，如果B = 2，我们将得到熟悉的按位NOT，AND，OR和XOR运算符。

对于B = 10，我们得到“十进制XOR”表：

^ │ 0 1 2 3 4 5 6 7 8 9
──┼────────────────────
0 │ 0 1 2 3 4 5 6 7 8 9
1 │ 1 1 2 3 4 5 6 7 8 8
2 │ 2 2 2 3 4 5 6 7 7 7
3 │ 3 3 3 3 4 5 6 6 6 6
4 │ 4 4 4 4 4 5 5 5 5 5
5 │ 5 5 5 5 5 4 4 4 4 4
6 │ 6 6 6 6 5 4 3 3 3 3
7 │ 7 7 7 6 5 4 3 2 2 2
8 │ 8 8 7 6 5 4 3 2 1 1
9 │ 9 8 7 6 5 4 3 2 1 0

对于多位数字，请逐位应用一位数字运算符。例如，12345 ^ 24680 = 24655，因为：

• 1 ^ 2 = 2
• 2 ^ 4 = 4
• 3 ^ 6 = 6
• 4 ^ 8 = 5
• 5 ^ 0 = 5

如果操作数的长度不同，则用前导零填充较短的一。

挑战

以尽可能少的字节编写一个程序或函数，该程序或函数将两个整数（可以假定为介于0和999 999 999之间（含0和999之间））作为输入，并输出上述两个数字的“十进制XOR”。

测试用例

• 12345，24680→24655
• 12345，6789→16654
• 2019，5779→5770
• 0，999999999→999999999
• 0，0→0

果冻，14字节

DUz0«9_ṚƊṀƊ€UḌ

在线尝试！

所有一位数字对的网格

以两个整数列表为参数并返回一个整数的单子链接。

说明

D               | Decimal digits
 U              | Reverse order of each set of digits
  z0            | Transpose with 0 as filler
          Ɗ€    | For each pair of digits, do the following as a monad:
    «   Ɗ       | - Minimum of the two digits and the following as a monad (vectorises):
     9_         |   - 9 minus the digits
       Ṛ        |   - Reverse the order
         Ṁ      | - Maximum
            U   | Reverse the order of the answer to restore the orignal order of digits
             Ḍ  | Convert back from decimal digits to integer

如果数字矩阵是可接受的输入/输出：

果冻，12字节

Uz0«9_ṚƊṀƊ€U

在线尝试！

Pyth，31个字节

LhS,hb-9ebjkmeS,ydy_d_.t_MjRTQ0

在线尝试！

LhS,hb-9eb             # Helper function, computes the (x & ~y) part
L                      # y = lambda b:
  S                    #               sorted(                )  
   ,                   #                       [    ,        ]
    hb                 #                        b[0]
      -9eb             #                              9-b[-1]
 h                     #                                       [0] # sorted(...)[0] = minimum

jkmeS,ydy_d_.t_MjRTQ0  # Main program (example input Q: [123, 45])
                jRTQ   # convert each input to a list of digits -> [[1,2,3],[4,5]]
              _M       # reverse each -> [[3,2,1],[5,4]]
            .t      0  # transpose, padding right with 0 -> [[3,5],[2,4],[1,0]]
           _           # reverse -> [[1,0],[2,4],[3,5]]
  m                    # map that over lambda d:
    S,                 #   sorted([    ,           ])
      yd               #           y(d)
        y_d            #                 y(d[::-1])         # reversed
   e                   #                             [-1]   # sorted(...)[-1] = maximum
jk                     # ''.join( ^^^ )

Python 2，71个字节

f=lambda n,m,T=10:n+m and max(min(n%T,~m%T),min(m%T,~n%T))+f(n/T,m/T)*T

在线尝试！

第四（gforth），111字节

: m 10 /mod rot ;
: t 9 swap - min ;
: f 2dup + 0> if m m recurse 10 * -rot 2dup swap t -rot t max + 1 then * ;

在线尝试！

代码说明

: m          \ start a new word definition
  10 /mod    \ get quotient and remainder of dividing by 10
  rot        \ move item in 3rd stack position to top of stack
;            \ end word definition

\ word implementing "not" followed by "and"
: t          \ start a new word definition
  9 swap -   \ subtract top stack element from 9
  min        \ get the minimum of the top two stack elements
;            \ end word definition

: f          \ start a new word definition
  2dup +     \ duplicate top two stack elements and add them together
  0> if      \ if greater than 0
    m m      \ divide both by 10, move remainders behind quotients
    recurse  \ call self recursively
    10 *     \ multiply result by 10 (decimal left shift of 1)
    -rot     \ get remainders from original division
    2dup     \ duplicate both remainders 
    swap t   \ swap order and call t (b & !a)
    -rot t   \ move result back and call t on other pair (a & !b)
    max + 1  \ get the max of the two results and add to total. put 1 on top of stack
  then       \ end if block
  *          \ multiply top two stack results (cheaper way of getting rid of extra 0)
;            \ end word definition

C＃（Visual C＃交互式编译器），75字节

a=>b=>a.Select((x,y)=>Math.Max(9-x<(y=y<b.Count?b[y]:0)?9-x:y,9-y<x?9-y:x))

@someone节省了6个字节

在线尝试！

PHP，111个 109字节

for(;''<($a=$argv[1][-++$i]).$b=$argv[2][-$i];)$s=min($a<5?9-$a:$a,max($a<5?$a:9-$a,$a<5?$b:9-$b)).$s;echo$s;

在线尝试！

测试：在线尝试！

如果我们将这些数字称为XOR $a和$b，我发现：

• 当$a小于5，XOR = min(9-$a, max($a, $b))
• 当$a等于或大于5时XOR = min($a, max(9-$a, 9-$b))

因此，我实现了这种逻辑，并采用了hack来处理不同长度的数字。我将每个数字都从两个输入数字的末尾（带有负索引，如input[-1]，input[-2]...），然后计算XOR，并将结果以相反的顺序放入要打印的字符串中。由于我从数字末尾取数字，因此XOR结果应以相反的顺序组合在一起。当输入之一长于另一输入时，较短输入上的负索引将导致一个等于0的空字符串。

视网膜，85 59字节

^'0P`.+
N$`.
$.%`
¶

/../_(`^
$"
T`d`Rd`.¶.
%N`.
^N`..
L`^.

在线尝试！将输入作为单独的行，但是链接是重新格式化用逗号分隔的输入的测试套件。说明：

^'0P`.+

左填充为零的两条线的长度相同。

N$`.
$.%`
¶

按其列索引对每个数字进行排序，然后删除换行符。这具有将数字配对在一起的效果，与转置效果几乎相同。

/../_(`

将结果分别应用于每对数字。

^
$"

复制一对。

T`d`Rd`.¶.

反转第一对的第二个数字和第二对的第一个数字，因此我们现在x ~y在一行~x y上，在另一行上。

%N`.

按顺序对每行的数字进行排序，以使第一个数字现在x & ~y或~x & y适当。

^N`..

对行进行反向排序。

L`^.

并提取第一个数字，这是所需的结果。