문제:

64 비트 부호있는 정수에서 선행 0 수를 찾습니다.

규칙 :

• 입력을 문자열로 취급 할 수 없습니다. 수학 및 비트 연산이 알고리즘을 구동하는 모든 것이 될 수 있습니다.
• 언어에 관계없이 출력은 숫자의 부호있는 64 비트 정수 표현에 대해 유효성을 검증해야합니다.
• 기본 코드 골프 규칙이 적용됩니다
• 바이트 단위의 최단 코드 승리

테스트 사례 :

이 테스트에서는 2의 보수 부호있는 정수를 가정합니다. 언어 / 솔루션에 부호없는 정수의 다른 표현이 없거나 사용하는 경우이를 호출하고 관련성이있는 추가 테스트 사례를 제공하십시오. 배정도를 다루는 몇 가지 테스트 사례를 포함 시켰지만, 나열해야 할 다른 것을 제안 해 주시기 바랍니다.

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

Linux의 x86_64 기계 언어, 6 바이트

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

lzcnt명령이있는 Haswell 또는 K10 이상의 프로세서가 필요합니다 .

온라인으로 사용해보십시오!

헥사 고니 , 78 70 바이트

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

온라인으로 사용해보십시오!

이 도전은 실제 언어에 비해 너무 사소하지 않습니까? ;)

_{측면 길이 6. 측면 길이 5 육각형에 맞지 않습니다.}

설명

파이썬 , 31 바이트

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

온라인으로 사용해보십시오!

Expresson은 &두 부분으로 비트 단위 입니다.

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

은 67-len(bin(-n))음이 아닌 입력에 대한 정확한 답을 제공합니다. 그것은 비트 길이를 취하고 67에서 빼고, 이것은 -0b접두사 를 보상하기 위해 64보다 3보다 큽니다 . 부정은 부정 을 앞두고 부호를 n==0만들지 않는다는 것을 사용 하도록 조정하는 트릭 -입니다.

그 & ~n>>64대신에 대답 0은 부정적 n이다. 경우 n<0, ~n>>64(64 비트 정수에서) 0과 동일하므로 준다와 한창 0. 때 n>=0(가), ~n>>64평가 -1및 수행 &-1에는 영향을주지 않습니다.

파이썬 2 , 36 바이트

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

온라인으로 사용해보십시오!

산술 대안.

Java 8, 32 26 바이트

Long::numberOfLeadingZeros

내장 FTW.

Kevin Cruijssen 덕분에 -6 바이트

온라인으로 사용해보십시오!

C (gcc) , 14 바이트

__builtin_clzl

Tio에서 잘 작동합니다

C (gcc) , 35 29 바이트

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

온라인으로 사용해보십시오!

6 바이트 동안 Dennis보다

C (gcc) 컴파일러 플래그, David Foerster의 29 바이트

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

온라인으로 사용해보십시오!

펄 6 , 35 28 26 바이트

nwellnhof 덕분에 -2 바이트

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

온라인으로 사용해보십시오!

숫자를 받아서 숫자를 반환하는 익명 코드 블록. 숫자를 이진 문자열로 변환하고 선행 0을 계산합니다. 첫 번째 문자가 -예 이므로 음수로 작동 -00000101하므로 선행 0이 없습니다.

설명:

{                        }  # 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

자바 스크립트 (Node.js) , 25 바이트

입력을 BigInt 리터럴로 사용합니다.

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

온라인으로 사용해보십시오!

$0$

파이썬 3 , 34 바이트

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

온라인으로 사용해보십시오!

J , 18 바이트

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

온라인으로 사용해보십시오!

J , 19 바이트

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

온라인으로 사용해보십시오!

설명:

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

펄 6 , 18 바이트

Jo King 덕분에 -2 바이트

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

온라인으로 사용해보십시오!

루비 , 22 바이트

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

온라인으로 사용해보십시오!

05AB1E , 10 9 바이트

·bg65αsd*

I / 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

하스켈 , 56 바이트

^{실수를 발견해 주셔서 감사합니다 xnor !}

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

상당히 많은 메모리를 할당 할 수 있습니다. 온라인으로 사용해보십시오!

더 작은 상수로 테스트하고 싶을 수도 있습니다 .8 비트를보십시오!

설명

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

파워 쉘, 51 바이트

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

테스트 스크립트 :

$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"
}

산출:

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

자바 8, 38 바이트

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

같은 입력 long(64 비트 정수) 등의 출력 int(32 비트 정수).

@ l4m2 의 C (gcc) 답변 포트 .

온라인으로 사용해보십시오.

설명:

 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

편집 : @lukeg 의 Java 8 answer에 표시된대로 내장을 사용하여 26 바이트 가 될 수 있습니다 .Long::numberOfLeadingZeros

APL + WIN, 34 바이트

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

설명:

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 # (Visual C # 대화식 컴파일러) , 42 바이트

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

온라인으로 사용해보십시오!

C # (Visual C # 대화식 컴파일러) , 31 바이트

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

