हिल्बर्ट का बाइनरी होटल

Question

इस चुनौती में आपको दो गुणों को पूरा करने वाले किसी भी कार्य (या पूर्ण कार्यक्रम) को लागू करने के लिए कहा जाएगा। वे गुण हैं:

• आपका कार्य बहुपद से गैर-ऋणात्मक पूर्णांकों के गैर-ऋणात्मक पूर्णांकों के साथ बहुपद से एक इंजेक्शन (प्रतिवर्ती) कार्य होना चाहिए। इसका मतलब है कि कोई भी दो असमान इनपुट समान आउटपुट के लिए मैप नहीं कर सकते हैं।

• आपके फ़ंक्शन को इनपुट से इसके आउटपुट तक "बिट्स" की कुल संख्या को संरक्षित करना होगा। इसका मतलब है कि यदि आप बहुपद के प्रत्येक गुणांक के 1 बिट्स की गणना करते हैं, तो उनका योग आउटपुट के बाइनरी प्रतिनिधित्व में 1 बिट की संख्या के समान होना चाहिए। उदाहरण के लिए 9है 1001तो यह 2 है बाइनरी में 1बिट्स।

---

आईओ

एक गैर-नकारात्मक पूर्णांक बहुपद गैर-ऋणात्मक पूर्णांकों की अनंत सूची के समान है, जो एक निश्चित बिंदु के बाद सभी पूर्णांक शून्य होते हैं। इस प्रकार, बहुपद को या तो अनंत सूचियों द्वारा दर्शाया जा सकता है (हालाँकि यह शायद अवांछनीय है) या सूची के अंत के बाद निहित शून्य के साथ परिमित सूचियों द्वारा।

बहुपद और परिमित सूची के बीच प्रमुख अंतर यह है कि एक सूची के अंत में एक शून्य जोड़ने से सूची बदल जाएगी:

एक बहुपद के अंत में एक शून्य जोड़ने पर इसका मान नहीं बदलता है:

इस प्रकार यदि आपका कार्य इनपुट के रूप में एक बहुपद का प्रतिनिधित्व करने के लिए एक परिमित सूची लेता है, तो शून्य को जोड़ने से इसका परिणाम नहीं बदलना चाहिए।

सूची के रूप में बहुपद का प्रतिनिधित्व करते समय, आप उनका प्रतिनिधित्व कर सकते हैं या तो पहली या आखिरी प्रविष्टि के साथ निरंतर शब्द का प्रतिनिधित्व करते हैं। उदाहरण के लिए आपके पास निम्नलिखित में से कोई भी संभावना हो सकती है:

पहले मामले में, सूची के अंत में शून्य जोड़ने से परिणाम में बदलाव नहीं होना चाहिए; दूसरे मामले में, सूची के सामने शून्य जोड़ने से परिणाम नहीं बदलना चाहिए।

यदि आपकी भाषा बहुपद का समर्थन करती है तो आप उन्हें इनपुट के रूप में ले सकते हैं।

आउटपुट किसी भी मानक तरीकों से एक गैर-नकारात्मक पूर्णांक आउटपुट होना चाहिए।

---

यह कोड-गोल्फ है इसलिए उत्तर बाइट्स में स्कोर किए जाएंगे, कम बाइट बेहतर होने के साथ।

Comments

है []या [0]एक मान्य इनपुट?

— जुंगह्वान मिन

@ जुंगहवनमाइन हां, दोनों हैं, वे शून्य बहुपद हैं।

— रॉक गार्फ हंटर

मुझे पता है कि आप 1 को शून्य से विभाजित करने का मतलब रखते हैं, लेकिन कुछ तरीके काम कर सकते हैं और यह अच्छा नहीं लगता ...

— l4m2

@ l4m2 मुझे क्षमा करें, लेकिन मैं आपकी किसी भी टिप्पणी को नहीं समझता। जहाँ तक आपका सवाल है, अग्रणी शून्य क्या है? बहुपद, गुणांक? मुझे यकीन नहीं है कि आप "शून्य नहीं लिखा" से क्या मतलब है।

— पोस्ट रॉक गार्फ हंटर

क्या वास्तव में चित्र आवश्यक हैं (अर्थात उन्हें समृद्ध पाठ का उपयोग करके प्रस्तुत नहीं किया जा सकता है) ??? क्योंकि छवियों को देखने की क्षमता के बिना लोग अपनी चुनौती को पूरी तरह से नहीं देख सकते हैं।

