परिमेय संख्याओं के बिटवाइज़ XOR

Question

परिचय

0 और 1 के बीच हर तर्कसंगत संख्या को बिट्स के अंत में आवधिक अनुक्रम के रूप में दर्शाया जा सकता है। उदाहरण के लिए, 11/40 का द्विआधारी प्रतिनिधित्व है

0.010 0011 0011 0011 ...

जहां 0011भाग अनिश्चित काल तक दोहराता है। इस प्रतिनिधित्व को खोजने का एक तरीका निम्नलिखित है। आर = 11/40 से शुरू करें , फिर बार-बार इसे दोहराएं और भिन्नात्मक भाग लें, जब यह ऊपर जाता है तो रिकॉर्डिंग होती है। 1. जब आर का मूल्य दोहराता है, तो आप जानते हैं कि आपने लूप में प्रवेश किया है।

1. r = 11/40
2. 2*r = 11/20 < 1   ->  next bit is 0, r = 11/20
3. 2*r = 11/10 >= 1  ->  next bit is 1, r = 2*r - 1 = 1/10
4. 2*r = 1/5 < 1     ->  next bit is 0, r = 1/5
5. 2*r = 2/5 < 1     ->  next bit is 0, r = 2/5
6. 2*r = 4/5 < 1     ->  next bit is 0, r = 4/5
7. 2*r = 8/5 >= 1    ->  next bit is 1, r = 2*r - 1 = 3/5
8. 2*r = 6/5 >= 1    ->  next bit is 1, r = 2*r - 1 = 1/5, same as in 4.
   The loop 5. -> 6. -> 7. -> 8. now repeats.

बाइनरी स्ट्रिंग से 11/40 तक प्राप्त करने के लिए, आप सूत्र का उपयोग कर सकते हैं

(int(prefix) + int(suffix)/(2^len(suffix) - 1)) / 2^len(prefix)

जहां prefixप्रारंभिक हिस्सा है 010, suffixदोहराव वाला हिस्सा है 0011, और intबाइनरी स्ट्रिंग को पूर्णांक में परिवर्तित करता है।

ऐसे दो अभ्यावेदन को देखते हुए, हम उन पर बिटवाइज़ XOR ऑपरेशन कर सकते हैं। परिणामी अनुक्रम भी आवधिक होगा, इसलिए यह एक तर्कसंगत संख्या का प्रतिनिधित्व करता है।

कुछ तर्कसंगत संख्याओं के लिए, दो द्विआधारी प्रतिनिधित्व हैं।

1/4 = 0.010000000...
    = 0.001111111...

उनके बीच का चुनाव बिटवाइज़ XOR के परिणाम को प्रभावित कर सकता है। इन मामलों में, हम पूर्व प्रतिनिधित्व का उपयोग करते हैं, जिसमें असीम रूप से कई 0 हैं।

काम

आपके इनपुट आधे खुले अंतराल [0,1) में दो तर्कसंगत संख्याएँ हैं। आपका आउटपुट एक तर्कसंगत संख्या के रूप में व्यक्त किए गए इनपुट पर लागू बिटवाइज़ XOR ऑपरेशन का परिणाम होगा। ध्यान दें कि आउटपुट 1 हो सकता है, भले ही इनपुट में से कोई भी हो।

इनपुट और आउटपुट के सटीक प्रारूप लचीले होते हैं, लेकिन प्रत्येक तर्कसंगत संख्या को दो पूर्णांकों, अंश और हर (0 और 1 के अपवाद के साथ, जिसे वांछित 0और 1यदि वांछित किया जा सकता है) द्वारा दर्शाया जाना चाहिए । आप मान सकते हैं कि इनपुट सबसे कम शब्दों में व्यक्त किए गए हैं। आउटपुट को सबसे कम शब्दों में व्यक्त किया जाना चाहिए। एक अंतर्निहित तर्कसंगत संख्या प्रकार एक स्वीकार्य प्रारूप है, जब तक यह इन प्रतिबंधों को संतुष्ट करता है। आप अपनी भाषा द्वारा लगाए गए पूर्णांकों पर किसी भी सीमा को अनदेखा कर सकते हैं, लेकिन आपके एल्गोरिथ्म को सैद्धांतिक रूप से सभी तर्कसंगत संख्याओं के लिए काम करना चाहिए।

सबसे कम बाइट गिनती जीतती है। मानक कोड-गोल्फ नियम लागू होते हैं।

उदाहरण

11/40 और 3/7 इनपुट पर विचार करें। हम पाइप के द्वारा दोहराए जाने वाले भागों का परिसीमन करते हुए, एक के ऊपर एक उनके निरूपण लिखते हैं |। फिर हम समान लंबाई के भागों को दोहराते हुए निकालते हैं, और उनके और उनके सामने के हिस्सों में बिटवाइर XOR लगाते हैं।

11/40 = 0. 0 1 0|0 0 1 1|0 0 1 1|0 0 1 1|0 0 1 1|0 0 1 1|0 0 1 1|0 0 1 ...
3/7   = 0.|0 1 1|0 1 1|0 1 1|0 1 1|0 1 1|0 1 1|0 1 1|0 1 1|0 1 1|0 1 1|...
     -> 0. 0 0 1|0 1 0 1 1 1 1 0 1 0 0 0|0 1 0 1 1 1 1 0 1 0 0 0|0 1 0 ...

परिणामी परिमेय संख्या 89/520 है।

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

