किसी भी सकारात्मक 32-बिट पूर्णांक ( 1 ≤ n ≤ 0xFFFFFFFF) के लिए उस पूर्णांक का प्रतिनिधित्व करने के लिए आवश्यक बिट्स की संख्या को आउटपुट करता है।

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

| n    | n in binary | bits needed |
|----------------------------------|
| 1    | 1           | 1           |
| 2    | 10          | 2           |
| 3    | 11          | 2           |
| 4    | 100         | 3           |
| 7    | 111         | 3           |
| 8    | 1000        | 4           |
| 15   | 1111        | 4           |
| 16   | 10000       | 5           |
| 128  | 10000000    | 8           |
| 341  | 101010101   | 9           |

4294967295 => 11111111111111111111111111111111 => 32

तो f(16)छपेगा या लौटेगा5

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

code-golf binary

— बैसड्रॉब कंबरवुबवबब
स्रोत

2

यह आधार -2 लघुगणक की छत है।

— orlp

23

@orlp यह वास्तव में हैfloor(log2(num))+1

— क्रिस्सी लिथोस

2

@ कृतिलीथोस राइट।

— orlp

3

कोई बात नहीं, बस एहसास हुआ कि अलग महत्वपूर्ण है जब numदो की शक्ति है।

— ब्रायन जे

11

यह एक तुच्छ चुनौती है जिसमें बहुत सारे तुच्छ समाधान हैं। हालांकि कुछ गैर-तुच्छ समाधान भी हैं। मतदाताओं को: बिलियन फ़ंक्शन को बढ़ाने से पहले कृपया इस मेटा पोस्ट का पहला वाक्य पढ़ें । (विनम्रतापूर्वक इस टिप्पणी से लिया गया है )

— कृतिका लिथोस

30

05AB1E , 2 बाइट्स

bg

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

— जादू ऑक्टोपस Urn
स्रोत

16

गूढ़ भाषा फिर से जीती ...bg

— devRicher

20

@devRicher मुझे ईमानदार होने के लिए अभी भी 1 बाइट समाधान द्वारा पीटा जाने की उम्मीद है।

— मैजिक ऑक्टोपस Urn

9

कम से कम इस जवाब को यह ऊपर उठता है; यह अंदर नहीं है bg।

— NoOneIsHere 21

3

bgगेमिंग में इसका मतलब है bad game:)

— YoYoYonnY

1

@yoyoyonny या युद्ध का मैदान haha।

— मैजिक ऑक्टोपस Urn

35

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

f=n=>n&&1+f(n>>>1)

<input type=number min=0 step=1 value=8 oninput="O.value=f(this.value)">
<input id=O value=4 disabled>

स्निपेट का विस्तार करें

— ETHproductions
स्रोत

यह कुछ गैर तुच्छ समाधानों में से एक है। अच्छी रणनीति!

— क्रिस्ति लिथोस

1

क्या इसका n>>>1समर्थन करना चाहिए n > 0x7FFFFFFF?

— अरनुलद

@Arnauld हम्म, उस उच्च >>पर विफल नहीं पता था n। धन्यवाद।

— ETHproductions

अच्छा, मेरा पहला प्रयास थाf=(a,b=1)=>a>1?f(a>>1,++b):b

— बैसड्रॉप कंबरवुबवबूब

28

x86 असेंबली, 4 बाइट्स

में निरंतर मान EBX:

bsr eax,ebx
inc eax

EAX में निरंतर के लिए आवश्यक बिट्स की संख्या समाहित है।

बाइट्स: ☼¢├@

हेक्साडेसिमल: ['0xf', '0xbd', '0xc3', '0x40']

— z0rberg के
स्रोत

2

क्या आप कृपया वास्तविक 8 बाइट संकलित x86 असेंबली कोड का एक हेक्सडंप शामिल कर सकते हैं?

— लवोजो

