आधार -1 + i में जोड़

Question

गाऊसी पूर्णांकों फार्म की जटिल नंबर दिए गए हैं a+bi, जहां aऔर bदोनों पूर्णांक हैं। आधार -1 + i में, सभी गाऊसी पूर्णांक को अंकों का उपयोग करके विशिष्ट रूप से दर्शाया जा सकता है 0और 1, चिह्न को चिह्नित करने के लिए प्रतीक की आवश्यकता के बिना।

उदाहरण के लिए, 1100आधार -1 + में मैं दशमलव संख्या 2 का प्रतिनिधित्व करता हूं, क्योंकि

1*(-1+i)^3 + 1*(-1+i)^2 + 0*(-1+i)^1 + 0*(-1+i)^0
= (2+2i) + (-2i) + 0 + 0
= 2

इनपुट बेस -1 में दो गाऊसी पूर्णांक होंगे। मैंने अंकों का उपयोग किया 01। यह निम्नलिखित रूपों में से एक ले सकता है:

• दो अलग-अलग अंक के तार,
• दो दशमलव पूर्णांक 01आधार -1 + i संख्याओं का प्रतिनिधित्व करते हैं (जैसे 1100आधार -1 + i में 2 के लिए),
• आधार -1 + i संख्याओं का प्रतिनिधित्व करने वाले दो बाइनरी पूर्णांक (उदाहरण के लिए 12या 0b1100आधार -1 + i में 2 के लिए)
• एक एकल स्ट्रिंग एक गैर-अल्फ़ान्यूमेरिक विभाजक (उदाहरण के लिए 1100 1100या 12,122 + 2) द्वारा दो अंकों के तार / बाइनरी पूर्णांक को अलग करता है

दो गाऊसी पूर्णांकों के योग को आधार -1 + i में भी आउटपुट करते हैं और अंकों का उपयोग करके प्रतिनिधित्व करते हैं 01(इनपुट के रूप में अनुमत प्रारूपों में से एक है, जरूरी नहीं कि एक ही पसंद हो)। आउटपुट में अग्रणी शून्य की एक सीमित संख्या शामिल है।

आपके फ़ंक्शन या प्रोग्राम को प्रत्येक 30 अंक पर अधिकतम 30 सेकंड के इनपुट के लिए 2 सेकंड के भीतर समाप्त करना होगा।

अतिरिक्त स्पष्टीकरण

• आप मान सकते हैं कि इनपुट में कोई बाहरी अग्रणी शून्य नहीं है। 0 के विशेष मामले के लिए, आप 0या तो या रिक्त स्ट्रिंग को प्रतिनिधित्व के रूप में चुन सकते हैं ।

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

0, 0 => 0                                      # 0 + 0 = 0
0, 1 => 1                                      # 0 + 1 = 1
1, 1 => 1100                                   # 1 + 1 = 2
1100, 1100 => 111010000                        # 2 + 2 = 4
1101, 1101 => 111011100                        # 3 + 3 = 6
110111001100, 1110011011100 => 0               # 42 + (-42) = 0
11, 111 => 0                                   # i + (-i) = 0
11, 110 => 11101                               # i + (-1-i) = -1
10101, 11011 => 10010                          # (-3-2i) + (-2+3i) = (-5+i)
1010100101, 111101 => 1110100000100            # (-19+2i) + (3-4i) = (-16-2i)

लंबे समय तक परीक्षण के मामले:

11011011010110101110010001001, 111100010100101001001010010101 => 0
111111111111111111111111111111, 111111111111111111111111111111 => 100100100100100100100100100100
101101110111011101110111011101, 101101110111011101110111011101 => 11101001010001000100010001000100011100
100100010101001101010110101010, 100010011101001011111110101000 => 110000110010101100001100111100010

Comments

कोई अंक सूची नहीं?

— कैलक्यूलेटरफेलिन

@CatsAreFluffy कोई अंक सूची नहीं, क्षमा करें।

— Sp3000

आप को बदलने के द्वारा एक बाइट बचा सकते हैं -1+iकरने के लिए i-1शीर्षक में।

— mbomb007

अब हमें दूसरे तरीके के रूपांतरण की आवश्यकता है। : P

