Problem:

Find the number of leading zeroes in a 64-bit signed integer

Rules:

• The input cannot be treated as string; it can be anything where math and bitwise operations drive the algorithm


• The output should be validated against the 64-bit signed integer representation of the number, regardless of language


• Default code golf rules apply


• Shortest code in bytes wins

Test cases:

These tests assume two's compliment signed integers. If your language/solution lacks or uses a different representation of signed integers, please call that out and provide additional test cases that may be relevant. I've included some test cases that address double precision, but please feel free to suggest any others that should be listed.

input                output   64-bit binary representation of input (2's compliment)

-1                   0        1111111111111111111111111111111111111111111111111111111111111111

-9223372036854775808 0        1000000000000000000000000000000000000000000000000000000000000000

9223372036854775807  1        0111111111111111111111111111111111111111111111111111111111111111

4611686018427387903  2        0011111111111111111111111111111111111111111111111111111111111111

1224979098644774911  3        0001000011111111111111111111111111111111111111111111111111111111

9007199254740992     10       0000000000100000000000000000000000000000000000000000000000000000

4503599627370496     11       0000000000010000000000000000000000000000000000000000000000000000

4503599627370495     12       0000000000001111111111111111111111111111111111111111111111111111

2147483648           32       0000000000000000000000000000000010000000000000000000000000000000

2147483647           33       0000000000000000000000000000000001111111111111111111111111111111

2                    62       0000000000000000000000000000000000000000000000000000000000000010

1                    63       0000000000000000000000000000000000000000000000000000000000000001

0                    64       0000000000000000000000000000000000000000000000000000000000000000

x86_64 machine language on Linux, 6 bytes

0:       f3 48 0f bd c7          lzcnt  %rdi,%rax

5:       c3

Try it online!

Python 3, 34 bytes

f=lambda n:-1<n<2**63and-~f(2*n|1)

Try it online!

Jelly, 10 bytes

ḤBL65_ɓ>-×

A monadic Link accepting an integer (within range) which yields an integer.

Try it online! Or see the test-suite.

Python, 31 bytes

lambda n:67-len(bin(-n))&~n>>64

Try it online!

The expresson is the bitwise & of two parts:

67-len(bin(-n)) & ~n>>64

The 67-len(bin(-n)) gives the correct answer for non-negative inputs. It takes the bit length, and subtracts from 67, which is 3 more than 64 to compensate for the -0b prefix. The negation is a trick to adjust for n==0 using that negating it doesn't produce a - sign in front.

The & ~n>>64 makes the answer instead be 0 for negative n. When n<0, ~n>>64 equals 0 (on 64-bit integers), so and-ing with it gives 0. When n>=0, the ~n>>64 evaluates to -1, and doing &-1 has no effect.

Python 2, 36 bytes

f=lambda n:n>0and~-f(n/2)or(n==0)*64

Try it online!

Arithmetical alternative.

PowerShell, 44 bytes

param($a)64-[Convert]::ToString($a,2).Length

Takes input from a commandline argument.

JavaScript (Node.js), 25 bytes

Takes input as a BigInt literal.

f=n=>n<0?0:n?f(n/2n)-1:64

Try it online!

Or 24 bytes by returning false instead of $0$.

Perl 6, 35 bytes

$!={$_??($_>0)*($!($_/2+|0)-1)!!64}

Try it online!

32 bytes if we can return false instead of 0.

$!={$_??$_>0&&$!($_/2+|0)-1!!64}

Try it online!

28 bytes if we can use string operations:

{.fmt("%064b")~~/^(0)*/;+$0}

Try it online!

Anonymous code block that takes a number and returns a number.

Explanation:

{                         }  # Anonymous code block

 .fmt("%064b")               # Format as a binary number with 64 digits

              ~~             # Smartmatch against

                /^(0)*/      # A regex counting leading zeroes

                       ;+$0  # Return the number of leading zeroes