De nombreux langages de programmation fournissent des opérateurs pour manipuler les chiffres binaires (base-2) des entiers. Voici une façon de généraliser ces opérateurs à d'autres bases:

Soit x et y deux nombres à un seul chiffre dans la base B . Définir l'opérateur unaire ~et binaire &, |et de ^telle sorte que:

• ~ x = (B - 1) - x
• x & y = min (x, y)
• x | y = max (x, y)
• x ^ y = (x et ~ y) | (y & ~ x)

Notez que si B = 2, nous obtenons les opérateurs NOT, AND, OR et XOR au niveau du bit familiers.

Pour B = 10, on obtient le tableau «XOR décimal»:

^ │ 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

Pour les numéros à plusieurs chiffres, appliquez l'opérateur à un chiffre chiffre par chiffre. Par exemple, 12345 ^ 24680 = 24655, car:

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

Si les opérandes sont de longueurs différentes, remplissez le plus court avec des zéros en tête.

Le défi

Écrivez, dans le moins d'octets possible, un programme ou une fonction qui prend en entrée deux entiers (qui peuvent être supposés être compris entre 0 et 999 999 999, inclus) et sort le «XOR décimal» des deux nombres comme défini ci-dessus.

Cas de test

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

Gelée , 14 octets

DUz0«9_ṚƊṀƊ€UḌ

Essayez-le en ligne!

Grille de toutes les paires à un chiffre

Un lien monadique prenant comme argument une liste de deux entiers et retournant un entier.

Explication

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

Si une matrice de chiffres est une entrée / sortie acceptable:

Gelée , 12 octets

Uz0«9_ṚƊṀƊ€U

Essayez-le en ligne!

Pyth , 31 octets

LhS,hb-9ebjkmeS,ydy_d_.t_MjRTQ0

Essayez-le en ligne!

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 octets

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

Essayez-le en ligne!

Forth (gforth) , 111 octets

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

Essayez-le en ligne!

Explication du code

: 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 # Interactive Compiler) , 75 octets

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

6 octets enregistrés grâce à @someone

Essayez-le en ligne!

PHP , 111 109 octets

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;

Essayez-le en ligne!

Tests: Essayez-le en ligne!

Si nous appelons les chiffres que nous voulons XOR, $aet $b, j'ai trouvé que:

• Quand $aest inférieur à 5,XOR = min(9-$a, max($a, $b))
• Quand $aest supérieur ou égal à 5,XOR = min($a, max(9-$a, 9-$b))

J'ai donc implémenté cette logique plus un hack pour gérer les nombres de différentes longueurs. Je prends chaque forme de chiffres à la fin des deux nombres d'entrée (avec des indices négatifs comme input[-1], input[-2]...) et calculer la XOR et mettre le résultat dans l' ordre inverse dans une chaîne de caractères à imprimer à la fin. Étant donné que je prends des chiffres à la fin des nombres, les résultats XOR doivent être regroupés dans l'ordre inverse. Lorsque l'une des entrées est plus longue que l'autre, l'index négatif sur une entrée plus courte se traduit par une chaîne vide qui est égale à 0.

Rétine , 85 59 octets

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

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

Essayez-le en ligne! Prend l'entrée sur des lignes distinctes, mais le lien consiste à tester la suite qui reformate l'entrée séparée par des virgules. Explication:

^'0P`.+

Pavé gauche avec des zéros sur les deux lignes à la même longueur.

N$`.
$.%`
¶

Triez chaque chiffre par son index de colonne, puis supprimez la nouvelle ligne. Cela a pour effet d'appairer les chiffres de la même manière qu'une transposition.

/../_(`

Appliquer séparément à chaque paire de chiffres, en joignant les résultats ensemble.

^
$"

Dupliquez la paire.

T`d`Rd`.¶.

Inversez le deuxième chiffre de la première paire et le premier chiffre de la seconde, nous avons donc maintenant x ~ysur une ligne et ~x ysur l'autre.

%N`.

Triez les chiffres de chaque ligne dans l'ordre, de sorte que le premier chiffre soit maintenant x & ~you ~x & ycomme approprié.

^N`..

Tri inversé des lignes.

L`^.

Et extrayez le premier chiffre, qui est le résultat souhaité.