— R

दुनिया में 1100 तरह के लोग हैं। जो लोग द्विआधारी को समझते हैं, जो लोग नहीं करते हैं, जो इसे टर्नरी के साथ भ्रमित करते हैं, वे जो इसे आधार 4 के साथ भ्रमित करते हैं, जो इसे आधार 5 के साथ भ्रमित करते हैं, जो इसे आधार -1 + i के साथ भ्रमित करते हैं, जो इसे भ्रमित करते हैं आधार 6, जो लोग इसे आधार 7 के साथ भ्रमित करते हैं, जो लोग इसे आधार 8 के साथ भ्रमित करते हैं, जो लोग इसे आधार 9 के साथ भ्रमित करते हैं ...

— wizzwizz4

Answer 1

पायथन 2, 98 97 91 84 बाइट्स

s=input();L=1
for _ in`s`*8:s+=1098*int(str(s).translate('0011'*64));L*=10
print s%L

यह दशमलव में I / O करता है। पूर्णांक को गैर-अल्फ़ान्यूमेरिक वर्ण द्वारा अलग किया जाना है +।

2 बाइट बंद करने के लिए @xnor को धन्यवाद!

Ideone पर इसे आज़माएं ।

यह काम किस प्रकार करता है

कॉम्प्लेक्स बेसिस में अंकगणित में , लेखक दिखाता है कि फॉर्म -n + i के आधारों में जटिल संख्याओं को कैसे जोड़ा और गुणा किया जाए ।

आधार -1 + i के लिए , इसके अतिरिक्त नियमित रूप से किया जाता है, बाइनरी कैरी के साथ दो अंतरों के साथ:

• 1 को अगले उच्च स्थान पर ले जाने के बजाय , हम 110 को अगले तीन पर ले जाते हैं।

• कैरी अंक अनिश्चित काल तक प्रचारित कर सकते हैं। हालांकि, अग्रणी शून्य के बिना, ए + बी में अधिकतम अ और ख की तुलना में अधिक से अधिक आठ अंक हैं ।

हम इस प्रकार आगे बढ़ते हैं।

1. सबसे पहले, हम एक और बी जोड़ते हैं जैसे कि उनके अंक दशमलव अंक थे।

   के लिए एक = 10101 और ख = 11011 , इस देता है 21,112 ।

2. इसके बाद, हम अंक की तुलना में बड़ा की जगह एक नया नंबर फार्म 1 एक साथ 1 एक साथ, दूसरों को 0 । ¹

   21112 की राशि के लिए , यह 10001 देता है ।

3. 1 से बड़े प्रत्येक अंक के लिए , हमें उस अंक से 2 घटाना होगा और 110 को अगले तीन उच्च पदों पर ले जाना होगा। के बाद से 1098 = 10 * 110 - 2 , हम द्वारा चरण 2 से परिणाम गुणा करके इस लक्ष्य को हासिल कर सकते हैं 1098 है, तो योग करने के लिए कि उत्पाद को जोड़ने। ²

   21112 की राशि के लिए , यह 21112 + 1098 * 10001 = 21112 + 10981098 = 11002210 देता है ।

4. हम चरण 2 और 3 को कुल d * 8 बार दोहराते हैं , जहाँ d एक + b के अंकों की संख्या है । ³

   प्रारंभिक योग 21112 के लिए , परिणाम हैं

                         11002210
                         12210010
                       1220010010
                     122000010010
                   12200000010010
                 1220000000010010
               122000000000010010
             12200000000000010010
           1220000000000000010010
         122000000000000000010010
       12200000000000000000010010
     1220000000000000000000010010
   122000000000000000000000010010
                                .
                                .
                                .
   

5. हम अंतिम राशि modulo 10 ^{d + 8} लेते हैं , सभी को छोड़ते हुए अंतिम d + 8 अंक।

   प्रारंभिक योग 21112 के लिए , अंतिम परिणाम 10010 है ।

---

¹ _{यह अनुवाद के साथ हासिल किया है । स्ट्रिंग 0011 को 64 बार दोहराने से वांछित प्रतिस्थापन को प्राप्त करने के लिए ASCII वर्ण 0123 के अनुक्रम के साथ एक पुनरावृत्ति रेखा होती है ।}

