สำหรับจำนวนเต็มบวก 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

นี่คือรหัสกอล์ฟ รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

05AB1E , 2 ไบต์

bg

ลองออนไลน์!

JavaScript (ES6), 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>

x86 ชุดประกอบ 4 ไบต์

สมมติว่าค่าคงที่ในEBX:

bsr eax,ebx
inc eax

EAX มีจำนวนบิตที่จำเป็นสำหรับค่าคงที่

ไบต์: ☼¢├@

เลขฐานสิบหก: ['0xf', '0xbd', '0xc3', '0x40']

Pythonขนาด 14 ไบต์

int.bit_length

ลองออนไลน์!

เขาวงกต , 13 12 ไบต์

 ?
_:
2/#(!@

ลองออนไลน์!

คำอธิบาย

โปรแกรมแบ่งการป้อนข้อมูล 2 ครั้งซ้ำ ๆ จนกระทั่งมันเป็นศูนย์ จำนวนขั้นตอนจะถูกติดตามโดยการทำซ้ำค่าในแต่ละขั้นตอน เมื่อมันลดลงเหลือศูนย์เราจะพิมพ์ความลึกของสแต็ก (ลบ 1)

โปรแกรมเริ่มต้นที่?อ่านอินพุต ลูปหลักคือบล็อก 2x2 ด้านล่าง, ทวนเข็มนาฬิกา:

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

เมื่อค่าเป็นศูนย์หลังจากการวนซ้ำเต็มบิตเชิงเส้นที่ท้ายจะถูกดำเนินการ:

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

C, 31 ไบต์

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

... จากนั้นฉันก็คิดถึงการสอบถามซ้ำ จากที่คลุมเครือถึงชัดเจนและหนึ่งในสี่ของความยาวหลุดออกไป

ดูมันสดบน Coliru

C, 43 ไบต์

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

การโทรfด้วยค่าที่ไม่ได้ลงชื่อ (เช่นf(42u)) จะ "คืน" ความยาวบิตของมัน แม้ใช้งานได้0u!

Ungolfed และอธิบาย: (ไม่ใส่เครื่องหมายแบ็กสแลช)

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
    })

ดูมันสดบน Coliru

Mathematica ขนาด 9 ไบต์

BitLength

อีกวิธีหนึ่งคือ:

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

Perl 6 , 7 ไบต์

*.msb+1

ลองมัน

คำอธิบาย:

* ทำให้มันกลายเป็นสิ่งที่แลมบ์ดารหัสและระบุตำแหน่งที่จะนำเข้า

.msb บน Int จะส่งคืนดัชนีของบิตที่สำคัญที่สุด (ตาม 0)

+1.msbจะรวมกันเป็นแลมบ์ดาและเพิ่มหนึ่งไปยังผลที่สุดของการโทร

มาโครตัวประมวลผลล่วงหน้า C (ที่มีนามสกุล gcc), 26

#define f 32-__builtin_clz

ใช้ GCC's นับชั้นนำศูนย์ builtin

เรียกสิ่งนี้ว่าเป็นฟังก์ชั่นเช่น f(100)เรียกสิ่งนี้เป็นฟังก์ชั่นเช่น

ลองมันออนไลน์

เรติน่า , 56 37 ไบต์

วิธีนี้ใช้ได้กับค่าอินพุตที่จำเป็นทั้งหมด

ปัญหาที่ใหญ่ที่สุดของหน้าจอ Retina ในการท้าทายนี้คือความจริงที่ว่าสตริงมีความยาวสูงสุด 2 ^ 30 ตัวอักษรดังนั้นวิธีปกติในการจัดการกับตัวเลข (การแสดงแบบเอก) ไม่ทำงานกับค่าที่มากกว่า 2 ^ 30

