Для будь-якого позитивного 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 містить кількість бітів, необхідних для Constant.

Байтів: ☼¢├@

Шістнадцятковий: ['0xf', '0xbd', '0xc3', '0x40']

Пітон , 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;}

... Тоді я подумав про рекурсію. Від незрозумілого до очевидного, і з однієї четвертості довжини скинуто.

Побачити його наживо на Коліру

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

Побачити його наживо на Коліру

Математика, 9 байт

BitLength

Як варіант:

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

Perl 6 , 7 байт

*.msb+1

Спробуй це

Пояснення:

* перетворює його в лямбда WeverCode і вказує, куди слід ввести дані

.msb на Int повертає індекс найзначнішого біта (на основі 0)

+1поєднується в лямбду і додає один до можливого результату виклику .msb.

Макрос препроцесора (з розширеннями gcc), 26

#define f 32-__builtin_clz

Використовується вбудований нульовий лічильник GCC .

Назвіть це як функцію, наприклад f(100).

Спробуйте в Інтернеті .

Сітківка , 56 37 байт

Це рішення працює з усіма необхідними вхідними значеннями.

Найбільшою проблемою, з якою стикається Ретіна в цьому виклику, є той факт, що її рядки мають максимальну довжину 2 ^ 30 символів, тому звичайний спосіб поводження з числами (одинарне представлення) не працює зі значеннями, що перевищують 2 ^ 30.

Щоб вирішити цю проблему, я застосував інший підхід, зберігаючи своєрідне десяткове представлення чисел, але там, де кожна цифра написана одинаково (я називаю це представлення цифрова ). Наприклад, число 341було б записане, як 111#1111#1#у цифровій формі. За допомогою цього представлення ми тепер можемо працювати з числами до 2^30/10цифр (~ сто мільйонів цифр). Він менш практичний, ніж стандартний уніар для довільної арифметики, але, доклавши трохи зусиль, ми могли б робити будь-які операції.

ПРИМІТКА: в цифрових системах теоретично може використовуватися будь-яка інша база (наприклад, двійковий 110буде 1#1##в базі 2, оцифрований), але оскільки 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

Спробуйте в Інтернеті!

Великий рефакторинг з багатьма хорошими ідеями, які займають гольф приблизно на третину довжини, все завдяки Мартину Ендеру!

Основна ідея полягає у використанні _в якості нашого одинарного символу: таким чином ми можемо використовувати звичайні цифри в нашому рядку до тих пір, поки ми перетворюємо їх назад в _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

Спробуйте в Інтернеті!

Рубі, 19 16 байт

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

Дякую Джордану за те, що виграли 3 байти

Джольф, 2 байти

lB

Просто перетворіть у двійкове і потім знайдіть довжину.

Джулія 0,4 , 14 байт

!n=log2(2n)÷1

Спробуйте в Інтернеті!

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

інструменти bash / Unix, 16 байт

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

Збережіть це у сценарії та передайте введення як аргумент. Кількість бітів, необхідних для представлення цього числа у двійковій формі, буде надруковано.

Ось пояснення:

DC - калькулятор на основі стека. Його вхід, розібраний на лексеми, полягає в:

2 - Натисніть 2 на стек.

o - Спустіть значення зі стека (що дорівнює 2) та зробіть його базовою для виводу (тому вихід тепер є двійковим).

Значення аргументу для програми bash ($ 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 має біт, коли 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. Вони від 10000 до 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. Ви можете спокуситись використовувати функцію стелі - ⌈x⌉, що є найменшим цілим числом, більшим або рівним 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 байт

&>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

Спробуйте в Інтернеті!

Медузи , 4 байти

p#bi

Спробуйте в Інтернеті!

Друк ( p), довжина ( #) двійкового зображення ( b) вводу ( i).

CJam , 5 байт

ri2b,

Спробуйте в Інтернеті!

Прочитайте input ( r), перетворіть у integer ( i), отримайте двійкове представлення ( 2b), get length ( ,).

Октава , 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 є кілька корисних вбудованих! Тепер нам потрібні лише короткі назви ...

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

Спробуйте в Інтернеті!

Звичайно, ви можете зробити це без вбудованих даних ( див. Відповідь Сніговика ), але для більшої кількості байтів.

Октава, 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'))

Octave має дві функції перетворення десяткових чисел у двійкові числа.

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 байт.

Пайк, 3 байти

b2l

Спробуйте тут!

Сітківка ,  44  23 байти

Для великих значень введення потрібна занадто велика кількість пам'яті. Перетворюється в одинарний, потім повторно ділиться на 2, рахуючи скільки разів, поки не досягне нуля. Кількість байтів передбачає кодування ISO 8859-1.

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

Спробуйте в Інтернеті