Vấn đề:

Tìm số lượng số 0 đứng đầu trong số nguyên có chữ ký 64 bit

Quy tắc:

• Đầu vào không thể được coi là chuỗi; nó có thể là bất cứ điều gì trong đó toán học và các phép toán bitwise điều khiển thuật toán
• Đầu ra phải được xác nhận dựa trên biểu diễn số nguyên có chữ ký 64 bit, bất kể ngôn ngữ
• Quy tắc golf mặc định áp dụng
• Mã ngắn nhất tính bằng byte

Các trường hợp thử nghiệm:

Các xét nghiệm này giả định hai số nguyên đã ký bổ sung. Nếu ngôn ngữ / giải pháp của bạn thiếu hoặc sử dụng một đại diện khác của các số nguyên đã ký, vui lòng gọi ra và cung cấp các trường hợp kiểm tra bổ sung có thể có liên quan. Tôi đã bao gồm một số trường hợp thử nghiệm có độ chính xác gấp đôi, nhưng xin vui lòng đề xuất bất kỳ trường hợp nào khác cần được liệt kê.

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

Ngôn ngữ máy x86_64 trên Linux, 6 byte

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

Yêu cầu bộ xử lý Haswell hoặc K10 trở lên có lzcnthướng dẫn.

Hãy thử trực tuyến!

Lục giác , 78 70 byte

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

Hãy thử trực tuyến!

Đây không phải là thách thức quá tầm thường đối với một ngôn ngữ thực tế? ;)

_{chiều dài bên 6. Tôi không thể lắp nó trong một hình lục giác dài 5 cạnh.}

Giải trình

Python , 31 byte

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

Hãy thử trực tuyến!

Expresson là bitwise &của hai phần:

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

Các 67-len(bin(-n))câu trả lời chính xác cho đầu vào không âm. Nó lấy độ dài bit và trừ đi từ 67, tức là hơn 3 so với 64 để bù cho -0btiền tố. Phủ định là một mẹo để điều chỉnh cho n==0việc sử dụng phủ định nó không tạo ra- dấu hiệu phía trước.

Các & ~n>>64làm cho câu trả lời thay vì được 0cho tiêu cực n. Khi n<0, ~n>>64bằng 0 (trên số nguyên 64 bit), do đó, và với nó mang lại 0. Khi n>=0, việc ~n>>64đánh giá -1và làm &-1không có hiệu lực.

Python 2 , 36 byte

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

Hãy thử trực tuyến!

Thay thế số học.

Java 8, 32 26 byte.

Long::numberOfLeadingZeros

Nội dung FTW.

-6 byte nhờ Kevin Cruijssen

Hãy thử trực tuyến!

C (gcc) , 14 byte

__builtin_clzl

Hoạt động tốt trên tio

C (gcc) , 35 29 byte

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

Hãy thử trực tuyến!

Hơn Dennis cho 6 byte

Cờ trình biên dịch C (gcc) , 29 byte của David Foerster

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

Hãy thử trực tuyến!

Perl 6 , 35 28 26 byte

-2 byte nhờ nwellnhof

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

Hãy thử trực tuyến!

Khối mã ẩn danh lấy một số và trả về một số. Điều này chuyển đổi số thành một chuỗi nhị phân và đếm các số 0 đứng đầu. Nó hoạt động cho các số âm bởi vì ký tự đầu tiên là một -ví dụ -00000101, vì vậy không có số 0 đứng đầu.

Giải trình:

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

Đưa đầu vào là một chữ BigInt.

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

Hãy thử trực tuyến!

$0$

Python 3 , 34 byte

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

Hãy thử trực tuyến!

J , 18 byte

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

Hãy thử trực tuyến!

J , 19 byte

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

Hãy thử trực tuyến!

Giải trình:

                #:  - 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 byte

-2 byte nhờ Jo King

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

Hãy thử trực tuyến!

Ruby , 22 byte

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

Hãy thử trực tuyến!

05AB1E , 10 9 byte

·bg65αsd*

I / O đều là số nguyên

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

·         # 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 byte

^{Cảm ơn xnor vì đã phát hiện ra một sai lầm!}

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

Có thể phân bổ khá nhiều bộ nhớ, hãy thử trực tuyến!

Có thể bạn muốn kiểm tra nó với hằng số nhỏ hơn: Hãy thử 8-bit!

Giải trình

Thay vì sử dụng mapM(pure[0,1])[1..64]để chuyển đổi đầu vào thành nhị phân, chúng tôi sẽ sử dụng mapM(pure[1,0])[1..64]để tạo ra các chuỗi đảo ngược$\lbrace0,1\rbrace^{64}$theo thứ tự từ điển. Vì vậy, chúng tôi chỉ có thể tổng hợp$1$tiền tố s bằng cách sử dụng sum.fst.span(>0).

Powershell, 51 byte

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

Kịch bản thử nghiệm:

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

Đầu ra:

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 byte

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

Nhập dưới dạng long(số nguyên 64 bit), đầu ra dưới dạngint (số nguyên 32 bit).

Câu trả lời C (gcc) của cảng @ l4m2 .

Hãy thử trực tuyến.

Giải trình:

 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: Có thể là 26 byte bằng cách sử dụng nội dung Long::numberOfLeadingZerosnhư được hiển thị trong câu trả lời Java 8 của @lukeg .

APL + THẮNG, 34 byte

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

Giải trình:

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 # (Trình biên dịch tương tác Visual C #) , 42 byte

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

Hãy thử trực tuyến!