² _{ध्यान दें कि इस राशि के अंक 3 से अधिक नहीं हो सकते हैं (प्रारंभिक मूल्य 1 प्लस दो 1 1 कैर्री से)।}

³ _{यह डी = 1 के लिए काम करने के लिए होता है , और डी * 8> डी + 8 अन्यथा। कोड चरणों को दोहरा सकता है (d + 1) * 8 बार, क्योंकि s का अनुगामी L होता है यदि s एक लंबा पूर्णांक है।}

Comments

यह गहरा जादू है । क्या प्रारूप input()उम्मीद कर रहा है? ( 21112जब मुझे इनपुट मिलता है 10101, 11011।)

— टिम पैडरिक

कोई बात नहीं; पायथन 3 का अनुवाद (असफल, ऐसा लगता है) एक संस्करण चल रहा था। यह पायथन 2 के तहत ठीक काम करता है ।

— बजे टिम पैडरिक

...किस तरह। कृप्या। के बारे में बताएं।

— निक हार्टले

@QPaysTaxes मैंने अपना उत्तर संपादित कर लिया है।

— डेनिस

@ डेनिस अब आप बता सकते हैं कि यह क्यों काम करता है? उदाहरण के लिए, क्यों d+8और क्या नहीं, कहते हैं d+9? किस तरह????

— निक हार्टले

Answer 2

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

_shM.u,%J/eMeN\12-+PMeNm.B6/J2k,kQ

इसे ऑनलाइन आज़माएं: प्रदर्शन या टेस्ट सूट (काफी समय लगता है)। यह समय के प्रतिबंध को आसानी से संतुष्ट करना चाहिए, क्योंकि ऑनलाइन संकलक सामान्य (ऑफ़लाइन) संकलक की तुलना में काफी धीमा है।

व्याख्या:

मेरा एल्गोरिथ्म मूल रूप से ले जाने के साथ जोड़ का एक कार्यान्वयन है। लेकिन ले जाने के बजाय 1, मैं ले जाने के लिए है 110( 1100आधार में -1+iरूप में ही है 2आधार में -1+i)। यह ज्यादातर ठीक काम करता है, लेकिन आप एक अनंत लूप प्रिंटिंग शून्य में फंस सकते हैं। उदाहरण के लिए यदि आप 1साथ जोड़ रहे हैं 11और वर्तमान में कैरी है 110। इसलिए मैं मूल रूप से तब तक जोड़ता हूं जब तक मैं एक लूप में फंस नहीं जाता और फिर रुक जाता हूं। मुझे लगता है कि एक लूप जो एक लूप हमेशा शून्य को प्रिंट करेगा और इसलिए यह ठीक होना चाहिए।

_shM.u,%J/eMeN\12-+PMeNm.B6/J2k,kQ   implicit: Q = input list of strings
                               ,kQ   create the pair ["", Q]
    .u                               modify the pair N (^) until loop:
      ,                                replace N with a new pair containing:
            eN                           N[1] (the remaining summand)
          eM                             take the last digits of each summand
         /    \1                         count the ones
        J                                store the count in J
       %J       2                        J % 2 (this is the first element of the new pair)
                   PMeN                  remove the last digit of each summand
                  +    m   /J2           and add J / 2 new summand:
                        .B6                 with the value "110" (binary of 6)
                 -            k          remove empty summand
    .u                               returns all intermediate results
  hM                                 extract the digits
 s                                   sum them up to a long string
_                                    reverse

Answer 3

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

f=lambda a,b:a*a+b*b^58and 2*f(a*b%2*6,f(a/2,b/2))|a+b&1if a else b

I / O आधार 2 पूर्णांकों के साथ किया जाता है।

-2 धन्यवाद @ डेनिस।

Comments

मैं इसे a*a+b*b^58==0कब लेता हूं aऔर bउलटा कर रहा हूं ? वह कैसे काम करता है?

— xnor

@xnor नहीं, a*a+b*b==58जब उनमें से एक 3 है और दूसरा है 7.

— feersum