ऐसा किया। और धन्यवाद, क्योंकि मुझे एहसास हुआ कि मैंने गलती की है। मैंने नियमों को फिट करने के लिए एक "inc eax" जोड़ा। मैं एक बाइट हार गया। :(

— z0rberg की

अरे वाह आपने मेरी पोस्ट को उचित फॉर्मेटिंग में बदल दिया। इसे सही करने के लिए धन्यवाद!

— z0rberg का

2

वैसे, विधानसभा प्रस्तुतियाँ मान सकती हैं कि इनपुट पहले से ही एक विशिष्ट रजिस्टर में संग्रहीत है , इसलिए मुझे लगता है कि आप इस तरह से कुछ बाइट्स से दाढ़ी बना सकते हैं।

— लोवजो 20

1

क्या विधानसभा भाषा स्रोत कोड के बजाय संकलित मशीन कोड के बाइट्स की संख्या के रूप में विधानसभा प्रस्तुतियाँ गिनना प्रथा है?

— SMLS

18

अजगर , 14 बाइट्स

int.bit_length

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

— डेनिस
स्रोत

यह पायथन 2 में भी काम करता है।

— तिजोरी

1

यह वास्तव में करता है। पायथन 2 का इंट 64 बिट्स नहीं 32 बिट्स चौड़ा था।

— डेनिस

अजगर 3 का bit_lengthहै bit_length()।

— डेफरन

2

@ डफरन यह एक फ़ंक्शन कॉल नहीं है; यह एक समारोह है। यदि n एक इंट है , int.bit_length(n)और n.bit_length()ठीक वैसा ही करें।

— डेनिस

2

@ डफरन int.bit_length(n)एक फ़ंक्शन कॉल है , और इस प्रकार एक स्निपेट जो इनपुट मानता है कि एक चर में संग्रहीत है। यह हमारे नियमों द्वारा अनुमत नहीं है, इसलिए (n)इसे लागू करना इस उत्तर को अमान्य बना देगा। हालांकि, int.bit_lengthएक फ़ंक्शन का मूल्यांकन करता है और बाद में उपयोग के लिए एक चर में बचाया जा सकता है। यह डिफ़ॉल्ट रूप से अनुमत है।

— डेनिस

15

भूलभुलैया , 13 12 बाइट्स

 ?
_:
2/#(!@

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

व्याख्या

कार्यक्रम केवल बार-बार इनपुट को 2 से विभाजित करता है जब तक कि यह शून्य न हो। प्रत्येक चरण में मूल्य की नकल करके चरणों की संख्या पर नज़र रखी जाती है। एक बार जब यह शून्य से कम हो जाता है तो हम स्टैक डेप्थ (माइनस 1) प्रिंट करते हैं।

कार्यक्रम शुरू होता है ?जिसमें इनपुट पढ़ता है। मुख्य लूप तब नीचे 2x2 ब्लॉक होता है, जो काउंटर-क्लॉकवाइज होता है:

:   Duplicate current value.
_2  Push 2.
/   Divide.

पूर्ण पुनरावृत्ति के बाद मान शून्य हो जाने पर, अंत में रैखिक बिट निष्पादित होता है:

#   Push stack depth.
(   Decrement.
!   Print.
@   Terminate.

— मार्टिन एंडर
स्रोत

5

यह समाधान पूर्ण है - यह इनपुट लेता है और उत्तर प्रदान करता है, और इस विशिष्ट उद्देश्य के लिए किसी भी मौजूदा फ़ंक्शन का उपयोग नहीं करता है - यह मैन्युअल रूप से उत्तर की गणना करता है। मेरे लिए यह अधिकांश अन्य उत्तरों की तुलना में खेल की भावना में अधिक है।

— जोहान

15

सी, 31 बाइट्स

f(long n){return n?1+f(n/2):0;}

... फिर मैंने पुनरावृत्ति के बारे में सोचा। अस्पष्ट से स्पष्ट तक, और लंबाई का एक चौथाई भाग छूट गया।

इसे कोलिरु पर लाइव देखें

सी, 43 बाइट्स

c;
#define f(v)({for(c=0;v>=1l<<c;++c);c;})

अहस्ताक्षरित मान (जैसे ) के fसाथ कॉल करने से इसकी थोड़ी लंबाई "वापस" हो जाएगी। यहां तक कि काम भी करता है !f(42u)0u

अधूरा और समझाया गया: (पीछे छोड़ दिया गया)

c;
#define f(v)
    ({ // GCC statement-expression

        // Increment c until (1 << c) >= v, i.e
        // that's enough bits to contain v.
        // Note the `l` to force long
        // arithmetic that won't overflow.
        for(c = 0; v >= 1l << c; ++c)
            ; // Empty for body

        c; // Return value
    })

इसे कोलिरु पर लाइव देखें

— क्वेंटिन
स्रोत

ओपी n> = 1 की गारंटी देता है, इसलिए n?...:0यह आवश्यक नहीं है।

— मैड फिजिसिस्ट

1

@ मैडिसफिसिस्ट अच्छी तरह से मुझे पुनरावृत्ति को रोकना है, मैं नहीं;)

— क्वेंटिन

ओआईसी। ध्यान से नहीं पढ़ा, अब एक डंबस की तरह लग रहा है। दोनों तरह से उत्तर।

— मैड फिजिसिस्ट

@MadPhysicist कोई चिंता नहीं, बहुत-बहुत धन्यवाद :)

