एक द्विआधारी खोज के लिए चरणों की संख्या

Question

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

हम उस पूर्णांक के लिए एक द्विआधारी खोज का अनुकरण कर रहे हैं जो इनपुट के रूप में दिया गया था, जिसमें नकली खोजकर्ता एक पूर्णांक का अनुमान लगा सकता है और बताया जा सकता है कि क्या यह बहुत अधिक है, बहुत कम है, या सही है। पूर्णांक खोजने की रणनीति इस प्रकार है:

• चलिए पूर्णांक को इनपुट के रूप में दिया जाता है जिसे हम खोजने की कोशिश कर रहे हैं।

• 1 के एक अनुमान के साथ शुरू करें। (हर अनुमान के लिए, चरणों की संख्या बढ़ाएँ (चाहे यह सही था या नहीं), और तुरंत बंद कर दें और यदि अनुमान सही था, तो कुल चरणों की संख्या को आउटपुट करें।)

• जब तक अनुमान n (लक्ष्य संख्या) से अधिक न हो जाए तब तक अनुमान को दोहराएं। (या यदि यह सही है, लेकिन यह पहले से ही हमारे सही-अनुमान नियम द्वारा कवर किया गया है।)

• अब, 2 की पहली शक्ति का एक ऊपरी बाउंड सेट करें जो n से अधिक है (यानी संख्या जो कि केवल अनुमान लगाया गया था), और इसके ठीक नीचे 2 की शक्ति की एक निचली बाउंड सेट करें।

• बार-बार ऊपरी सीमा और निचली सीमा के औसत (गोल नीचे) का अनुमान लगाते हैं। यदि यह बहुत अधिक है, तो इसे ऊपरी बाउंड के रूप में सेट करें। यदि यह बहुत कम है, तो इसे निचले बाउंड के रूप में सेट करें। यह प्रक्रिया अंततः एक सही अनुमान में परिणाम की गारंटी है।

यहाँ एक उदाहरण है n = 21 के इनपुट के लिए:

1 -> 2 -> 4 -> 8 -> 16 -> 32 -> 24 -> 20 -> 22 -> 21
\__________________________/
   repeated doubling      \________________________/
                             repeated averaging

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

यहाँ n = 1 से n = 100 तक सभी आउटपुट हैं:

1
2
4
3
6
5
6
4
8
7
8
6
8
7
8
5
10
9
10
8
10
9
10
7
10
9
10
8
10
9
10
6
12
11
12
10
12
11
12
9
12
11
12
10
12
11
12
8
12
11
12
10
12
11
12
9
12
11
12
10
12
11
12
7
14
13
14
12
14
13
14
11
14
13
14
12
14
13
14
10
14
13
14
12
14
13
14
11
14
13
14
12
14
13
14
9
14
13
14
12

और यहाँ कुछ बड़े परीक्षण मामले हैं:

1234 -> 21
1337 -> 22
3808 -> 19
12345 -> 28
32768 -> 16
32769 -> 32
50000 -> 28

Answer 1

जाप, 13 12 बाइट्स

हे मेरे गोश मैं एक समय के लिए जेली और अजगर दोनों को पीट रहा था: डी

¢a1 ªJ +1+¢l

इसे ऑनलाइन टेस्ट करें!

यहाँ रणनीति मैं फायदा नहीं है: चलो एक्स इनपुट पूर्णांक होना, और ख हो एक्स के द्विआधारी प्रतिनिधित्व। सही आउटपुट 1 + बी की लंबाई है + बी में 1 का अंतिम सूचकांक , शून्य से 1 यदि यह सूचकांक 0 है।

Comments

मैंने तुमसे कहा था कि डेनिस जीत जाएगा।

— 2

Answer 2

जेली, 18 15 10 9 बाइट्स

B>WU;BḄBL

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

पृष्ठभूमि

चलो n एक सकारात्मक पूर्णांक हो सकता है और मीटर के सबसे छोटे शक्ति 2 कि अधिक से अधिक या से बराबर या के बराबर है n ।

• दोहरीकरण चरण के द्विआधारी प्रतिनिधित्व में प्रत्येक अंक के लिए एक कदम लेता मीटर ।

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

की गणना से बचने के लिए मीटर , हम उस का निरीक्षण, यदि n <मीटर , की बाइनरी अंकों की संख्या n ठीक एक की बाइनरी अंकों की संख्या से कम है मीटर ।