यह मेरे लिए स्पष्ट नहीं है कि (3,7)एकमात्र जोड़ी है जो एक चक्र देती है और विशेष आवरण की आवश्यकता होती है। यदि यह सच है, तो आपको केवल (a,b)==(3,7)उसी क्रम में जांच करने की आवश्यकता है , चूंकि (7,3)पुनरावृत्ति होती है (3,7), और हो सकता है कि इसके लिए एक छोटी अभिव्यक्ति हो।

— xnor

अब यह किसी को भी भ्रमित करने की गारंटी है जो नहीं जानता (या भूल जाता है) कि (ए) ^एक्सओआर है, न कि एक्सपेंनेशन, या (बी) एक्सओआर की तुलना में कम पूर्वता है +।

— टिम पैडरिक

Answer 4

रेटिना , 100 बाइट्स

r+`(.*)(\d|(?!\4))( .*)(.?)
$2$4:$1$3
T` 0
+`1:11(1*:1*)11
:$1
^:*
:::
}`:(1*:1*:)11
1:1$1
(1)*:
$#1

यह इनपुट को अल्पविराम से अलग करता है। आउटपुट हमेशा तीन प्रमुख शून्य से शुरू होता है।

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

मैं वास्तव में आश्चर्य है कि अगर वहाँ पहले चरण के लिए एक छोटा सा समाधान है ...

Comments

नहीं, नहीं, स्कोर एकदम सही है;)

— कॉनर ओ'ब्रायन

-2 का अच्छा स्कोर!

— निक हार्टले

वाह। मैंने इस समाधान को तब नहीं देखा जब मैंने अपना पोस्ट किया था ... मेरे समाधान से बहुत अधिक श्रेष्ठ।

— लीक नून

@ केनीलाउ मैं बस इसे देख रहा था और सोच रहा था "एचएम, मुझे लगता है कि मुझे कुछ बिंदु पर स्पष्टीकरण जोड़ा जाना चाहिए ..."

— मार्टिन एंडर

...- 2i? यह दशमलव है, लेकिन कार्यक्रम एक आधार का उपयोग करता है जो नहीं।

— 15:75 पर user75200

Answer 5

जेली, 29 28 26 24 21 20 बाइट्स

DBḅ1100ḌµDL+8µ¡Dṣ2ṪḌ

यह दशमलव में I / O करता है। पूर्णांक को गैर-अल्फ़ान्यूमेरिक वर्ण द्वारा अलग किया जाना है +।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

पृष्ठभूमि

कॉम्प्लेक्स बेसिस में अंकगणित में , लेखक दिखाता है कि फॉर्म -n + i के आधारों में जटिल संख्याओं को कैसे जोड़ा और गुणा किया जाए ।

आधार -1 + i के लिए , इसके अतिरिक्त नियमित रूप से किया जाता है, बाइनरी कैरी के साथ दो अंतरों के साथ:

• 1 को अगले उच्च स्थान पर ले जाने के बजाय , हम 110 को अगले तीन पर ले जाते हैं।

• कैरी अंक अनिश्चित काल तक प्रचारित कर सकते हैं। हालांकि, अग्रणी शून्य के बिना, ए + बी में अधिकतम अ और ख की तुलना में अधिक से अधिक आठ अंक हैं ।

हम इस प्रकार आगे बढ़ते हैं।

1. सबसे पहले, हम एक और बी जोड़ते हैं जैसे कि उनके अंक दशमलव अंक थे।

   के लिए एक = 10101 और ख = 11011 , इस देता है 21,112 ।

2. 1 से बड़े प्रत्येक अंक के लिए , हमें उस अंक से 2 घटाना होगा और 110 को अगले तीन उच्च पदों पर ले जाना होगा। हम प्रत्येक दशमलव अंक को बाइनरी में कनवर्ट करके प्राप्त कर सकते हैं, जिसके परिणामस्वरूप बाइनरी सरणियां बेस 1100 से पूर्णांक तक होती हैं, और परिणामी सूची की व्याख्या 0 's, 1 ' s, 1100 's और 1101 के गैर-विहित आधार 10 के रूप में होती है। नंबर। ¹

   21112 की राशि के लिए , यह 21112 + 1098 * 10001 = 21112 + 10981098 = 11002210 देता है ।

