In how many bits do I fit

Question

For any positive 32-bit integer (1 ≤ n ≤ 0xFFFFFFFF) output the number of bits needed to represent that integer.

Test cases

| 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

So f(16) would print or return 5

This is code-golf. Shortest code in bytes wins

Answer 1

Perl, 21 bytes

21 bytes, (ab)use the fact that $= must be an integer

say$==1+log(<>)/log 2

25 bytes, naïve implementation

say length sprintf"%b",<>

28 23 byte version without whitespaces

$-++while$_>>=1;say++$-

1while($i//=<>)>=1<<++$_;say

---

Usage

$ echo 128 | perl -E '$-++while$_>>=1;say++$-'
8
$ echo 128 | perl -E 'say length sprintf"%b",<>'
8

Answer 2

JavaScript (ES6), 17 bytes

f=
a=>-~Math.log2(a)

<input type=number min=0 oninput=o.textContent=f(this.value)><div>Bits: <span id=o>

Saved 2 bytes thanks to @edc65.

Answer 3

Java 8, 43 41

v->{int b=0;for(;v>0;++b,v/=2);return b;}

Counts the bits the old fashioned way and returns the count. Lambda fits into a LongFunction<Integer>.

Answer 4

Actually, 2 bytes

├l

Try it online!

Explanation:

├l
├   binary representation (without leading zeroes)
 l  length

Since Actually uses arbitrary-width integers, this will work for any input, so long as there is enough memory and time.

Answer 5

Japt, 2 bytes

¢l

¢ converts the input into a base-2 string

l returns the length

Thanks ETHproductions for shaving off 3 bytes.

Answer 6

PHP, 21 bytes

<?=-~log($argv[1],2);

• log(x,2) Computes log2(x)
• ~ is the binary negation operator that also cast to int
• - take opposite

28 bytes

<?=strlen(decbin($argv[1]));

• decbin convert to binary
• strlen takes length

28 bytes

<?=floor(log($argv[1],2))+1;

• log(x,2) compute log2(x)
• floor ... +1 takes floor plus 1

32 bytes (Thanks Titus)

for(;2**++$i<=$argv[1];);echo$i;

• 2**$n compute 2^n ie. pow(2,n) until superior to $argv[1]

Answer 7

APL, 6 bytes

1+⌊2⍟⍵

Omega is the right argument, which is replaced with the number in question.

Try it online!

Answer 8

Julia, 16 bytes

n->endof(bin(n))

Anonymous function.

Answer 9

Pyth - 3 bytes

Alternative 3 byte answer. Takes floor(log2(n))+1

hsl

Test Suite.

Answer 10

RProgN, 4 Bytes.

~2BL

Explained

~2BL    #
~        # Zero Space Segment, The rest of this code is interpreted as if it were a bunch of characters separated by spaces.
 2B     # Convert implicit input to Base 2
   L    # Get the length of that, and implicitly output.

Try it online!

Answer 11

awk, 32 bytes

Iterate 2's exponent and see when it's greater than given value. Return the value in exit:

{for(;++i<=32;)if(2^i>$0)exit i}

Run it:

$ echo 4294967295| awk '{for(;++i<=32;)if(2^i>$0)exit i}'
$ echo $?
32

Answer 12

Python 2, 28 Bytes

def f(a):print len(bin(a))-2

Answer 13

C, 27 bytes

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

Inspired by the answer by Quentin. Uses an unsigned literal to avoid overflow when using 32-bit integers. Might be able to cut the unsigned part if int is 64-bit, but it's more interesting this way.

Answer 14

C, 47 39 bytes

int L(uint32_t X){return X?1+L(X/2):0;}

Not using a library function. The algorithm counts the number of bits needed by shifting right (or the equivalent divide by 2) until 0.

Answer 15

Matlab, 21 Bytes

c=@(x)nnz(dec2bin(x))

Yay for anonymous functions!

Example usage:

c(6)

ans = 

     3

Answer 16

Julia, 15 bytes

n->ndigits(n,2)

This is an anonymous function that wraps Julia's built-in ndigits function that counts the number of digits of the input in the given base. Here we're giving it a base of 2.

Try it online!

Answer 17

J, 11 bytes

2&(1+<.@^.)

This is a monadic verb that accepts input on the right.

2&(    @^.)  NB. Base 2 logarithm of the input
     <.      NB. Floor
   1+        NB. Add 1

Could likely be improved using # (tally) and #: (binary representation) but I haven't figured that part out yet.

Try it online!

Answer 18

ForceLang, 88 bytes

Noncompeting, requires the latest interpreter release, which postdates the question. (The ln implementation used previously was too inaccurate with large values)

set i math.ln io.readnum()
set j math.ln 2
set k math.floor i.mult j.pow -1
io.write k+1

Answer 19

VBScript, 45 bytes

Sub l(n)
WScript.Echo Log(n)/Log(2)+1
End Sub

See result by adding l(whatever the number is) to the end of the file. Run with cscript.exe if you want the result in a command window.

Answer 20

Javascript, 23 bytes

x=>x.toString(2).length

f=x=>x.toString(2).length
document.write(f(341)) // 9

Answer 21

TI-Basic, 8 bytes

1+int(logBASE(Ans,2

Answer 22

Perl, 19 bytes

$_=0|1+(log)/log 2

The score includes 1 byte for the -p switch the program requires.

Try it online!

Answer 23

Ruby, 19 bytes

->i{i.to_s(2).size}

Answer 24

SmileBASIC, 20 bytes

INPUT N?LEN(BIN$(N))

Answer 25

Python 2, 39 bytes

lambda x:__import__('math').frexp(x)[1]

Not even kind of the shortest, but it showcases a neat function that could be useful elsewhere!

frexp(n) represents n as n = m * 2**e with 0.5 <= abs(m) < 1 and then returns the tuple (m, e) as output. For positive integers, e is exactly the number of bits required to represent the number.

Answer 26

Powershell, 66 48 bytes

-18 bytes thanks to @briantist

function l {[math]::floor([math]::log($args[0])/[math]::log(2))+1}

($m=[math])::floor(m::log($args[0])/m::log(2))+1

Doing anything in Powershell is complicated, but it's better than Batch! In just Batch, this challenge isn't even possible (no decimal numbers=no logarithms).

Answer 27

Lithp, 30 bytes

 #N::((length(to-string N 2)))

Pretty simple. Convert the number to binary (to-string N 2) and return the length of the string.

Try it online!

Alternate entry (no binary builtin), 38 bytes

 #N::((if(!= 0 N)((+ 1(x(>> N 1))))0))

Try it online!

Recursively shifts right by 1 each time the function is called, until we get to 0. This is an unsigned shift, so can support the full range of 0x0 - 0xFFFFFFFF. The Lithp >> operator is equivalent to Javascript's >>> operator.

Answer 28

Common Lisp, 39 bytes

(defun f(i)(length(format nil "~B" i)))

Try it online!

Answer 29

C, 39 36 bytes

f(n,*p){*p=0;while(n){n/=2;(*p)++;}}

Ungolfed version:

 void f(long int n, int *p)
 {
   *p=0;
    while(n!=0)
    {
      n/=2;
     (*p)++;  
    }   
  }

The main() function that accepts number from stdin, would look like this:

   int main()
   {
       int b=0
       long int num;
       scanf("%ld",&num);
       f(num,&b);
       printf("%d\n",b);
       return 0;
   }
`

Alternative:

f(long n){i=0;while(n!=0){n/=2;i++;}return i;}

Ungolfed version:

int f(int n)
{
  int i=0;

  while(n!=0)
  {
    n/=2;
    i++;

  }
   return i;
} 
 

Answer 30

Dodos, 60 bytes

	' S ' g
g
	S dab
	g S ' dab f
f
	f ' '
	S dab
'
	dip
S
	dot

Try it online!

(S computes the sum, S ' dab f divides by 2)