Muitas linguagens de programação fornecem operadores para manipular os dígitos binários (base 2) dos números inteiros. Aqui está uma maneira de generalizar esses operadores para outras bases:

Deixe que x e y ser números de um dígito em base de B . Definir o operador unário ~e operadores binários &, |e ^de tal forma que:

• Matemática5 pontos
• x & y = min (x, y)
• x y = max (x, y)
• x ^ y = (x e ~ y) | (y & x)

Observe que, se B = 2, obtemos os familiares operadores NOT, AND, OR e XOR, bit a bit.

Para B = 10, obtemos a tabela "decimal 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

Para números de vários dígitos, aplique o operador de um dígito, dígito por dígito. Por exemplo, 12345 ^ 24680 = 24655, porque:

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

Se os operandos tiverem comprimentos diferentes, preencha o menor com zeros à esquerda.

O desafio

Escreva, no menor número de bytes possível, um programa ou função que tome como entrada dois números inteiros (que podem ser assumidos entre 0 e 999 999 999, inclusive) e emita o "XOR decimal" dos dois números, conforme definido acima.

Casos de teste

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

Gelatina , 14 bytes

DUz0«9_ṚƊṀƊ€UḌ

Experimente online!

Grade de todos os pares de um dígito

Um link monádico usando uma lista de dois números inteiros como argumento e retornando um número inteiro.

Explicação

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

Se uma matriz de dígitos é aceitável de entrada / saída:

Gelatina , 12 bytes

Uz0«9_ṚƊṀƊ€U

Experimente online!

Pitão , 31 bytes

LhS,hb-9ebjkmeS,ydy_d_.t_MjRTQ0

Experimente online!

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 bytes

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

Experimente online!

Quarto (gforth) , 111 bytes

: 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 * ;

Experimente online!

Código Explicação

: 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 # (compilador interativo do Visual C #) , 75 bytes

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))

Guardado 6 bytes graças a @someone

Experimente online!

PHP , 111 109 bytes

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;

Experimente online!

Testes: Experimente online!

Se chamarmos os dígitos que queremos XOR, $ae $b, eu achei que:

• Quando $aé menor que 5,XOR = min(9-$a, max($a, $b))
• Quando $aé igual ou superior a 5,XOR = min($a, max(9-$a, 9-$b))

Então eu implementei essa lógica mais um hack para lidar com números de diferentes comprimentos. Tomo cada forma dígito final de ambos os números de entrada (com índices negativos gosto input[-1], input[-2], ...) e calcular o XOR e colocar o resultado na ordem inversa em uma cadeia a ser impresso no final. Como eu recebo dígitos do final dos números, os resultados do XOR devem ser reunidos em ordem inversa. Quando uma das entradas é maior que a outra, o índice negativo na entrada mais curta resulta em uma sequência vazia que é igual a 0.

Retina , 85 59 bytes

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

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

Experimente online! Recebe a entrada como linhas separadas, mas o link é para testar o conjunto que reformata a entrada separada por vírgula. Explicação:

^'0P`.+

Almofada esquerda com zeros ambas as linhas no mesmo comprimento.

N$`.
$.%`
¶

Classifique cada dígito pelo índice da coluna e exclua a nova linha. Isso tem o efeito de emparelhar os dígitos da mesma maneira que uma transposição faria.

/../_(`

Aplique separadamente a cada par de dígitos, juntando os resultados.

^
$"

Duplique o par.

T`d`Rd`.¶.

Inverta o segundo dígito do primeiro par e o primeiro dígito do segundo, para que agora tenhamos x ~yuma linha e ~x ya outra.

%N`.

Classifique os dígitos de cada linha em ordem, para que o primeiro dígito seja agora x & ~you ~x & yconforme apropriado.

^N`..

Classificação inversa das linhas.

L`^.

E extraia o primeiro dígito, que é o resultado desejado.