— Quentin

गैर-पुनरावर्ती समाधान के लिए gcc स्टेटमेंट एक्सप्रेशनों को मानते हुए, मुझे लगता है कि आप #define f(n) ({64-__builtin_clzl(n);})दृष्टिकोण का उपयोग करने के लिए इच्छुक हो सकते हैं ।

— मोरकी

14

गणितज्ञ, 9 बाइट्स

BitLength

वैकल्पिक रूप से:

Floor@Log2@#+1&
#~IntegerLength~2&

— मार्टिन एंडर
स्रोत

14

पर्ल 6 , 7 बाइट्स

*.msb+1

कोशिश करो

स्पष्टीकरण:

* यह जो कुछ भी एक प्रकार का वृक्ष मेमने बन जाता है, और यह बताता है कि इनपुट कहां रखा जाए

.msb एक इंट में सबसे महत्वपूर्ण बिट (0 आधारित) का सूचकांक देता है

+1लैम्ब्डा में संयुक्त है, और कॉलिंग के अंतिम परिणाम में एक जोड़ता है .msb।

— ब्रैड गिल्बर्ट b2gills
स्रोत

13

C प्रीप्रोसेसर मैक्रो (gcc एक्सटेंशन के साथ), २६

#define f 32-__builtin_clz

जीसीसी के गिनती-अग्रणी-शून्य बिलिन का उपयोग करता है ।

इसे फंक्शन के रूप में कहें, उदा f(100)।

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

— डिजिटल आघात
स्रोत

अरे वाह, मैंने एक बिल्डिन का उपयोग करने के बारे में सोचा था, लेकिन विचार छोड़ दिया क्योंकि मुझे लगा कि यह बहुत लंबा होने जा रहा है ... अच्छा खेला।

— क्वेंटिन

लकी ओपी निर्दिष्ट n> = 1: D

— Matthieu M.

12

रेटिना , 56 37 बाइट्स

यह समाधान सभी आवश्यक इनपुट मूल्यों के साथ काम करता है।

इस चुनौती में सबसे बड़ी समस्या रेटिना का सामना करना है, यह तथ्य यह है कि इसके तारों की अधिकतम लंबाई 2 ^ 30 वर्ण है, इसलिए संख्याओं (सामान्य प्रतिनिधित्व) से निपटने का सामान्य तरीका 2 ^ 30 से अधिक मूल्यों के साथ काम नहीं करता है।

इस समस्या को हल करने के लिए, मैंने एक अलग दृष्टिकोण अपनाया, जिसमें संख्याओं के दशमलव निरूपण को ध्यान में रखते हुए, लेकिन जहां प्रत्येक अंक को unary में लिखा गया है (मैं इसे प्रतिनिधित्व अंकसूची कहूँगा )। उदाहरण के लिए संख्या 341को 111#1111#1#अंकों के रूप में लिखा जाएगा । इस प्रतिनिधित्व के साथ अब हम 2^30/10अंकों की संख्या (~ सौ मिलियन अंक) के साथ काम कर सकते हैं । यह मनमाने ढंग से अंकगणित के लिए मानक यूनिरी से कम व्यावहारिक है, लेकिन थोड़े प्रयास से हम किसी भी तरह के ऑपरेशन कर सकते हैं।