— माइंडविन

Answer 1

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

BFṢḄæ«ÆẸ

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

बाएं उलटा, 5 बाइट्स

Bċ0ÆE

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

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

BFṢḄæ«ÆẸ  Main link. Argument: A (array)

B         Binary; convert each integer in A to base 2.
 F        Flatten; concatenate the resulting binary arrays.
  Ṣ       Sort the resulting bit array.
   Ḅ      Convert from base 2 to integer, yielding an integer x with as much set
          bits as there are set bits in A.
      ÆẸ  Unexponents; convert A = [a1, a2, ...] to y = (p1**a1 + p2**a2 + ...),
          where pn is the n-th prime number.
          By the fundamental theorem of arithmetic, the resulting integer is unique
          for each array A without trailing zeroes.
    æ«    Bitshift left; compute x * 2**y.

Answer 2

वोल्फ्राम भाषा (गणितज्ञ) , 36 20 बाइट्स

x#/.x->2^(#/.x->2)!&

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

इनपुट के रूप में एक बहुपद f (x) लेता है। Y * f (y) का मूल्यांकन करता है, जहां y = 2 ^ (f (2)!)। अफसोस, इसका मतलब है कि आउटपुट बहुत बड़े हैं।

जब भी y किसी गुणांक से 2 बड़ा होता है, तो 1-बिट्स की संख्या को संरक्षित करते हुए y * f (y) का मूल्यांकन किया जाएगा, जो ऊपर दिए गए मान के लिए सही है। हम y = 2 ^ (f (2)!) का चयन करते हैं ताकि परिणाम को इंजेक्टिव बनाया जा सके:

• Y के समान मान वाले दो अलग-अलग इनपुट अलग-अलग आउटपुट देंगे क्योंकि हम मूल रूप से y में दो अलग-अलग संख्याएँ पढ़ रहे हैं।
• यदि हम k = f (2) और इसलिए y को ठीक करते हैं, तो y का सबसे छोटा मान * f (y) तब प्राप्त होता है जब इनपुट k के बराबर एक स्थिर बहुपद होता है और सबसे बड़ा मान तब प्राप्त होता है जब इनपुट आधार देने वाला बहुपद होता है -2 का विस्तार। पहले मामले में, y * f (y) = 2 ^ (k!) * K, और दूसरे मामले में, y * f (y) <2 ^ (k! * Ceil (lg k)), जो कम है 2 ^ से ((k + 1)!) * (k + 1)।
• परिणामस्वरूप, दो बहुपद f और g के साथ f (2) <g (2) के लिए, हमें प्राप्त होने वाला पूर्णांक उस पूर्णांक से कम होगा जो हम g से प्राप्त करते हैं।

Answer 3

वोल्फ्राम भाषा (गणितज्ञ) , 61 बाइट्स

