Problema:

Encontre o número de zeros à esquerda em um número inteiro assinado de 64 bits

Regras:

• A entrada não pode ser tratada como sequência; pode ser qualquer coisa em que operações matemáticas e bit a bit conduzem o algoritmo
• A saída deve ser validada com relação à representação inteira assinada de 64 bits do número, independentemente do idioma
• Aplicam-se as regras de código padrão de golfe
• O menor código em bytes ganha

Casos de teste:

Esses testes assumem números inteiros assinados pelo complemento de dois. Se seu idioma / solução não possui ou usa uma representação diferente de números inteiros assinados, chame isso e forneça casos de teste adicionais que possam ser relevantes. Incluí alguns casos de teste que abordam precisão dupla, mas fique à vontade para sugerir outros que devem ser listados.

input                output   64-bit binary representation of input (2's complement)
-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

Linguagem de máquina x86_64 no Linux, 6 bytes

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

Requer processador Haswell ou K10 ou superior com lzcnt instruções.

Experimente online!

Hexagonia , 78 70 bytes

2"1"\.}/{}A=<\?>(<$\*}[_(A\".{}."&.'\&=/.."!=\2'%<..(@.>._.\=\{}:"<><$

Experimente online!

Esse desafio não é trivial demais para uma linguagem prática? ;)

_{comprimento lateral 6. Não consigo encaixá-lo em um hexágono de comprimento lateral 5.}

Explicação

Python , 31 bytes

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

Experimente online!

O expresson é o bit a bit &de duas partes:

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

O 67-len(bin(-n))fornece a resposta correta para entradas não negativas. Ele pega o comprimento do bit e subtrai de 67, que é 3 a mais que 64 para compensar o -0bprefixo. A negação é um truque para ajustar ao n==0usar essa negação que não produz um- sinal na frente.

Em & ~n>>64vez disso, a resposta é 0negativa n. Quando n<0, ~n>>64é igual a 0 (em números inteiros de 64 bits), e assim por diante 0. Quando n>=0, o ~n>>64avalia -1e o fazer &-1não tem efeito.

Python 2 , 36 bytes

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

Experimente online!

Alternativa aritmética.

Java 8, 32 26 bytes.

Long::numberOfLeadingZeros

Builtins FTW.

-6 bytes graças a Kevin Cruijssen

Experimente online!

C (gcc) , 14 bytes

__builtin_clzl

Funciona bem em tio

C (gcc) , 35 29 bytes

f(long n){n=n<0?0:f(n-~n)+1;}

Experimente online!

Than Dennis por 6 bytes

Sinalizadores do compilador C (gcc) , 29 bytes por David Foerster

-Df(n)=n?__builtin_clzl(n):64

Experimente online!

Perl 6 , 35 28 26 bytes

-2 bytes graças a nwellnhof

{to .fmt("%064b")~~/^0*/:}

Experimente online!

Bloco de código anônimo que pega um número e retorna um número. Isso converte o número em uma string binária e conta os zeros iniciais. Funciona para números negativos porque o primeiro caractere é um -exemplo -00000101, portanto, não há zeros à esquerda.

Explicação:

{                        }  # Anonymous code block
    .fmt("%064b")           # Format as a binary string with 64 digits
                 ~~         # Smartmatch against
                   /^0*/    # A regex counting leading zeroes
 to                     :   # Return the index of the end of the match

JavaScript (Node.js) , 25 bytes

Recebe a entrada como um literal BigInt.

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

Experimente online!

$0$

Python 3 , 34 bytes

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

Experimente online!

J , 18 bytes

0{[:I.1,~(64$2)#:]

Experimente online!

J , 19 bytes

1#.[:*/\0=(64$2)#:]

Experimente online!

Explicação:

                #:  - convert 
                  ] - the input to
          (64$2)    - 64 binary digits
         =          - check if each digit equals 
        0           - zero
   [:*/\            - find the running product
1#.                 - sum

Perl 6 , 18 bytes

-2 bytes graças a Jo King

64-(*%2**64*2).msb

Experimente online!

Ruby , 22 bytes

->n{/[^0]/=~"%064b"%n}

Experimente online!

05AB1E , 10 9 bytes

·bg65αsd*

E / S são números inteiros

Experimente online ou verifique todos os casos de teste .

Explicação:

·         # Double the (implicit) input
          #  i.e. -1 → -2
          #  i.e. 4503599627370496 → 9007199254740992
 b        # Convert it to binary
          #  i.e. -2 → "ÿ0"
          #  i.e. 9007199254740992 → 100000000000000000000000000000000000000000000000000000
  g       # Take its length
          #  i.e. "ÿ0" → 2
          #  i.e. 100000000000000000000000000000000000000000000000000000 → 54
   65α    # Take the absolute different with 65
          #  i.e. 65 and 2 → 63
          #  i.e. 65 and 54 → 11
      s   # Swap to take the (implicit) input again
       d  # Check if it's non-negative (>= 0): 0 if negative; 1 if 0 or positive
          #  i.e. -1 → 0
          #  i.e. 4503599627370496 → 1
        * # Multiply them (and output implicitly)
          #  i.e. 63 and 0 → 0
          #  i.e. 11 and 1 → 11

Haskell , 56 bytes

^{Obrigado xnor por detectar um erro!}

f n|n<0=0|1>0=sum.fst.span(>0)$mapM(pure[1,0])[1..64]!!n

Pode alocar bastante memória, experimente online!

Talvez você queira testá-lo com uma constante menor: tente 8 bits!

Explicação

mapM(pure[0,1])[1..64]mapM(pure[1,0])[1..64]$\lbrace0,1\rbrace^{64}$$1$sum.fst.span(>0)

Powershell, 51 bytes

param([long]$n)for(;$n-shl$i++-gt0){}($i,65)[!$n]-1

Script de teste:

$f = {

param([long]$n)for(;$n-shl$i++-gt0){}($i,65)[!$n]-1

}

@(
    ,(-1                   ,0 )
    ,(-9223372036854775808 ,0 )
    ,(9223372036854775807  ,1 )
    ,(4611686018427387903  ,2 )
    ,(1224979098644774911  ,3 )
    ,(9007199254740992     ,10)
    ,(4503599627370496     ,11)
    ,(4503599627370495     ,12)
    ,(2147483648           ,32)
    ,(2147483647           ,33)
    ,(2                    ,62)
    ,(1                    ,63)
    ,(0                    ,64)
) | % {
    $n,$expected = $_
    $result = &$f $n
    "$($result-eq$expected): $result"
}

Resultado:

True: 0
True: 0
True: 1
True: 2
True: 3
True: 10
True: 11
True: 12
True: 32
True: 33
True: 62
True: 63
True: 64

Java 8, 38 bytes

int f(long n){return n<0?0:f(n-~n)+1;}

Entrada como long(número inteiro de 64 bits), saída como int(número inteiro de 32 bits).

Porta da resposta C (gcc) de @44m2 .

Experimente online.

Explicação:

 int f(long n){       // Recursive method with long parameter and integer return-type
   return n<0?        //  If the input is negative:
           0          //   Return 0
          :           //  Else:
           f(n-~n)    //   Do a recursive call with n+n+1
                  +1  //   And add 1

EDIT: Pode ter 26 bytes usando o built-Long::numberOfLeadingZeros in conforme exibido na resposta Java 8 do @lukeg .

APL + WIN, 34 bytes

+/×\0=(0>n),(63⍴2)⊤((2*63)××n)+n←⎕

Explicação:

n←⎕ Prompts for input of number as integer

((2*63)××n) If n is negative add 2 to power 63

(63⍴2)⊤ Convert to 63 bit binary

(0>n), Concatinate 1 to front of binary vector if n negative, 0 if positive

+/×\0= Identify zeros, isolate first contiguous group and sum if first element is zero

C # (compilador interativo do Visual C #) , 42 bytes

x=>x!=0?64-Convert.ToString(x,2).Length:64

Experimente online!

C # (compilador interativo do Visual C #) , 31 bytes

int c(long x)=>x<0?0:c(x-~x)+1;

Ainda mais curto, com base na resposta C (gcc) de l4m2. Nunca soube que você poderia declarar funções assim, obrigado @Dana!

Experimente online!

Geléia ,  10  9 bytes

-1 graças a um puro truque de Erik, o Outgolfer (agora não é negativo, agora é simplesmente AƑ)

ḤBL65_×AƑ

Um link monádico que aceita um número inteiro (dentro do intervalo) que gera um número inteiro.

Experimente online! Ou veja a suíte de testes .

O 10 foi ḤBL65_ɓ>-×

Aqui está outra solução de 10 bytes, que eu gosto, pois diz que é "BOSS" ...

BoṠS»-~%65

Conjunto de teste aqui

... BoṠS63r0¤i, BoṠS63ŻṚ¤iou BoṠS64ḶṚ¤itambém funcionaria.

Outro 10 byter (de Dennis) é æ»64ḶṚ¤Äċ0(novamente æ»63r0¤Äċ0e æ»63ŻṚ¤Äċ0também funcionará)

Perl 5 , 37 bytes

sub{sprintf("%064b",@_)=~/^0*/;$+[0]}

Experimente online!

Ou 46 bytes se a "stringification" não for permitida: sub z

sub{my$i=0;$_[0]>>64-$_?last:$i++for 1..64;$i}

Swift (em uma plataforma de 64 bits), 41 bytes

Declara um fechamento chamado fque aceita e retorna um Int. Esta solução funciona apenas corretamente em plataformas de 64 bits, para onde Inté typealiaseditada Int64. (Em uma plataforma de 32 bits, Int64pode ser usado explicitamente para o tipo de parâmetro do fechamento, adicionando 2 bytes.)

let f:(Int)->Int={$0.leadingZeroBitCount}

No Swift, mesmo o tipo inteiro fundamental é um objeto comum declarado na biblioteca padrão. Isso significa que Intpode ter métodos e propriedades, como leadingZeroBitCount(que é necessário em todos os tipos em conformidade com o FixedWidthIntegerprotocolo da biblioteca padrão ).

Haskell , 24 bytes

f n|n<0=0
f n=1+f(2*n+1)

Experimente online!

Isso é basicamente o mesmo que a solução Java de Kevin Cruijssen, mas eu a achei de forma independente.

O argumento deve ter um tipo Intpara uma compilação de 64 bits ouInt64 para qualquer coisa.

Explicação

Se o argumento for negativo, o resultado será imediatamente 0. Caso contrário, mudamos para a esquerda, preenchendo um , até chegar a um número negativo. Esse preenchimento nos permite evitar um caso especial para 0.

Apenas para referência, aqui está a maneira óbvia / eficiente:

34 bytes

import Data.Bits
countLeadingZeros

Limpo , 103 bytes

Usa o mesmo "embutido" que a resposta do tetocat.

f::!Int->Int
f _=code {
instruction 243
instruction 72
instruction 15
instruction 189
instruction 192
}

Experimente online!

Limpo , 58 bytes

import StdEnv
$0=64
$i=until(\e=(2^63>>e)bitand i<>0)inc 0

Experimente online!

Stax , 10 bytes

în»╧3(∞┼⌠g

Execute e depure

É uma porta da solução 05AB1E de Kevin.

Perl 5 -p , 42 bytes

1while$_>0&&2**++$a-1<$_;$_=0|$_>=0&&64-$a

Experimente online!

Mais do que uma solução baseada em bitstring, mas uma solução decente baseada em matemática.

APL (NARS), 15 caracteres, 30 bytes

{¯1+1⍳⍨⍵⊤⍨64⍴2}

teste alguns números para ver como usar:

  f←{¯1+1⍳⍨⍵⊤⍨64⍴2}
  f ¯9223372036854775808
0
  f 9223372036854775807
1

Ferrugem, 18 bytes

i64::leading_zeros

Experimente online!

K (ngn / k) , 6 bytes

64-#2\

Experimente online!

2\ codificar o argumento em binário

# comprimento

64- subtrair de 64

PHP, 50 46 bytes

for(;0<$n=&$argn;$n>>=1)$i++;echo$n<0?0:64-$i;

Execute como pipe -Rou experimente on-line ,

<?=$argn<0?0:0|64-log($argn+1,2);tem problemas de arredondamento; então eu segui o longo caminho.

Wolfram Language (Mathematica) , 41 bytes

A fórmula para números positivos é justa 63-Floor@Log2@#&. Regras de substituição são usadas para casos especiais de entrada zero e negativa.

A entrada não precisa ser um número inteiro assinado de 64 bits. Isso levará efetivamente o piso da entrada para transformá-la em um número inteiro. Se você inserir um número fora dos limites normais para um número inteiro de 64 bits, ele retornará um número negativo indicando quantos bits mais seriam necessários para armazenar esse número inteiro.

63-Floor@Log2[#/.{_?(#<0&):>2^63,0:>.5}]&

Experimente online!

A solução da @ LegionMammal978 é um pouco menor em 28 bytes. A entrada deve ser um número inteiro. De acordo com a documentação: " BitLength[n]é efetivamente uma versão eficiente de Floor[Log[2,n]]+1". Ele lida automaticamente com o caso de zero relatório correto em 0vez de-∞ .

Wolfram Language (Mathematica) , 28 bytes

Boole[#>=0](64-BitLength@#)&

Experimente online!

bitNumber - math.ceil (math.log (número) / math.log (2))

por exemplo, 64 bits NÚMERO: 9223372036854775807 math.ceil (math.log (9223372036854775807) / math.log (2)) ANS: 63