Nhiều ngôn ngữ lập trình cung cấp các toán tử để thao tác các chữ số nhị phân (cơ số 2) của các số nguyên. Đây là một cách để khái quát các toán tử này sang các cơ sở khác:

Hãy x và y là các số đơn chữ số trong cơ sở B . Xác định các nhà điều hành unary ~và khai thác nhị phân &, |và ^như vậy:

• ~ x = (B - 1) - x
• x & y = phút (x, y)
• x | y = tối đa (x, y)
• x ^ y = (x & ~ y) | (y & ~ x)

Lưu ý rằng nếu B = 2, chúng ta sẽ nhận được các toán tử bit, AND, OR và XOR quen thuộc.

Với B = 10, chúng ta có được bảng XOR thập phân của Nhật Bản:

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

Đối với các số có nhiều chữ số, áp dụng toán tử một chữ số theo chữ số. Ví dụ: 12345 ^ 24680 = 24655, vì:

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

Nếu các toán hạng có độ dài khác nhau, thì đệm ngắn hơn với các số 0 đứng đầu.

Các thách thức

Viết, càng ít byte càng tốt, một chương trình hoặc hàm lấy hai số nguyên đầu vào (có thể được giả định là từ 0 đến 999 999 999, đã bao gồm) và xuất ra số thập phân XOR của hai số như được xác định ở trên.

Các trường hợp thử nghiệm

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

Thạch , 14 byte

DUz0«9_ṚƊṀƊ€UḌ

Hãy thử trực tuyến!

Lưới của tất cả các cặp chữ số đơn

Một liên kết đơn âm lấy danh sách hai số nguyên làm đối số của nó và trả về một số nguyên.

Giải trình

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

Nếu một ma trận chữ số được chấp nhận đầu vào / đầu ra:

Thạch , 12 byte

Uz0«9_ṚƊṀƊ€U

Hãy thử trực tuyến!

Bình thường , 31 byte

LhS,hb-9ebjkmeS,ydy_d_.t_MjRTQ0

Hãy thử trực tuyến!

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 byte

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

Hãy thử trực tuyến!

Forth (gforth) , 111 byte

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

Hãy thử trực tuyến!

Giải thích mã

: 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 # (Trình biên dịch tương tác Visual C #) , 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))

Đã lưu 6 byte nhờ @someone

Hãy thử trực tuyến!

PHP , 111 109 byte

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;

Hãy thử trực tuyến!

Kiểm tra: Hãy thử trực tuyến!

Nếu chúng ta gọi các chữ số mà chúng ta muốn là XOR, $avà $b, tôi thấy rằng:

• Khi $anhỏ hơn 5,XOR = min(9-$a, max($a, $b))
• Khi $abằng hoặc hơn 5,XOR = min($a, max(9-$a, 9-$b))

Vì vậy, tôi đã triển khai logic này cộng với một bản hack để xử lý các số có độ dài khác nhau. Tôi lấy mỗi chữ số ở cuối của cả hai số đầu vào (với các chỉ số âm như input[-1],, input[-2]...) và tính XOR và đặt kết quả theo thứ tự đảo ngược trong một chuỗi sẽ được in ở cuối. Vì tôi lấy các chữ số từ cuối các số, kết quả XOR nên được đặt cùng nhau theo thứ tự đảo ngược. Khi một trong các đầu vào dài hơn đầu vào khác, chỉ số âm trên đầu vào ngắn hơn dẫn đến một chuỗi trống bằng 0.

Võng mạc , 85 59 byte

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

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

Hãy thử trực tuyến! Lấy đầu vào là các dòng riêng biệt, nhưng liên kết là để kiểm tra bộ định dạng lại định dạng đầu vào được phân tách bằng dấu phẩy. Giải trình:

^'0P`.+

Pad trái với số không cả hai dòng có cùng chiều dài.

N$`.
$.%`
¶

Sắp xếp từng chữ số theo chỉ số cột của nó, sau đó xóa dòng mới. Điều này có tác dụng ghép các chữ số lại với nhau theo cách tương tự như chuyển vị.

/../_(`

Áp dụng riêng cho từng cặp chữ số, nối các kết quả lại với nhau.

^
$"

Nhân đôi cặp.

T`d`Rd`.¶.

Đảo ngược chữ số thứ hai của cặp thứ nhất và chữ số thứ nhất của số thứ hai, vì vậy bây giờ chúng ta có x ~ytrên một dòng và ~x ytrên dòng khác.

%N`.

Sắp xếp các chữ số của mỗi dòng theo thứ tự, sao cho chữ số đầu tiên bây giờ x & ~yhoặc ~x & yphù hợp.

^N`..

Sắp xếp ngược các dòng.

L`^.

Và trích xuất chữ số đầu tiên, đó là kết quả mong muốn.