3. हम चरण 2 को कुल d + 8 बार दोहराते हैं , जहां d एक + b के अंकों की संख्या है ।

   प्रारंभिक योग 21112 के लिए , परिणाम हैं

                         11002210
                         12210010
                       1220010010
                     122000010010
                   12200000010010
                 1220000000010010
               122000000000010010
             12200000000000010010
           1220000000000000010010
         122000000000000000010010
       12200000000000000000010010
     1220000000000000000000010010
   122000000000000000000000010010
   

4. हम अंतिम परिणाम से सभी लेकिन अंतिम d + 8 अंकों को छोड़ देते हैं। यह अंतिम 2 के बाद सब कुछ त्याग कर प्राप्त किया जाता है । ²

   प्रारंभिक योग 21112 के लिए , अंतिम परिणाम 10010 है ।

यह काम किस प्रकार करता है

DBḅ1100ḌµDL+8µ¡Dṣ2ṪḌ  Main link. Argument: a + b (implicit sum)

        µ    µ¡       Execute the chain before the first µ n times, where n is
                      the result of executing the chain before the second µ.
         D            Convert a + b to base 10.
          L           Length; count the decimal digits.
           +8         Add 8 to the number of digits.
D                     Convert the initial/previous sum to base 10.
 B                    Convert each digit (0 - 3) to binary.
  ḅ1100               Convert each binary array from base 1100 to integer.
       Ḍ              Interpret the resulting list as a base 10 number.
               D      Convert the final sum to base 10.
                ṣ2    Split at occurrences of 2.
                  Ṫ   Select the last chunk.
                   Ḍ  Convert from base 10 to integer.

---

¹ _{ध्यान दें कि इस राशि के अंक 3 से अधिक नहीं हो सकते हैं (प्रारंभिक मूल्य 1 प्लस दो 1 1 कैर्री से)।}

² _{यह काम करता है क्योंकि अंतिम अंक जो रद्द करेगा वह 3 नहीं हो सकता है ।}

Answer 6

पायथन 3, 289 बाइट्स

यह कम से कम सबसे महत्वपूर्ण अंकों (दूसरे शब्दों में, सटीक वही एल्गोरिथ्म जो आपको प्राथमिक विद्यालय में पढ़ाया गया था) से डिजिटाइज़ जोड़ देता है। अंतर यह है कि (ए) यह बाइनरी में है, दशमलव में नहीं है, इसलिए आप जब भी कोई अंक 2 या अधिक होता है, और (बी) 1 + 1 = 1100, नहीं ले जाते हैं 10।

दरअसल, यह भी ध्यान रखना आवश्यक है कि 11 + 111 = 0, या जो शून्य होना चाहिए, वह कभी समाप्त नहीं होगा।

from collections import*
def a(*s,p=0):
 r=defaultdict(int,{0:0})
 for S in s:
  n=0
  for d in S[::-1]:r[n]+=d=='1';n+=1
 while p<=max(r):
  while r[p]>1:
   r[p]-=2
   if r[p+1]>1<=r[p+2]:r[p+1]-=2;r[p+2]-=1
   else:r[p+2]+=1;r[p+3]+=1
  p+=1
 return str([*map(r.get,sorted(r))])[-2::-3]

अधिक गोल्फिंग निश्चित रूप से संभव है।

Comments

आप कितने निश्चित हैं कि आपका "शून्य डिटेक्टर" पर्याप्त है?

— याकूब

@ यक: एक से एक सहकर्मी-समीक्षा-पत्रिका के पैमाने पर, शायद इसे कोई प्रतिवाद दे?

— टिम पैडरिक

Answer 7

रेटिना, 157 151 134 134 133 124 123 बाइट्स

मार्टिन बर्टनर की बदौलत 1 बाइट।

(.+),(.+)
$.1$*0$2,$.2$*0$1,
1
0x
+`(0x*)(,.*)0(x*),
$2,$1$3
{`,