अगर हम के पहले बाइनरी अंक की जगह एन एक साथ 0 , परिणाम रिवर्स, संलग्न मूल बाइनरी अंकों और सभी प्रमुख शून्य निकालने के लिए, उसके बाद निम्न होता है:

• यदि n 2 की शक्ति है , तो पहले (संशोधित) आधे के सभी अंक हटा दिए जाते हैं, केवल n = m के मूल बाइनरी प्रतिनिधित्व के अंकों को छोड़ देते हैं ।

• यदि n है नहीं की शक्ति 2 , पहली छमाही कि सबसे महत्वपूर्ण अंकों से मेल खाती है में अंकों नहीं निकाल दिए जाते हैं, तथ्य यह है कि के लिए मुआवजा n एक बाइनरी अंक की तुलना में कम है मीटर ।

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

B>WU;BḄBL  Main link. Input: n

B          Compute the binary representation of n.
 >W        Compare it with [n].
           n is positive, so it is not less than the first binary digit and the
           comparison yields zero. When comparing lists of different length, the
           elements in the longer list that do not have a pair remain untouched.
           Therefore, this will just zero out the first binary digit.
   U       Reverse the modified binary representation.
    ;B     Concatenate it with the unmodified binary representation of n.
      ḄB   Convert from binary to integer, and back to binary.
           This removes leading zeroes.
        L  Get the length of the resulting array.

Comments

’B;Bt0L(7 बाइट्स) मेरे जूलिया जवाब में उसी दृष्टिकोण का उपयोग करते हुए, जेली के नवीनतम संस्करण में काम करता है ।

— डेनिस

Answer 3

ईएस 6, 38 बाइट्स

x=>33-(g=Math.clz32)(x-1)+g(x&-x)-g(x)

जैसा कि अन्य उत्तरों से समझा जाता है, आप पहले और अंतिम बिट्स के पदों की संख्या की गणना कर सकते हैं।

दोहरीकरण चरण में चरणों की संख्या है n=33-Math.clz32(x-1)। हम 2ⁿ but x चाहते हैं लेकिन n=33-Math.clz32(x)हमें 2ⁿ> x देता है इसलिए हम क्षतिपूर्ति करने के लिए x से 1 घटाते हैं।

औसत चरण में चरणों की संख्या आसान है, बस है n=Math.clz32(x&-x)-Math.clz32(x)। x&-xएक आसान अभिव्यक्ति है जो सबसे कम बिट x(2 की शक्ति के रूप में) का मूल्यांकन करती है ।

Comments

कैसे x&-xकाम करता है ? मैंने सोचा होगा कि यह एक्स के पूर्ण मूल्य का मूल्यांकन करेगा।

— ETHproductions

मुझे इस पृष्ठ पर एक अच्छा स्पष्टीकरण मिला (देखें बिट-हैक # 7)।

— ETHproductions

Answer 4

पायथ, 15 13 बाइट्स

h-y.ElQ/PPyQ2

मैंने पाया है कि गणना की जाने वाली संख्या है 1 + 2*ceil(log_2(x)) - [number of 2s in x's prime factorization, minus 1 if x is a power of 2 greater than 1].

इसे यहाँ आज़माएँ ।

Answer 5

जूलिया, 37 35 बाइट्स

n->endof(strip(bin(n-1)bin(n),'0'))

@AlexA को धन्यवाद। 2 बाइट बचाने के लिए!

यह मेरे जेली उत्तर से टिप्पणियों का अनुसरण करता है , लेकिन किनारे के मामलों से अलग ढंग से संबंधित है।

यदि n> 1 , n - 1 का बाइनरी प्रतिनिधित्व 2 की अगली शक्ति से एक अंक कम है , जो n के बाइनरी प्रतिनिधित्व के पहले अंक को नहीं हटाकर मुआवजा दिया जाता है ।

दोनों तरफ से सभी शून्य को हटाकर , हम किनारे के मामले 1 के साथ भी निपटते हैं ।

Answer 6

हास्केल, 82 बाइट्स

हास्केल में यह एक बहुत ही सरल कार्यान्वयन है:

f x=[j|j<-[1..],let g i|i<2=1|x>g(i-1)=2*g(i-1)|1<2=div(g(i-1)+g(i-2))2,g j==x]!!0

कम गोल्फ वाला:

f x = head [ stepNum | stepNum <- [1..], step stepNum == x]
  where
    prevStep i = step (i-1)
    step i | i == 1         = 1
           | x > prevStep i = 2 * prevStep i
           | otherwise      = div (prevStep i + step (i-2)) 2