เพื่อที่จะแก้ปัญหานี้ฉันได้นำวิธีการที่แตกต่างกันไปใช้การจัดเรียงตัวเลขทศนิยมแทนตัวเลข แต่ที่แต่ละหลักจะเขียนด้วยภาษาเดียว (ฉันจะเรียกวิธีนี้ว่าการเป็นตัวแทนดิจิทัล ) ยกตัวอย่างเช่นตัวเลข341จะถูกเขียน111#1111#1#ในรูปแบบดิจิทัล ด้วยการเป็นตัวแทนนี้เราสามารถทำงานกับตัวเลขสูงสุด2^30/10(~ ร้อยล้านหลัก) มันใช้งานได้น้อยกว่า unary มาตรฐานสำหรับเลขคณิตโดยพลการ แต่ด้วยความพยายามเล็กน้อยเราสามารถดำเนินการใด ๆ ได้

หมายเหตุ: ดิจิทัลในทางทฤษฎีสามารถใช้ฐานอื่น ๆ (เช่นไบนารี110จะอยู่1#1##ในฐานที่ 2 ดิจิตัล) แต่เนื่องจาก Retina มี builtins ในการแปลงระหว่างทศนิยมและไม่เป็นเอกภาพและไม่มีวิธีโดยตรงที่จะจัดการกับฐานอื่น ๆ

อัลกอริทึมที่ฉันใช้คือทำให้การหารจำนวนเต็มต่อเนื่องสองจนกว่าเราจะถึงศูนย์จำนวนหน่วยงานที่เราทำคือจำนวนบิตที่จำเป็นในการเป็นตัวแทนของจำนวนนี้

ดังนั้นเราจะแบ่งสองหลักเป็นหน่วยหลักได้อย่างไร นี่เป็นตัวอย่างของ Retina ที่ทำ:

(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 เราเพียงแค่ต้องลบ. 5s ที่เป็นไปได้ออกจากท้ายหากหมายเลขเดิมเป็นเลขคี่

ดังนั้นนี่คือรหัสเต็มเราจะหารด้วยสองจนกว่าจะมีตัวเลขยังคงอยู่ในตัวเลขและใส่ตัวอักษรที่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

ลองออนไลน์!

การปรับโครงสร้างครั้งยิ่งใหญ่ด้วยแนวคิดที่ดีมากมายที่เล่นกอล์ฟได้ประมาณหนึ่งในสามของความยาวทั้งหมดขอบคุณ Martin Ender!

แนวคิดหลักคือใช้_เป็นสัญลักษณ์ของเรา: ด้วยวิธีนี้เราสามารถใช้ตัวเลขปกติในสายอักขระของเราตราบใดที่เราแปลงกลับเป็น_ s เมื่อต้องการ: สิ่งนี้ช่วยให้เราประหยัดหลายไบต์ในการหารและการแทรกหลาย ตัวเลข

นี่คือรหัส:

<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

ลองออนไลน์!

Ruby, 19 16 ไบต์

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

ขอบคุณจอร์แดนสำหรับการเล่นกอล์ฟขนาด 3 ไบต์

Jolf, 2 ไบต์

lB

เพียงแปลงเป็นไบนารี่แล้วค้นหาความยาว

Julia 0.4 , 14 ไบต์

!n=log2(2n)÷1

ลองออนไลน์!

JavaScript ES6, 19 ไบต์

a=>32-Math.clz32(a)

Math.clz32ส่งคืนจำนวนบิตศูนย์นำในการแทนเลขฐานสองแบบ 32 บิตของตัวเลข ดังนั้นเพื่อให้ได้จำนวนบิตที่ต้องการสิ่งที่เราต้องทำก็คือ substract นั้นจาก 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>

เครื่องมือทุบตี / Unix ขนาด 16 ไบต์

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

บันทึกสิ่งนี้ในสคริปต์และส่งผ่านอินพุตเป็นอาร์กิวเมนต์ จำนวนบิตที่ต้องใช้เพื่อแสดงจำนวนนั้นในไบนารีจะถูกพิมพ์

นี่คือคำอธิบาย:

dc เป็นเครื่องคิดเลขตามสแต็ก อินพุตแยกเป็นโทเค็นคือ:

2 - กด 2 บนสแต็ก

o - ป๊อปอัพค่าออกจากสแต็ก (ซึ่งคือ 2) และทำให้มันเป็นฐานเอาท์พุท

ค่าของการโต้แย้งไปยังโปรแกรมทุบตี ($ 1) - ผลักดันอาร์กิวเมนต์นั้นในสแต็ก

n - ป๊อปอัพค่าออกจากสแต็ก (ซึ่งเป็นหมายเลขอินพุต) และพิมพ์ (เป็นไบนารีเพราะนั่นคือฐานเอาต์พุต) โดยไม่มีการขึ้นบรรทัดใหม่

ดังนั้นคำสั่ง dc จะพิมพ์ตัวเลขเป็นเลขฐานสอง

เอาต์พุตของ dc ถูกไพพ์ไปที่คำสั่ง wc พร้อมกับอ็อพชัน -c ซึ่งพิมพ์จำนวนอักขระในอินพุต

ผลลัพธ์ที่ได้คือการพิมพ์จำนวนของตัวเลขในการเป็นตัวแทนไบนารีของการโต้แย้ง

Google ชีตขนาด 15 ไบต์

รับอินพุตจากเซลล์A1และเอาต์พุตไปยังเซลล์ที่เก็บสูตร

=Len(Dec2Bin(A1

หรือ

=Int(1+Log(A1,2

หรือ

=Int(Log(2*A1,2

Excel, 17 ไบต์

เหมือนกับด้านบน แต่ได้รับการจัดรูปแบบสำหรับ MS Excel

=Len(Dec2Bin(A1))

หรือ

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

หรือ

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

Pyth, 3 ไบต์

l.B

ชุดทดสอบใช้ได้ที่นี่

คำอธิบาย

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

เยลลี่ 2 ไบต์

BL

แปลงเป็นไบนารีค้นหาความยาว

C #, 63 45 31 ไบต์

บันทึกแล้ว 18 ไบต์ขอบคุณ Loovjo และ TuukkaX

บันทึกแล้ว 14 ไบต์ขอบคุณ Grax

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

มันใช้ว่าตัวเลขทศนิยม n มี⌊log2 (n) ⌋ + 1 บิตซึ่งอธิบายไว้ในหน้านี้ :

จำนวนบิตในจำนวนเต็มทศนิยมแบบเฉพาะ

จำนวนเต็มบวก n มี b บิตเมื่อ 2 ^ (b-1) ≤ n ≤ 2 ^ b - 1 ตัวอย่างเช่น:

• 29 มี 5 บิตเพราะ 16 ≤ 29 ≤ 31 หรือ 2 ^ 4 ≤ 29 ≤ 2 ^ 5 - 1
• 123 มี 7 บิตเพราะ 64 ≤ 123 ≤ 127 หรือ 2 ^ 6 ≤ 123 ≤ 2 ^ 7 - 1
• 967 มี 10 บิตเพราะ 512 ≤ 967 ≤ 1023 หรือ 2 ^ 9 ≤ 967 ≤ 2 ^ 10 - 1

สำหรับตัวเลขที่มากขึ้นคุณสามารถดูตารางพลังสองเพื่อค้นหาพลังที่ต่อเนื่องกันที่มีหมายเลขของคุณ

หากต้องการดูว่าทำไมการทำงานนี้ให้ลองนึกถึงการแทนเลขฐานสองของจำนวนเต็ม 2 ^ 4 ถึง 2 ^ 5 - 1 เป็นต้น ค่าเหล่านี้คือ 10,000 ถึง 11111 ค่า 5 บิตที่เป็นไปได้ทั้งหมด

ใช้ลอการิทึม

วิธีการข้างต้นสามารถระบุได้อีกวิธีหนึ่ง: จำนวนบิตคือเลขชี้กำลังของกำลังไฟฟ้าที่เล็กที่สุดที่สองของคุณมากกว่าจำนวนของคุณ คุณสามารถระบุได้ว่าทางคณิตศาสตร์เป็น:

bspec = ⌊log2 (n) ⌋ + 1

สูตรนั้นมีสามส่วน:

• log2 (n) หมายถึงลอการิทึมในฐาน 2 ของ n ซึ่งเป็นเลขยกกำลังที่ยก 2 เพื่อรับ n ตัวอย่างเช่น log2 (123) ≈ 6.9425145 การมีอยู่ของส่วนที่เป็นเศษส่วนหมายความว่า n อยู่ระหว่างกำลังสอง

• ⌊x⌋เป็นพื้นของ x ซึ่งเป็นส่วนจำนวนเต็มของ x ตัวอย่างเช่น⌊6.9425145⌋ = 6. คุณสามารถคิดถึง⌊log2 (n) ⌋เป็นเลขชี้กำลังของกำลังสูงสุดของสองในการแทนเลขฐานสองของ n

• +1 จะยกกำลังเป็นเลขยกกำลังสองถัดไป คุณสามารถคิดว่าขั้นตอนนี้เป็นการบัญชีสำหรับเลขที่ 2 ^ 0 ของเลขฐานสองของคุณซึ่งจะให้จำนวนบิตทั้งหมด สำหรับตัวอย่างของเรานั่นคือ 6 + 1 = 7 คุณอาจถูกล่อลวงให้ใช้ฟังก์ชันเพดาน - ceilingx⌉ซึ่งเป็นจำนวนเต็มที่น้อยที่สุดที่มากกว่าหรือเท่ากับ x - เพื่อคำนวณจำนวนบิตเช่น:

bspec = ⌈log2 (n) ⌉

อย่างไรก็ตามสิ่งนี้ล้มเหลวเมื่อ n คือพลังของสอง

C #, 32 ไบต์

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

แปลงพารามิเตอร์เป็นสตริงไบนารีและส่งคืนความยาวของสตริง

Haskell, 20 ไบต์

succ.floor.logBase 2

ประกอบด้วยฟังก์ชั่นที่ใช้ลอการิทึมฐาน 2 ชั้นและเพิ่ม 1

Befunge-93 , 23 21 Bytes

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

Befunge เป็นภาษาที่ใช้กริด 2 มิติ (แม้ว่าฉันจะใช้เพียงบรรทัดเดียวเท่านั้น)

&                      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

ลองออนไลน์!

แมงกะพรุนขนาด 4 ไบต์

p#bi

ลองออนไลน์!

พิมพ์ ( p) ความยาว ( #) ของการแทนแบบไบนารี่ ( b) ของอินพุต ( i)

CJam , 5 ไบต์

ri2b,

ลองออนไลน์!

อ่านอินพุต ( r), แปลงเป็นจำนวนเต็ม ( i), รับการแทนแบบไบนารี ( 2b), รับความยาว ( ,)

อ็อกเทฟ 19 ไบต์

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

ฟังก์ชั่นไม่ระบุชื่อที่เพิ่ม 1 คำนวณลอการิทึมไบนารีและปัดเศษขึ้น

ลองออนไลน์!

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]

Java 8, 34 27 ไบต์

ครั้งหนึ่ง Java มี builtins ที่มีประโยชน์! ตอนนี้เราต้องการชื่อที่สั้นกว่านี้ ...

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

ลองออนไลน์!

แน่นอนคุณสามารถทำสิ่งนี้ได้โดยไม่ต้อง buildins ( ดูคำตอบของ Snowman ) แต่สำหรับจำนวนไบต์ที่สูงขึ้น

อ็อกเทฟ, 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 ไบต์ดังนั้นจึงเชื่อมโยงกับคำตอบ Octave อื่น ๆ ของ Luis Mendoคำตอบของคู่อื่น

เราสามารถทำได้ดีกว่าโดยใช้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 ไบต์เช่นกัน

Pyke 3 ไบต์

b2l

ลองที่นี่!

เรติน่า 44 ไบต์

ต้องใช้หน่วยความจำมากเกินไปในการทำงานสำหรับค่าอินพุตที่มีขนาดใหญ่ แปลงเป็นเอกภาพจากนั้นหารด้วย 2 ซ้ำ ๆ นับจำนวนครั้งจนกว่าจะถึงศูนย์ จำนวนไบต์ถือว่าการเข้ารหัส ISO 8859-1

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

ลองออนไลน์