(^|0x0xx0xx)
000
(0x*)(0x*)(0x*0)xx
$1x$2x$3
)`^0+
0
0x
1

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

एकजुट करने के लिए धर्मान्तरित, और फिर निम्न प्रतिस्थापन (दशमलव में यहाँ दिखाया गया है) को दोहराएं:

122 -> 000
0002 -> 1100 (this can also be 0012 -> 1110 and 1112 -> 2210 or even 2222 -> 3320 or even 3333 -> 4431)

मूल रूप से, जब दो से बड़ा होता है: दो को हटा दें, पिछले अंक में कुछ भी न जोड़ें, पिछले अंक में एक जोड़ें, फिर पिछले अंक में एक जोड़ें।

छद्मकोश में:

if(a[n]>2):
    a[n] -= 2;
    a[n-2] += 1;
    a[n-3] += 1;

अनुपयोगी कार्यान्वयन:

प्रत्येक अंक (जैसे 3) को xs (जैसे xxx) की संख्या के रूप में दिखाया गया है और उसके बाद उपसर्ग किया गया है 0।

उदाहरण के लिए, के 1234रूप में व्यक्त किया जाएगा 0x0xx0xxx0xxxx।

यह 0अपरिवर्तित रहता है, जैसा 101कि व्यक्त किया जाएगा 0x00x।

शुरू और अंत में, केवल 0और है 1, रूपांतरण आसानी से 1->0xऔर किया जा सकता है 0x->1।

हर चरण को देखने के लिए यहां क्लिक करें ।

Answer 8

जावास्क्रिप्ट (ईएस 6), 146 126 बाइट्स

r=n=>n&&n%2-r(n>>=1)-i(n)
i=n=>n&&r(n>>=1)-i(n)
g=(x,y,b=(x^y)&1)=>x|y&&b+2*g(b-x+y>>1,b-x-y>>1)
(x,y)=>g(r(x)+r(y),i(x)+i(y))

gएक गाऊसी पूर्णांक (वास्तविक और काल्पनिक भागों) आधार में धर्मान्तरित i-1, जबकि rऔर iएक आधार धर्मान्तरित i-1(क्रमशः वास्तविक और काल्पनिक भागों) एक गाऊसी पूर्णांक में पूर्णांक। एक बार रूपांतरण होने के बाद, मुझे सिर्फ अंकगणित करना है।

संपादित करें: वास्तविक और काल्पनिक भागों की अलग-अलग गणना करके 20 बाइट्स सहेजे गए।

Answer 9

C ++ 416 बाइट्स, प्लस #include <vector>\n#include <algorithm>\n(एक और 40)

using I=int;using v=std::vector<I>;void r(v&x){v r{rbegin(x),rend(x)};x=r;}v a(v L,v R){r(L);r(R);L.resize(std::max(L.size(),R.size()));for(int&r:R)L[&r-R.data()]+=r;while(1){L.resize(L.size()+3);auto it=find(rbegin(L),rend(L),2);if(it==rend(L))break;I i=-1+it.base()-begin(L);i&&L[i+1]&&L[i-1]/2?L[i+1]=L[i]=L[i-1]=0:(++L[i+2],++L[i+3],L[i]=0);}L.erase( std::find(rbegin(L),rend(L),1).base(),end(L));r(L);return L;}

या, अधिक व्हाट्सएप के साथ:

using I=int;
using v=std::vector<I>;

void r(v&x){v r{rbegin(x),rend(x)};x=r;}
v a(v L,v R) {
  r(L);r(R);
  L.resize(std::max(L.size(),R.size()));
  for(int&r:R)
    L[&r-R.data()]+=r;
  while(1) {
    L.resize(L.size()+3);
    auto it=find(rbegin(L), rend(L), 2);
    if(it==rend(L)) break;
    I i=-1+it.base()-begin(L);
    i&&L[i+1]&&L[i-1]/2?
      L[i+1]=L[i]=L[i-1]=0
    :
      (++L[i+2],++L[i+3],L[i]=0);
  }
  L.erase( std::find(rbegin(L),rend(L),1).base(), end(L));
  r(L);
  return L;
}

बमुश्किल गोल्फ हुआ। यह चींटियों के वेक्टर के रूप में इनपुट लेता है, और चींटियों के एक वेक्टर को लौटाता है।

जीवंत उदाहरण ।