@ l4m2의 C (gcc) 답변을 기반으로 더 짧습니다 . @Dana 덕분에 그런 함수를 선언 할 수 있다는 것을 결코 알지 못했습니다!

온라인으로 사용해보십시오!

젤리 ,  10  9 바이트

에릭 Outgolfer하여 깔끔한 트릭 -1 덕분에 (IS-음이 아닌 지금 단순히 AƑ)

ḤBL65_×AƑ

정수 (범위 내)를 허용하는 정수 링크는 정수를 생성합니다.

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.

10은 ḤBL65_ɓ>-×

여기에 또 다른 10 바이트 솔루션이 있는데, 이것이 "BOSS"라고 말했기 때문에 좋아합니다 ...

BoṠS»-~%65

시험 스위트 여기

... BoṠS63r0¤i, BoṠS63ŻṚ¤i또는 BoṠS64ḶṚ¤i작동합니다.

(데니스)에서 또 다른 10 byter이다 æ»64ḶṚ¤Äċ0(다시 æ»63r0¤Äċ0및 æ»63ŻṚ¤Äċ0것 또한 일)

펄 5 , 37 바이트

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

온라인으로 사용해보십시오!

또는 "stringification"이 허용되지 않는 경우이 46 바이트 : sub z

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

스위프트 (64 비트 플랫폼), 41 바이트

f을 수락하고 반환하는 클로저를 선언 합니다 Int. 이 솔루션은 제대로 64 비트 플랫폼, 작동 Int됩니다 typealias에 에드 Int64. 32 비트 플랫폼에서는 Int64클로저의 매개 변수 유형에 2 바이트를 추가하여 명시 적으로 사용할 수 있습니다.

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

Swift에서 기본 정수 유형조차 표준 라이브러리에 선언 된 일반 객체입니다. 즉 , 표준 라이브러리 프로토콜을 준수하는 모든 유형에 필요한 Int메소드 및 특성을 가질 수 있습니다 .leadingZeroBitCountFixedWidthInteger

하스켈 , 24 바이트

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

온라인으로 사용해보십시오!

이것은 기본적으로 Kevin Cruijssen의 Java 솔루션과 동일하지만 독립적으로 찾았습니다.

인수는 Int64 비트 빌드 또는 Int64기타 유형이어야합니다 .

설명

인수가 음수이면 결과는 즉시 0입니다. 그렇지 않으면 왼쪽으로 이동 하여 하나를 채 웁니다. 음수에 도달 할 때까지 합니다. 이 충전으로 0에 대한 특별한 경우를 피할 수 있습니다.

참고로 여기에 분명하고 효율적인 방법이 있습니다.

34 바이트

import Data.Bits
countLeadingZeros

클린 , 103 바이트

ceilingcat의 답변과 동일한 "내장" 을 사용합니다 .

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

온라인으로 사용해보십시오!

클린 , 58 바이트

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

온라인으로 사용해보십시오!

Stax , 10 바이트

în»╧3(∞┼⌠g

실행 및 디버깅

Kevin의 05AB1E 솔루션의 포트입니다.

펄 5 -p , 42 바이트

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

온라인으로 사용해보십시오!

비트 열 기반 솔루션보다 길지만 적절한 수학 기반 솔루션입니다.

APL (NARS), 15 자, 30 바이트

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

사용 방법을 보려면 몇 가지 숫자를 테스트하십시오.

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

녹, 18 바이트

i64::leading_zeros

온라인으로 사용해보십시오!

K (ngn / k) , 6 바이트

64-#2\

온라인으로 사용해보십시오!

2\ 이진으로 인수를 인코딩

# 길이

64- 64에서 빼기

PHP, 50 46 바이트

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

파이프로 실행 -R하거나 온라인으로 사용해보십시오 .

<?=$argn<0?0:0|64-log($argn+1,2);반올림 문제가 있습니다. 그래서 먼 길을 갔다.

Wolfram Language (Mathematica) , 41 바이트

양수에 대한 공식은 단지 63-Floor@Log2@#&입니다. 교체 규칙은 특수 입력 0 및 음수 입력에 사용됩니다.

입력은 64 비트 부호있는 정수일 필요는 없습니다. 이것은 입력의 바닥을 효과적으로 정수로 바꿉니다. 64 비트 정수에 대해 정상 범위 밖의 숫자를 입력하면이 정수를 저장하는 데 필요한 비트 수를 나타내는 음수를 반환합니다.

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

온라인으로 사용해보십시오!

@ LegionMammal978의 솔루션은 28 바이트에서 약간 짧습니다. 입력은 정수 여야합니다. 문서에 따르면 : " BitLength[n]효과적으로 효율적인 버전입니다 Floor[Log[2,n]]+1."이 (가) 아닌 정확한보고 0가없는 경우를 자동으로 처리합니다 -∞.

Wolfram Language (Mathematica) , 28 바이트

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

온라인으로 사용해보십시오!

bitNumber-math.ceil (math.log (number) / math.log (2))

예 : 64 비트 NUMBER : 9223372036854775807 math.ceil (math.log (9223372036854775807) / math.log (2)) ANS : 63