C # (Trình biên dịch tương tác Visual C #) , 31 byte

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

Thậm chí ngắn hơn, dựa trên câu trả lời C (gcc) của @ l4m2. Không bao giờ biết rằng bạn có thể khai báo các chức năng như vậy, cảm ơn @Dana!

Hãy thử trực tuyến!

Thạch ,  10  9 byte

-1 nhờ một mánh khóe gọn gàng của Erik the Outgolfer (hiện tại không phải là tiêu cực AƑ)

ḤBL65_×AƑ

Liên kết đơn âm chấp nhận một số nguyên (trong phạm vi) mang lại một số nguyên.

Hãy thử trực tuyến! Hoặc xem bộ thử nghiệm .

10 là ḤBL65_ɓ>-×

Đây là một giải pháp 10 byte khác, mà tôi thích vì nó nói là "BOSS" ...

BoṠS»-~%65

Bộ thử nghiệm ở đây

...BoṠS63r0¤i , BoṠS63ŻṚ¤iHoặc BoṠS64ḶṚ¤icũng sẽ làm việc.

10 byter khác (từ Dennis) là æ»64ḶṚ¤Äċ0(một lần nữa æ»63r0¤Äċ0và æ»63ŻṚ¤Äċ0cũng sẽ hoạt động)

Perl 5 , 37 byte

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

Hãy thử trực tuyến!

Hoặc 46 byte này nếu không cho phép "chuỗi hóa": sub z

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

Swift (trên nền tảng 64 bit), 41 byte

Khai báo một bao đóng được gọi là fchấp nhận và trả về một Int. Giải pháp này chỉ hoạt động một cách chính xác nền tảng 64-bit, nơi Intđược typealiased để Int64. (Trên nền tảng 32 bit, Int64có thể được sử dụng rõ ràng cho loại tham số của bao đóng, thêm 2 byte.)

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

Trong Swift, ngay cả kiểu số nguyên cơ bản là một đối tượng bình thường được khai báo trong thư viện chuẩn. Điều này có nghĩa là Intcó thể có các phương thức và thuộc tính, chẳng hạn như leadingZeroBitCount(được yêu cầu trên tất cả các loại tuân thủ FixedWidthIntegergiao thức của thư viện chuẩn ).

Haskell , 24 byte

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

Hãy thử trực tuyến!

Điều này về cơ bản giống như giải pháp Java của Kevin Cruijssen, nhưng tôi thấy nó độc lập.

Đối số nên có kiểu Intcho bản dựng 64 bit, hoặcInt64 cho bất cứ thứ gì.

Giải trình

Nếu đối số là âm, kết quả là ngay lập tức 0. Nếu không, chúng ta dịch chuyển sang trái, điền vào các đối số , cho đến khi chúng ta đạt đến một số âm. Việc điền đó cho phép chúng tôi tránh trường hợp đặc biệt cho 0.

Chỉ để tham khảo, đây là cách rõ ràng / hiệu quả:

34 byte

import Data.Bits
countLeadingZeros

Sạch , 103 byte

Sử dụng cùng "dựng" như câu trả lời của trần nhà.

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

Hãy thử trực tuyến!

Sạch , 58 byte

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

Hãy thử trực tuyến!

Stax , 10 byte

în»╧3(∞┼⌠g

Chạy và gỡ lỗi nó

Đó là một cổng của giải pháp 05AB1E của Kevin.

Perl 5 -p , 42 byte

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

Hãy thử trực tuyến!

Dài hơn một giải pháp dựa trên chuỗi bit, nhưng là một giải pháp dựa trên toán học đàng hoàng.

APL (NARS), 15 ký tự, 30 byte

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

kiểm tra vài con số để xem cách sử dụng:

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

Rust, 18 byte

i64::leading_zeros

Hãy thử trực tuyến!

K (ngn / k) , 6 byte

64-#2\

Hãy thử trực tuyến!

2\ mã hóa đối số trong nhị phân

# chiều dài

64- trừ 64

PHP, 50 46 byte

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

Chạy như ống với -Rhoặc thử trực tuyến ,

<?=$argn<0?0:0|64-log($argn+1,2);có vấn đề làm tròn số; Vì vậy, tôi đã đi đường dài.

Ngôn ngữ Wolfram (Mathicala) , 41 byte

Công thức cho các số dương chỉ là 63-Floor@Log2@#& . Quy tắc thay thế được sử dụng cho các trường hợp đặc biệt của đầu vào số 0 và âm.

Đầu vào không cần phải là số nguyên có chữ ký 64 bit. Điều này sẽ có hiệu quả lấy sàn của đầu vào để biến nó thành một số nguyên. Nếu bạn nhập một số bên ngoài giới hạn bình thường cho số nguyên 64 bit, nó sẽ trả về một số âm cho biết cần bao nhiêu bit nữa để lưu số nguyên này.

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

Hãy thử trực tuyến!

Giải pháp của @ LegionMammal978 ngắn hơn một chút với 28 byte. Đầu vào phải là một số nguyên. Theo tài liệu: "thực sự BitLength[n]là một phiên bản hiệu quả của Floor[Log[2,n]]+1." Nó tự động xử lý trường hợp không báo cáo chính xác 0thay vì-∞ .

Ngôn ngữ Wolfram (Mathicala) , 28 byte

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

Hãy thử trực tuyến!

bitNumber - math.ceil (math.log (số) / math.log (2))

ví dụ: 64 bit SỐ: 9223372036854775807 math.ceil (math.log (9223372036854775807) / math.log (2)) ANS: 63