Tr[2^((2#2-1)2^#)&@@@Position[Reverse/@#~IntegerDigits~2,1]]&

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

दो सकारात्मक पूर्णांकों को एक एकल सकारात्मक पूर्णांक में मैप किया जा सकता है। आज्ञा a, bदेना दो सकारात्मक पूर्णांकों। फिर a, b -> (2a - 1) 2^(b-1)एनएक्सएन से एन तक एक जीवनी है।

यह फ़ंक्शन 1इनपुट (1 एस स्थान से) में सभी बिट्स की स्थिति का पता लगाता है , और प्रत्येक स्थिति के लिए उपरोक्त नक्शे का एक इंजेक्शन-केवल वैरिएंट लागू करता है। फिर, प्रत्येक परिणामी संख्या को दो की शक्ति तक बढ़ाया जाता है, और सभी संख्याओं को एक साथ जोड़ा जाता है (जो कि ठीक है क्योंकि हमने एक इंजेक्शन NxN -> एन मानचित्र लागू किया है)।

उदाहरण के लिए:

{1, 2, 3}
{{1}, {1, 0}, {1, 1}}             (* Convert to binary *)
{{1}, {0, 1}, {1, 1}}             (* Reverse each *)
{{1, 1}, {2, 2}, {3, 1}, {3, 2}}  (* Position of 1s *)
{2, 12, 8, 24}                    (* Inject to N *)
{4, 4096, 256, 16777216}          (* Raise to the power of 2 *)
16781572                          (* Add *)

उलटा फ़ंक्शन (124 बाइट्स)

##+#&~Fold~#&@*Reverse/@Normal@SparseArray[{Log2[j=#~BitAnd~-#],(#/j+1)/2}->1&@@@(Reverse[#~IntegerDigits~2]~Position~1-1)]&

यहाँ इंजेक्शन के लिए परीक्षण करने के लिए एक उलटा कार्य है।

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

Answer 4

पायथन 2 , 118 117 114 103 100 बाइट्स

जोनाथन फ्रेच द्वारा 100 बाइट्स:

a=input()
while a[0]<1:a.pop(0)
y="".join("2"+bin(v)[2:]for v in a)
print~-2**y.count("1")<<int(y,3)

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

एक गोल्फ संभावना ^{1 के} साथ 103 बाइट्स

a=input()
while a[0]<1:a.pop(0)
x="".join(map(bin,a))
print~-(1<<x.count("1"))<<int(x.replace(*"b2"),3)

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

-15 बाइट्स के लिए धन्यवाद जोनाथन फ्रेच

यह एक संख्या बनाता है जिसमें पहले "बिट्स पर" होता है और फिर एक त्रिकोणीय संख्या के रूप में व्याख्या की गई सरणी का एकात्मक प्रतिनिधित्व होता है।

त्रिकोणीय संख्या को संख्याओं को बाइनरी स्ट्रिंग्स ( 0bNNN) में परिवर्तित करके बनाया जाता है , फिर उसके bसाथ प्रतिस्थापित किया जाता है 2।

¹ मैं 14 बाइट्स को आधार -12 नंबर में परिवर्तित करके सहेज सकता था, लेकिन TIO मेमोरी से बाहर चला गया इसलिए मैंने इसका उपयोग करने का निर्णय लिया।

Comments

@JonathanFrech बहुत बहुत धन्यवाद :)

— fergusq

Answer 5

05AB1E , 14 बाइट्स

gÅpImPoIbS{2β*

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

डेनिस जैली समाधान के रूप में एक ही परिणाम देता है, फिर भी तकनीक थोड़ा अलग है।

कैसे?

आइए इनपुट की कोशिश करें [1, 2, 3]:

gÅpImPoIbS{2β* | Full program.
               | STACK: [[1, 2, 3]]
               |
g              | Push the length.
               | STACK: [3]
 Åp            | Generate the first N primes.
               | STACK: [[2, 3, 5]]
   Im          | Push the input, and apply pairwise exponentiation.
               | STACK: [2, 9, 125]
     P         | Push the product.
               | STACK: 2250
      o        | Push 2 ** N.
               | STACK: 2 ** 2250 (way too large)
       Ib      | Push the input and convert to binary.
               | STACK: [2 ** 2250, ['1', '10', '11']].
         S{    | Sort all the characters.
               | STACK: [2 ** 2250, ['0', '1', '1', '1', '1']]
           2β  | Convert from binary.
               | STACK: [2 ** 2250, 15]
             * | Multiplication.
               | STACK: [2 ** 2250 * 15]
               | Implicitly print the top of the stack (2 ** 2250 * 15).

Answer 6

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

r='print 0';s='<<'
for n in input():r+=oct(n)[:0:-1];s+='0'+'1'*n
exec r+s

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

Answer 7

जावास्क्रिप्ट 6, 96 83 बाइट्स

x=>(t=x.map(k=>(x[0]+=k)&&2+k.toString(2)).join``).replace(/0|2/g,'')+'0'.repeat(t)

एक द्विआधारी अभिव्यक्ति का उत्पादन

([1,2]) => 3*2^21210(Decimal)
([0,1,2]) => 3*2^21210
([1,2,0]) => 3*2^2121020
([1,2,3,4]) => 31*2^212102112100(Threotically)

Comments

शून्य एक रिक्त स्ट्रिंग का नेतृत्व करेगा जो शून्य का प्रतिनिधित्व करता है

— l4m2

replace(/0|2/g,0)काम भी लगता है, लेकिन डिकोड करना कठिन है

— l4m2

के बारे में निश्चित नहीं है x=>(t=x.map(k=>(x[0]+=k)&&2+k.toString(2)).join``).replace(/2/g,'0'.repeat(t))। ठीक लग रहा है लेकिन साबित नहीं कर सकता

— l4m2