नोट: सिद्धांत रूप में अंकगणित किसी अन्य आधार का उपयोग कर सकता है (जैसे बाइनरी बेस 2 डिजिटरी में 110हो सकता 1#1##है), लेकिन चूंकि रेटिना में दशमलव और यूनरी के बीच कनवर्ट करने के लिए बिल्डिंग्स हैं और अन्य ठिकानों से निपटने के लिए कोई सीधा रास्ता नहीं है, इसलिए दशमलव शायद सबसे अधिक प्रबंधनीय आधार है।

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

तो, हम अंकों में दो को कैसे विभाजित करते हैं? यहाँ रेटिना स्निपेट है कि यह करता है:

(1*)(1?)\1#        We divide one digit, the first group captures the result, the second group captures the remainder
$1#$2$2$2$2$2      The result is put in place of the old number, the remainder passes to the next digit (so it is multiplied by 10) and is divided by two there -> 5 times the remainder goes to the next digit

यह प्रतिस्थापन 2 से एक अंकों की संख्या को विभाजित करने के लिए पर्याप्त है, हमें बस मूल संख्या विषम होने पर अंत से संभव 5 को निकालने की आवश्यकता है।

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

.                  |
$*1#               Convert to digitunary
{`^(.*1)           Loop:|
n$1                    add an 'n'
(1*)(1?)\1#            |
$1#$2$2$2$2$2          divide by 2
)`#1*$                 |
#                      erase leftovers
n                  Return the number of 'n's in the string

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

नवीनीकृत समाधान, 37 बाइट्स

बहुत से अच्छे विचारों के साथ बड़ी सफलता, जो मार्टिन एंडर के लिए धन्यवाद, लंबाई के एक तिहाई के बारे में है!

मुख्य विचार _हमारे एकाकी प्रतीक के रूप में उपयोग करने के लिए है : इस तरह से हम अपनी स्ट्रिंग में नियमित अंकों का उपयोग कर सकते हैं, जब तक हम उन्हें _जरूरत पड़ने पर वापस एस में बदल देते हैं : इससे हमें विभाजन पर कई बाइट्स बचाने और कई के सम्मिलन पर अंक।

यहाँ कोड है:

<empty line>    |
#               put a # before each digit and at the end of the string 
{`\d            Loop:|
$*_                 Replace each digit with the corrisponding number of _
1`_                 |
n_                  Add an 'n' before the first _
__                  |
1                   Division by 2 (two _s become a 1)
_#                  |
#5                  Wherever there is a remainder, add 5 to the next digit
}`5$                |
                    Remove the final 5 you get when you divide odd numbers
n               Return the number of 'n's in the string

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

— सिंह
स्रोत

1

मैंने एक समान संख्यात्मक रूप का उपयोग किया है (लेकिन इसे Unary-Coded Decimal कहा जाता है ), जो कि Sed के साथ अंकगणित के लिए बहुत आसान है।

— टोबी स्पाइट

11

रूबी, 19 16 बाइट्स

->n{"%b"%n=~/$/}

3 बाइट्स बंद करने के लिए धन्यवाद जॉर्डन

— एलेक्सिस एंडरसन
स्रोत

आप के साथ एक बाइट बचा सकता है %: ->n{("%b"%n).size}।

— जॉर्डन

3

रुको, यह छोटा है ->n{"%b"%n=~/$/}:।

— जॉर्डन

10

जोल्फ, 2 बाइट्स

lB

बस बाइनरी में कनवर्ट करें और फिर लंबाई ढूंढें।

— Rɪᴋᴇʀ
स्रोत

10

जूलिया 0.4 , 14 बाइट्स

!n=log2(2n)÷1

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

— डेनिस
स्रोत

2

अन्य उत्तरों की तुलना में बहुत अधिक दिलचस्प। +1

— जादू ऑक्टोपस मूत्र

10

जावास्क्रिप्ट ईएस 6, 19 बाइट्स

a=>32-Math.clz32(a)

Math.clz32किसी संख्या के 32-बिट बाइनरी प्रतिनिधित्व में अग्रणी शून्य बिट्स की संख्या देता है। इसलिए आवश्यक बिट्स की मात्रा प्राप्त करने के लिए, हमें केवल उस संख्या को 32 से घटाना होगा

f=
  a=>32-Math.clz32(a)

pre {
    display: inline;
}

<input id=x type="number" oninput="y.innerHTML = f(x.value)" value=128><br>
<pre>Bits needed: <pre id=y>8</pre></pre>

स्निपेट का विस्तार करें

— बैसड्रॉब कंबरवुबवबब
स्रोत

2

विकल्प a=>1+Math.log2(a)|0भी 19 बाइट्स है।

— नील

5

@ नील 1+...|0चिल्लाते हैं माइनस टिल्ड ! a=>-~Math.log2(a)18 है

— edc65

@ edc65 मैं 17 की गिनती करता हूं ... लेकिन हां, मुझे यकीन था कि मुझे कुछ याद आ रहा है, इसे इंगित करने के लिए धन्यवाद।

— नील

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

— बेसड्रॉप कम्बर्बुवबूब

10

बैश / यूनिक्स उपकरण, 16 बाइट्स

dc<<<2o$1n|wc -c

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

यहाँ एक स्पष्टीकरण है:

dc एक स्टैक-आधारित कैलकुलेटर है। इसका इनपुट, टोकन में पार्स किया गया है:

2 - स्टैक पर 2 पुश करें।

ओ - स्टैक से एक मान पॉप करें (जो 2 है) और इसे आउटपुट बेस बनाते हैं (इसलिए आउटपुट अब बाइनरी में है)।

बैश कार्यक्रम के तर्क का मूल्य ($ 1) - स्टैक पर उस तर्क को दबाएं।

n - स्टैक से एक मान पॉप करें (जो इनपुट नंबर है) और इसे प्रिंट करें (बाइनरी में, क्योंकि यह आउटपुट बेस है) जिसमें कोई अनुगामी न्यूलाइन नहीं है।

तो dc कमांड बाइनरी में संख्या को प्रिंट करता है।

Dc का आउटपुट -c ऑप्शन के साथ कमांड wc में जाता है, जो इसके इनपुट में अक्षरों की संख्या को प्रिंट करता है।

अंतिम परिणाम तर्क के द्विआधारी प्रतिनिधित्व में अंकों की संख्या को प्रिंट करना है।

— मिशेल स्पेक्टर
स्रोत

भाषा का अच्छा विकल्प है, लेकिन अगर आप स्पष्टीकरण भी शामिल करते हैं तो यह और भी अच्छा होगा।

— एनएच।

@ एनएच धन्यवाद। मैंने एक स्पष्टीकरण जोड़ा है।

— मिशेल स्पेक्टर

9

Google शीट, 15 बाइट्स

सेल से इनपुट लेता है A1और फॉर्मूला रखने वाले सेल को आउटपुट देता है

=Len(Dec2Bin(A1

या

=Int(1+Log(A1,2

या

=Int(Log(2*A1,2

एक्सेल, 17 बाइट्स

ऊपर के रूप में ही, लेकिन एमएस एक्सेल के लिए स्वरूपित

=Len(Dec2Bin(A1))

या

=Int(1+Log(A1,2))

या

=Int(Log(2*A1,2))

— टेलर स्कॉट
स्रोत

8

अजगर, 3 बाइट्स

l.B

टेस्ट सूट यहाँ उपलब्ध है।

व्याख्या

l.BQ    Q is implicitly appended
   Q    eval(input)
 .B     convert Q to binary string
l       len(.B(Q))

— माइक बुफ़र्डेकी
स्रोत

वैकल्पिक रूप से: hslया .El, जिसमें lलॉग आधार 2 की गणना करता है, और hsया .Eगणना छत।

— आर.के.

8

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

BL

बाइनरी में कनवर्ट करता है, लंबाई पाता है।

— Rɪᴋᴇʀ
स्रोत

8

सी #, 63 45 31 बाइट्स

सहेजे गए 18 बाइट्स, Loovjo और TuukkaX की बदौलत

सहेजे गए 14 बाइट्स, ग्रेक्स के लिए धन्यवाद

 b=>1+(int)System.Math.Log(b,2);

यह उपयोग करता है, कि एक दशमलव संख्या n में ,log2 (n) 1 + 1 बिट्स है, जो इस पृष्ठ पर वर्णित है :

एक विशिष्ट दशमलव पूर्णांक में बिट्स की संख्या

एक सकारात्मक पूर्णांक n में 2 बिट्स होते हैं जब 2 ^ (b-1) ≤ n b 2 ^ b - 1. उदाहरण के लिए:

29 में 5 बिट्स हैं क्योंकि 16 16 29 5 31, या 2 ^ 4 ≤ 29 bits 2 ^ 5 - 1

123 में 7 बिट्स हैं क्योंकि 64 ≤ 123 7 127, या 2 ^ 6 ≤ 123 bits 2 ^ 7 - 1

967 में 10 बिट्स हैं क्योंकि 512 67 967, 1023, या 2 ^ 9 10 967 ^ 2 ^ 10 - 1

बड़ी संख्या के लिए, आप दो शक्तियों की एक तालिका से परामर्श कर सकते हैं ताकि उन शक्तियों को ढूंढा जा सके जिनमें आपकी संख्या शामिल है।

यह देखने के लिए कि यह क्यों काम करता है, उदाहरण के लिए, 2 ^ 5 के माध्यम से पूर्णांक 2 ^ 4 के द्विआधारी निरूपण के बारे में सोचें। वे 11111 के माध्यम से 10000, सभी संभव 5-बिट मान हैं।

लघुगणक का उपयोग करना

उपरोक्त विधि को दूसरे तरीके से कहा जा सकता है: बिट्स की संख्या आपकी संख्या से दो से छोटी शक्ति का प्रतिपादक है। आप बता सकते हैं कि गणितीय रूप में:

bspec = splog2 (n) ⌊ + 1

उस सूत्र के तीन भाग हैं:

log2 (n) का अर्थ है n के आधार 2 में लघुगणक, जो कि घातांक 2 है जिसे n प्राप्त करने के लिए उठाया गया है। उदाहरण के लिए, log2 (123) 94 6.9425145। भिन्नात्मक भाग की उपस्थिति का मतलब है n दो की शक्तियों के बीच है।

Thex the x का तल है, जो x का पूर्णांक भाग है। उदाहरण के लिए, example6.9425145, = 6. आप n के द्विआधारी प्रतिनिधित्व में दो की उच्चतम शक्ति के घातांक के रूप में (log2 (n) ⌊ के बारे में सोच सकते हैं।

+1 घातांक को दो की अगली उच्च शक्ति पर ले जाता है। आप इस कदम को अपने द्विआधारी संख्या के 2 ^ 0 वें स्थान के लिए लेखांकन के रूप में सोच सकते हैं, जो तब आपको इसकी कुल संख्या देता है। हमारे उदाहरण के लिए, यह 6 + 1 = 7 है। आपको सीलिंग फ़ंक्शन - ⌉x to का उपयोग करने के लिए लुभाया जा सकता है, जो कि x के बराबर या उससे अधिक का सबसे छोटा पूर्णांक है - बिट्स की संख्या की गणना करने के लिए जैसे:

bspec = splog2 (n) ⌈

हालाँकि, यह विफल रहता है जब n दो की शक्ति है।

— होर्वाथ डेविड
स्रोत

आपके पास वहां एक अतिरिक्त जगह है ...)+ 1)...-> ...)+1...। इसके अलावा, मुझे लगता है कि आप इसे प्रिंट करने के बजाय सीधे मूल्य वापस कर सकते हैं।

— लोजोवो डेस

आप इसे b=>1+(int)System.Math.Log(b,2); घटाकर 31 तक कर सकते हैं । अंतर रूपांतरण Math.Floor के समान आउटपुट प्रदान करता है और यदि आपको केवल एक बार संदर्भ प्रणाली का उपयोग करने की आवश्यकता है, तो आपको कथन का उपयोग करने की आवश्यकता नहीं है।

— ग्रैक्स 32

6

सी #, 32 बाइट्स

n=>Convert.ToString(n,2).Length;

पैरामीटर को एक बाइनरी स्ट्रिंग में कनवर्ट करता है और स्ट्रिंग की लंबाई लौटाता है।

— Yytsi
स्रोत

4

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

succ.floor.logBase 2

एक फ़ंक्शन बनाता है जो लघुगणक आधार 2, फर्श लेता है, और 1 जोड़ता है।

— Doorknob
स्रोत

4

बेफुंज -93 , 23 21 बाइट्स

&>2# /# :_1>+#<\#1_.@

Befunge एक 2D ग्रिड-आधारित भाषा है (हालाँकि मैं केवल एक लाइन का उपयोग कर रहा हूँ)।

&                      take integer input
 >2# /# :_             until the top of the stack is zero, halve and duplicate it
          1>+#<\#1_    find the length of the stack
                   .@  output that length as an integer and terminate the program

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

— JayDepp
स्रोत

@JamesHolderness धन्यवाद, मुझे लगा कि इसे छोटा किया जा सकता है क्योंकि इसमें बहुत सारे हैश / स्पेस थे, लेकिन मैं इसे प्राप्त नहीं कर सका।

— JayDepp

17 बाइट्स

— जो किंग

3

जेलिफ़िश , 4 बाइट्स

p#bi

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

इनपुट के बाइनरी प्रतिनिधित्व ( ) के प्रिंट ( p), लंबाई ( )।#bi

— मार्टिन एंडर
स्रोत

3

सीजाम , 5 बाइट्स

ri2b,

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

इनपुट पढ़ें ( r), पूर्णांक में बदलें ( i), बाइनरी प्रतिनिधित्व प्राप्त करें ( 2b), लंबाई प्राप्त करें ( ,)।

— मार्टिन एंडर
स्रोत

3

ऑक्टेव , 19 बाइट्स

@(x)ceil(log2(x+1))

बेनामी फ़ंक्शन जो 1 जोड़ता है, बाइनरी लॉगरिथम की गणना करता है और राउंड अप करता है।

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

— लुइस मेंडो
स्रोत

1

खैर, मैंने कोशिश की ;-)

— स्टीवी ग्रिफिन

3

QBIC , 18 बाइट्स

:{~2^q>a|_Xq\q=q+1

यह अविश्वसनीय माइक है! लेकिन ये कैसे काम करता है?

:        Read input as integer 'a'
{        Start an infinite DO-LOOP
~2^q>a   If 2 to the power of q (which is 1 by default) is greater than a
|_Xq     Then quit, printing q
\q=q+1   Else, increment q
[LOOP is closed implicitly by QBIC]

— steenbergh
स्रोत

3

जावा 8, 34 27 बाइट्स

एक बार के लिए, जावा में कुछ उपयोगी भवन हैं! अब, हमें कुछ छोटे नामों की आवश्यकता है ...

x->x.toString(x,2).length()

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

बेशक, आप इसे बिना निर्माण के कर सकते हैं ( स्नोमैन का जवाब देखें ), लेकिन एक उच्च बाइट गिनती के लिए।

— FlipTack
स्रोत

3

ऑक्टेव, 19 बाइट्स

@(x)nnz(dec2bin(x))    % or
@(x)nnz(de2bi(x)+1)    % or
@(x)nnz(de2bi(x)<2)    % or
@(x)numel(de2bi(x))    % or
@(x)rows(de2bi(x'))

ऑक्टेव में दशमलव संख्या को द्विआधारी संख्या में बदलने के लिए दो कार्य हैं।

dec2binवर्णों की एक स्ट्रिंग में एक नंबर धर्मान्तरित 1और 0(ASCII-मूल्यों 48और 49)। स्ट्रिंग की लंबाई आवश्यक बिट्स के बराबर होगी, जब तक कि अन्यथा निर्दिष्ट न हो। चूँकि अक्षर 1और 0गैर-शून्य हैं, हम nnzइस तरह के तत्वों की संख्या का पता लगाने के लिए उपयोग कर सकते हैं @(x)nnz(dec2bin(x)):। यह 19 बाइट्स है, इसलिए यह लुइस मेंडो के अन्य ऑक्टेव उत्तर के साथ जुड़ा हुआ है ।

क्या हम बेहतर उपयोग कर सकते हैं de2bi?

de2biएक ऐसा फंक्शन है जो द्विआधारी संख्याओं को एक वेक्टर के रूप में संख्याओं के साथ 1और 0पूर्णांक के रूप में लौटाता है , वर्णों को नहीं। de2biस्पष्ट रूप से दो बाइट्स से कम है dec2bin, लेकिन हम अब उपयोग नहीं कर सकते nnz। हम उपयोग कर सकते हैं nnzअगर हम या तो 1सभी तत्वों को जोड़ते हैं, या इसे केवल trueमूल्यों के साथ एक तार्किक वेक्टर में बनाते हैं। @(x)nnz(de2bi(x)+1)और @(x)nnz(de2bi(x)<2)दोनों 19 बाइट्स हैं। का उपयोग करते हुए numelभी हमें 19 बाइट्स दे देंगे, @(x)numel(de2bi(x))।

rowsएक बाइट से कम है numel, लेकिन de2biएक क्षैतिज वेक्टर देता है, इसलिए इसे ट्रांसपोज़ किया जाना चाहिए। @(x)rows(de2bi(x)')ऐसा ही कुछ 19 बाइट्स में भी होता है।

— स्टीवी ग्रिफिन
स्रोत

2

Pyke, 3 बाइट्स

b2l

यहाँ कोशिश करो!

— नीला
स्रोत

2

रेटिना , 44 23 बाइट्स

बड़े इनपुट मानों को चलाने के लिए बहुत अधिक मेमोरी की आवश्यकता होती है। एकजुट करने के लिए धर्मान्तरित करता है, फिर बार-बार 2 से विभाजित करता है, गिनता है कि कितनी बार शून्य हिट होता है। बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

.*
$*
+`^(1+)1?\1
$1_
.

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

— mbomb007
स्रोत

1

मुझे यकीन नहीं है कि यह वैध है। यह "आपके द्वारा संभवतः अधिक मेमोरी की आवश्यकता है" का मामला नहीं है, लेकिन "रेटिना की तुलना में अधिक मेमोरी की आवश्यकता होती है जो स्वयं को संभाल सकती है"। विशेष रूप से, रेटिना के कार्यान्वयन में सीमाओं के कारण, यूनरी के लिए प्रारंभिक रूपांतरण आदेश 2 ^ 30 और उससे अधिक के इनपुट के लिए विफल हो जाएगा।

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

यदि यह वैध है, तो इसे बहुत कम किया जा सकता है: tio.run/nexus/retina#@6@nxaWixaWdEKdhqK1paB9jyKViGM@l9@@saUhAA

— मार्टिन

मैं कितने बिट्स में फिट हूं

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

05AB1E , 2 बाइट्स

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

x86 असेंबली, 4 बाइट्स

अजगर , 14 बाइट्स

भूलभुलैया , 13 12 बाइट्स

व्याख्या

सी, 31 बाइट्स

सी, 43 बाइट्स

गणितज्ञ, 9 बाइट्स

पर्ल 6 , 7 बाइट्स

स्पष्टीकरण:

C प्रीप्रोसेसर मैक्रो (gcc एक्सटेंशन के साथ), २६

रेटिना , 56 37 बाइट्स

रूबी, 19 16 बाइट्स

जोल्फ, 2 बाइट्स

जूलिया 0.4 , 14 बाइट्स

जावास्क्रिप्ट ईएस 6, 19 बाइट्स

बैश / यूनिक्स उपकरण, 16 बाइट्स

Google शीट, 15 बाइट्स

एक्सेल, 17 बाइट्स

अजगर, 3 बाइट्स

व्याख्या

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

सी #, 63 45 31 बाइट्स

एक विशिष्ट दशमलव पूर्णांक में बिट्स की संख्या

लघुगणक का उपयोग करना

सी #, 32 बाइट्स

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

बेफुंज -93 , 23 21 बाइट्स

जेलिफ़िश , 4 बाइट्स

सीजाम , 5 बाइट्स

ऑक्टेव , 19 बाइट्स

QBIC , 18 बाइट्स

जावा 8, 34 27 बाइट्स

ऑक्टेव, 19 बाइट्स

Pyke, 3 बाइट्स

रेटिना , 44 23 बाइट्स