दशमलव "XOR" ऑपरेटर

Question

कई प्रोग्रामिंग भाषा पूर्णांक के बाइनरी (बेस -2) अंकों को हेरफेर करने के लिए ऑपरेटर प्रदान करती हैं। इन ऑपरेटरों को अन्य ठिकानों पर सामान्यीकृत करने का एक तरीका यह है:

चलो एक्स और वाई आधार में एकल अंकों की संख्या हो बी । यूनिरी ऑपरेटर को परिभाषित करें~ और द्विआधारी ऑपरेटरों &, |और ^ऐसा है कि:

• ~ x = (बी - 1) - x
• x & y = मिनट (x, y)
• x | y = अधिकतम (x, y)
• x ^ y = (x & ~ y) | (y & ~ x)

ध्यान दें कि यदि B = 2 है, तो हमें परिचित बिटवाइज़ NOT, AND, OR, और XOR ऑपरेटर मिलते हैं।

B = 10 के लिए, हमें "दशमलव 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

मल्टी-डिजिट नंबरों के लिए, सिंगल-डिजिट ऑपरेटर डिजिट-बाय-डिजिट लागू करें। उदाहरण के लिए, 12345 ^ 24680 = 24655, क्योंकि:

• 1 ^ 2 = 2
• 2 ^ 4 = 4
• 3 ^ 6 = 6
• 4 ^ 8 = 5
• ५ ^ ० = ५

यदि ऑपरेंड अलग-अलग लंबाई के होते हैं, तो छोटे को अग्रणी शून्य के साथ पैड करें।

चुनौती

जितना संभव हो, कुछ बाइट्स में लिखें, एक प्रोग्राम या फ़ंक्शन जो इनपुट दो पूर्णांकों के रूप में लेता है (जो कि 0 और 999 999 के बीच माना जा सकता है, समावेशी) और उपरोक्त के रूप में दो नंबरों के "दशमलव XOR" को आउटपुट करता है।

परीक्षण के मामलों

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

Comments

क्या हम इनपुट या आउटपुट को स्ट्रिंग्स या चार सरणियों के रूप में ले सकते हैं?

— इग्नोरेंस

एक अंक सरणी के बारे में कैसे? क्या यह स्वीकार्य है?

— को अज्ञानता

के 09इनपुट के लिए स्वीकार्य परिणाम है 90, 99?

— नील

काश एक सामान्यीकरण होता जो बना A^B^B=A

— रहता

@trichoplax, आप दोनों नहीं हो सकता है a^b=b^aऔर a^b^b=aएक अजीब प्रधानमंत्री भाजक के साथ अड्डों के लिए

— mik

Answer 1

जेली , 14 बाइट्स

DUz0«9_ṚƊṀƊ€UḌ

इसे ऑनलाइन आज़माएं!

सभी एकल अंकों के जोड़े की ग्रिड

एक मोनडिक लिंक दो पूर्णांकों की सूची को अपने तर्क के रूप में लेता है और एक पूर्णांक लौटाता है।

व्याख्या

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

यदि एक अंक मैट्रिक्स स्वीकार्य इनपुट / आउटपुट है:

जेली , 12 बाइट्स

Uz0«9_ṚƊṀƊ€U

इसे ऑनलाइन आज़माएं!

Answer 2

पायथ , 31 बाइट्स

LhS,hb-9ebjkmeS,ydy_d_.t_MjRTQ0

इसे ऑनलाइन आज़माएं!

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

Answer 3

पायथन 2 , 71 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 4

फोर्थ (gforth) , 111 बाइट्स

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

इसे ऑनलाइन आज़माएं!

कोड स्पष्टीकरण

: 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

Answer 5

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 75 बाइट्स

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

@Someone के लिए 6 बाइट्स का धन्यवाद सहेजा गया

इसे ऑनलाइन आज़माएं!

Comments

76 बाइट्स । मुझे लगता है कि यह प्रश्न ज़िप का उपयोग करने का एक अनूठा अवसर हो सकता है।

— मेरा सर्वनाम 4

@someone धन्यवाद! के बारे में Zip, आप इसका उपयोग नहीं कर सकते क्योंकि यह स्वचालित रूप से छोटी की लंबाई तक लंबे संग्रह को छोटा कर देता है

— अज्ञानता का अवतार

Answer 6

PHP , 111 109 बाइट्स

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;

इसे ऑनलाइन आज़माएं!

टेस्ट: इसे ऑनलाइन आज़माएं!

यदि हम उन अंकों को कहते हैं जिन्हें हम XOR करना चाहते हैं, $aऔर $b, मैंने पाया कि:

• कब $a 5 से कम है,XOR = min(9-$a, max($a, $b))
• जब $aके बराबर या अधिक से अधिक 5 है,XOR = min($a, max(9-$a, 9-$b))

इसलिए मैंने इस तर्क को लागू किया और विभिन्न लंबाई वाले नंबरों को संभालने के लिए एक हैक। मैं प्रत्येक अंक प्रपत्र दोनों इनपुट संख्या के अंत ले (नकारात्मक अनुक्रमित चाहते साथ input[-1], input[-2], ...) और XOR की गणना और एक स्ट्रिंग में उलट क्रम में परिणाम को अंत में मुद्रित करने के लिए। चूंकि मैं संख्याओं के अंत से अंक लेता हूं, इसलिए XOR परिणाम को एक साथ उल्टे क्रम में रखा जाना चाहिए। जब इनपुट में से एक दूसरे से अधिक लंबा होता है, तो कम इनपुट पर नकारात्मक सूचकांक एक रिक्त स्ट्रिंग में परिणाम होता है जो 0 के बराबर होता है।

Answer 7

रेटिना , 85 59 बाइट्स

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

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

इसे ऑनलाइन आज़माएं! इनपुट को अलग लाइनों के रूप में लेता है, लेकिन लिंक सूट का परीक्षण करने के लिए है जो सुधारक अल्पविराम से अलग इनपुट करता है। स्पष्टीकरण:

^'0P`.+

एक ही लंबाई के लिए दोनों पंक्तियों के साथ शून्य-पैड।

N$`.
$.%`
¶

प्रत्येक अंक को उसके कॉलम इंडेक्स द्वारा क्रमित करें, फिर न्यूलाइन को हटा दें। इसमें अंकों को एक साथ जोड़े जाने का प्रभाव होता है, जैसे कि एक संक्रमण।

/../_(`

परिणामों को एक साथ जोड़ते हुए, प्रत्येक जोड़ी अंकों के लिए अलग से लागू करें।

^
$"

जोड़ी को डुप्लिकेट करें।

T`d`Rd`.¶.

पहली जोड़ी के दूसरे अंक और दूसरे के पहले अंक को उल्टा कर दें, इसलिए अब हमारे पास x ~yएक पंक्ति है और ~x yदूसरे पर।

%N`.

क्रम में प्रत्येक पंक्ति के अंकों को क्रमबद्ध करें, ताकि पहला अंक अब x & ~yया ~x & yजैसा उचित हो।

^N`..

लाइनों को उल्टा करें।

L`^.

और पहला अंक निकालें, जो वांछित परिणाम है।