0 0 -> 0
1/2 1/2 -> 0
1/2 1/4 -> 3/4
1/3 2/3 -> 1
1/2 3/4 -> 1/4
5/8 1/3 -> 23/24
1/3 1/5 -> 2/5
15/16 3/19 -> 257/304
15/16 257/304 -> 3/19
3/7 11/40 -> 89/520
5/32 17/24 -> 59/96
16/29 16/39 -> 621001733121535520/696556744961512799

Comments

हमें समर्थन करने के लिए किस अधिकतम अवधि की आवश्यकता है?

— नील

@ नील क्या आपको लगता है कि ऐसा अधिकतम मौजूद है?

— orlp

नोट: कुछ संख्याओं में दो द्विआधारी विस्तार हैं, अर्थात् उन संख्याओं में जहां अंतिम अवधि की लंबाई एक है। यह उपरोक्त समस्या की परिभाषा में निहित है कि हमें000...इस मामले मेंसमाप्त होने वाले प्रतिनिधित्व को चुनना चाहिए(यदि हम एल्गोरिथ्म का उपयोग करते हैं तो यह भी है जो हमें मिलता हैr)। उदाहरण के लिए, मामले में5/8, 1/3हमें मिलता है23/24क्योंकि हम विस्तार के0.101000...लिएचुनते हैं5/8। अगर हम बजाय चयन0.10011111...के रूप में5/8, परिणाम के बाद XOR हो जाता है19/24, तो यह गलत है। विकिपीडिया से

— जेपी स्टिग नीलसन

@JeppeStigNielsen लानत ... इसका मतलब है कि नियमित XOR के विपरीत (a ^ b) ^ b == aपकड़ नहीं है। जैसे (19/24 ^ 1/3) ^ 1/3 != 19/24। इसने मुझे इस बारे में काफी उत्साह खो दिया :(

— orlp

यह भी देखें कि बिटकॉइन ऑपरेटर 3 डी में कैसा दिखता है? गणित पर ।

— इल्मरी करोनें

Answer 1

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

def x(a,b,z=0):
 l=[]
 while(a,b)not in l:l+=[(a,b)];z=2*z|(a<.5)^(b<.5);a=a*2%1;b=b*2%1
 p=l.index((a,b));P=len(l)-p
 return((z>>P)+z%2**P*a**0/~-2**(P or 1))/2**p

पायथन 3 के fractions.Fractionप्रकार के रूप में इनपुट लेता है , और इसे आउटपुट भी करता है।

मजेदार तथ्य (आप इसे आसानी से उत्पन्न कार्यों का उपयोग करके दिखा सकते हैं), यदि आप बाइनरी पाने के (a<.5)^(b<.5)लिए ((a>=.5)and(b>=.5))ऊपर और दो तर्कसंगत संख्याओं के बीच बदलते हैं । इसको बुलाओ nd(a, b)। फिर हमारे पास है a + b - 2*nd(a, b) = x(a, b)!

Comments

दरअसल, मेरी गलती है। क्षमा याचना! (ध्यान दें कि उत्तर में शामिल tio का लिंक बहुत अच्छा होगा)

— श्री एक्सकोडर

Answer 2

जावास्क्रिप्ट, 141 बाइट्स

(p,q,r,s)=>(h=(v,u)=>v%u?h(u,v%u):[a/u,b/u])(b=(g=x=>x%q||x%s?g((x|x/2)+x%2):x)(1),a=(o=b/(b-(b&~-b)),x=p*b/q,y=r*b/s,(x%o^y%o)+(x/o^y/o)*o))

पिछले परीक्षण मामले (पूर्णांक अतिप्रवाह) के लिए काम नहीं करेंगे। इनपुट 4 नंबरों के लिए p/q xor r/s, दो नंबरों के साथ एक सरणी आउटपुट। टेस्टकेस के लिए 0, 0, आपको इनपुट करना चाहिए 0, 1, 0, 1।

किस तरह:

(यहां वर्णित सभी संख्याएं द्विआधारी रूप में हैं।)

1. सबसे छोटी संख्या पाते हैं b, जो b = 10 ^ p - 10 ^ q (p, q are integers, p > q); and b = 0 (mod q); and b = 0 (mod s);
2. चलो x = p * b / q, y = r * b / q; कन्वर्ट करने के लिए p / q, और ;r / sx / by / b
3. आज्ञा देना o = 10 ^ (p - q) - 1; विभाजन x, yको [x % o, x / o], को [y % o, y / o]; प्रत्येक भाग के लिए xor प्राप्त करें [x % o xor y % o, x / o xor y / o], और वापस शामिल हों (x % o xor y % o) + (x / o xor y / o) * o; इसे दान के रूप में a;
4. यदि a = 0, उत्तर है 0(या 0 / 1); नहीं तो चलो u = gcd(a, b); जवाब है (a/u)और (b/u)।

f=

(p,q,r,s)=>(h=(v,u)=>u%v?h(u%v,v):[a/v,b/v])(b=(g=x=>x%q||x%s?g((x|x/2)+x%2):x)(1),a=(o=b/(b-(b&~-b)),x=p*b/q,y=r*b/s,(x%o^y%o)+(x/o^y/o)*o))

<div oninput="[v5.value,v6.value]=['?','?'];[v5.value,v6.value]=f(+v1.value,+v2.value,+v3.value,+v4.value)">
<input id=v1 />/<input id=v2 /> xor <input id=v3 />/<input id=v4 /> = <output id=v5></output> / <output id=v6></output>
<style>input{width:40px}</style>
</div>