Viele Programmiersprachen bieten Operatoren zum Manipulieren der binären (Basis-2) Ziffern von ganzen Zahlen. Hier ist eine Möglichkeit, diese Operatoren auf andere Basen zu verallgemeinern:

Lassen Sie x und y einem einstelligen Zahlen in der Basis sein B . Definieren Sie den unären Operator ~und binäre Operatoren &, |und ^so dass:

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

Beachten Sie, dass wir bei B = 2 die bekannten bitweisen Operatoren NOT, AND, OR und XOR erhalten.

Für B = 10 erhalten wir die "dezimale XOR" -Tabelle:

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

Wenden Sie bei mehrstelligen Zahlen den einstelligen Operator ziffernweise an. Zum Beispiel 12345 ^ 24680 = 24655, weil:

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

Wenn die Operanden unterschiedlich lang sind, füllen Sie die kürzere mit führenden Nullen auf.

Die Herausforderung

Schreiben Sie in so wenigen Bytes wie möglich ein Programm oder eine Funktion, die zwei Ganzzahlen als Eingabe verwendet (wobei angenommen werden kann, dass sie zwischen 0 und 999 und 999 und 999 liegen) und das oben definierte „dezimale XOR“ der beiden Zahlen ausgibt.

Testfälle

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

Jelly , 14 Bytes

DUz0«9_ṚƊṀƊ€UḌ

Probieren Sie es online!

Gitter aller einstelligen Paare

Ein monadischer Link, der eine Liste mit zwei Ganzzahlen als Argument verwendet und eine Ganzzahl zurückgibt.

Erläuterung

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

Wenn eine Ziffernmatrix für die Eingabe / Ausgabe akzeptabel ist:

Gelee , 12 Bytes

Uz0«9_ṚƊṀƊ€U

Probieren Sie es online!

Pyth , 31 Bytes

LhS,hb-9ebjkmeS,ydy_d_.t_MjRTQ0

Probieren Sie es 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

Probieren Sie es online!

Viertens (gviertens) , 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 * ;

Probieren Sie es online!

Code-Erklärung

: 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 Byte

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 Bytes dank @someone gespeichert

Probieren Sie es 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;

Probieren Sie es online!

Tests: Online ausprobieren!

Wenn wir die Ziffern nennen wir XOR wollen, $aund $b, fand ich , dass:

• Wann $aist weniger als 5,XOR = min(9-$a, max($a, $b))
• Wann $aist gleich oder mehr als 5,XOR = min($a, max(9-$a, 9-$b))

Also habe ich diese Logik und einen Hack implementiert, um Zahlen mit unterschiedlichen Längen zu verarbeiten. Ich nehme jede Ziffer Form um das Ende beiden Eingangsnummern (mit negativer Indizes mag input[-1], input[-2], ...) und die XOR berechnen und das Ergebnis in umgekehrter Reihenfolge in einem String setzen am Ende gedruckt werden. Da ich Ziffern vom Ende der Zahlen nehme, sollten die XOR-Ergebnisse in umgekehrter Reihenfolge zusammengestellt werden. Wenn einer der Eingänge länger als der andere ist, führt der negative Index für kürzere Eingänge zu einer leeren Zeichenfolge, die gleich 0 ist.

Retina , 85 59 Bytes

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

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

Probieren Sie es online! Nimmt Eingaben als separate Zeilen, aber der Link ist eine Testsuite, die kommagetrennte Eingaben neu formatiert. Erläuterung:

^'0P`.+

Linkes Pad mit Nullen, beide Zeilen gleich lang.

N$`.
$.%`
¶

Sortieren Sie jede Ziffer nach ihrem Spaltenindex und löschen Sie dann die neue Zeile. Dies hat den Effekt, dass die Ziffern auf die gleiche Weise wie bei einer Transponierung gepaart werden.

/../_(`

Bewerben Sie sich separat für jedes Ziffernpaar und fügen Sie die Ergebnisse zusammen.

^
$"

Dupliziere das Paar.

T`d`Rd`.¶.

Kehre die zweite Ziffer des ersten Paares und die erste Ziffer des zweiten um, so dass wir nun x ~yin der einen und ~x yin der anderen Zeile haben .

%N`.

Sortieren Sie die Ziffern jeder Zeile nacheinander, sodass die erste Ziffer jetzt x & ~yoder ~x & yentsprechend ist.

^N`..

Sortieren Sie die Zeilen in umgekehrter Reihenfolge.

L`^.

Und extrahieren Sie die erste Ziffer, die das gewünschte Ergebnis ist.