Opérateur décimal «XOR»

15

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
code-golf math number dan04
la source
Pouvons-nous prendre l'entrée ou la sortie sous forme de chaînes ou de tableaux de caractères?
Incarnation de l'ignorance
6
Que diriez-vous d'un tableau de chiffres? Est-ce acceptable?
Incarnation de l'ignorance
1
Un 09résultat acceptable pour une entrée de 90, 99?
Neil
1
Je souhaite qu'il y ait une généralisation qui se soit maintenueA^B^B=A
trichoplax le
2
@trichoplax, vous ne pouvez pas avoir les deux a^b=b^aet a^b^b=apour les bases avec un diviseur premier impair
mik

Réponses:

3

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!

Nick Kennedy
la source
2

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( ^^^ )
ar4093
la source
1

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
reffu
la source
1

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!

Incarnation de l'ignorance
la source
76 octets . Je pense que cette question pourrait être une occasion unique d'utiliser Zip.
mon pronom est monicareinstate
1
@someone Merci! En ce qui concerne Zip, vous ne pouvez pas l'utiliser car il tronque automatiquement la collection la plus longue à la longueur de la plus courte
Embodiment of Ignorance
0

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.

Nuit2
la source
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é.

Neil
la source