ปัญหา:

ค้นหาจำนวนของศูนย์นำหน้าในจำนวนเต็มแบบ 64 บิต

กฎ:

• อินพุตไม่สามารถถือเป็นสตริงได้ มันสามารถเป็นอะไรก็ได้ที่การดำเนินการทางคณิตศาสตร์และ bitwise เป็นตัวผลักดันอัลกอริธึม
• เอาต์พุตควรตรวจสอบความถูกต้องกับการแสดงตัวเลขจำนวนเต็มแบบ 64 บิตของหมายเลขโดยไม่คำนึงถึงภาษา
• ใช้กฎของรหัสกอล์ฟเริ่มต้น
• รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

กรณีทดสอบ:

การทดสอบเหล่านี้ถือว่าเป็นจำนวนเต็มแบบเต็มของสองส่วน หากภาษา / การแก้ปัญหาของคุณขาดหรือใช้การแทนจำนวนเต็มที่ลงนามแตกต่างกันโปรดโทรออกและแจ้งกรณีทดสอบเพิ่มเติมที่อาจเกี่ยวข้อง ฉันได้รวมกรณีทดสอบบางข้อที่กล่าวถึงความแม่นยำสองเท่า แต่โปรดอย่าลังเลที่จะแนะนำรายการอื่น ๆ ที่ควรแสดง

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

x86_64 ภาษาเครื่องบน Linux, 6 ไบต์

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

ต้องการตัวประมวลผล Haswell หรือ K10 หรือสูงกว่าพร้อมlzcntคำสั่ง

ลองออนไลน์!

Hexagony , 78 70 ไบต์

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

ลองออนไลน์!

ความท้าทายนี้ไม่สำคัญเกินไปสำหรับภาษาที่ใช้งานจริงหรือ ;)

_{ความยาวด้าน 6. ฉันไม่สามารถใส่ในความยาวด้าน 5 เหลี่ยมหกเหลี่ยม}

คำอธิบาย

Pythonขนาด 31 ไบต์

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

ลองออนไลน์!

expresson เป็น bitwise &ของสองส่วน:

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

67-len(bin(-n))ให้คำตอบที่ถูกต้องสำหรับปัจจัยการผลิตที่ไม่ใช่เชิงลบ ใช้ความยาวบิตและลบออกจาก 67 ซึ่งเป็น 3 มากกว่า 64 เพื่อชดเชย-0bคำนำหน้า การปฏิเสธคือเคล็ดลับในการปรับการn==0ใช้ที่เป็นการปฏิเสธว่าไม่ได้สร้าง-สัญญาณไว้ข้างหน้า

& ~n>>64ทำให้คำตอบแทนที่จะเป็นเชิงลบ0 nเมื่อn<0, ~n>>64เท่ากับ 0 (ในจำนวนเต็ม 64 บิต) 0เพื่อและไอเอ็นจีกับมันให้ เมื่อn>=0ใดที่~n>>64ประเมิน-1และทำ&-1ไม่มีผล

Python 2 , 36 ไบต์

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

ลองออนไลน์!

ทางเลือกเกี่ยวกับคณิตศาสตร์

Java 8, 32 26 ไบต์

Long::numberOfLeadingZeros

Builtins FTW

-6 ไบต์ขอบคุณ Kevin Cruijssen

ลองออนไลน์!

C (gcc) , 14 ไบต์

__builtin_clzl

ทำงานได้ดีบน tio

C (gcc) , 35 29 ไบต์

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

ลองออนไลน์!

Than Dennis ราคา 6 ไบต์

ธงคอมไพเลอร์C (gcc) , 29 ไบต์โดย David Foerster

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

ลองออนไลน์!

Perl 6 , 35 28 26 ไบต์

-2 ไบต์ต้องขอบคุณ nwellnhof

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

ลองออนไลน์!

การบล็อกโค้ดแบบไม่ระบุชื่อที่ใช้ตัวเลขและส่งคืนตัวเลข นี่จะแปลงตัวเลขเป็นสตริงไบนารีและนับจำนวนศูนย์นำหน้า มันใช้งานได้กับจำนวนลบเพราะอักขระตัวแรกเป็น-เช่น-00000101ดังนั้นจึงไม่มีเลขศูนย์นำหน้า

คำอธิบาย:

{                        }  # 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 ไบต์

ใช้อินพุตเป็นตัวอักษร BigInt

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

ลองออนไลน์!

$0$

Python 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

Perl 6 , 18 ไบต์

-2 ไบต์ขอบคุณ Jo King

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

Haskell , 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)

Powershell, 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

Java 8, 38 ไบต์

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

อินพุตเป็นlong(จำนวนเต็ม 64- บิต), ส่งออกเป็นint(จำนวนเต็ม 32- บิต)

พอร์ตของ@ l4m2 's 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

แก้ไข: สามารถเป็น26 ไบต์โดยใช้ builtin Long::numberOfLeadingZerosตามที่แสดงใน@lukeg 's Java 8 คำตอบ

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 # Interactive Compiler) , 42 ไบต์

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

ลองออนไลน์!

C # (Visual C # Interactive คอมไพเลอร์) , 31 ไบต์

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

สั้นกว่าเดิมโดยอิงจากคำตอบ C (gcc)ของ @ l4m2 ไม่เคยรู้เลยว่าคุณสามารถประกาศฟังก์ชั่นแบบนั้นได้ขอบคุณ @Dana!

ลองออนไลน์!

เยลลี่ ,  10  9 ไบต์

-1 ด้วยเคล็ดลับที่ประณีตโดย Erik the Outgolfer (ตอนนี้ไม่ใช่เชิงลบตอนนี้เป็นเพียงแค่AƑ)

ḤBL65_×AƑ

ลิงค์ monadic ยอมรับจำนวนเต็ม (ภายในช่วง) ซึ่งให้ผลเป็นจำนวนเต็ม

ลองออนไลน์! หรือดูการทดสอบในตัว

10 รายการคือ ḤBL65_ɓ>-×

นี่เป็นอีกหนึ่งโซลูชั่น 10 ไบต์ซึ่งฉันชอบเพราะมันบอกว่ามันเป็น "BOSS" ...

BoṠS»-~%65

ทดสอบชุดที่นี่

... BoṠS63r0¤i, BoṠS63ŻṚ¤iหรือBoṠS64ḶṚ¤iจะยังทำงาน

อีก 10 byter (จาก Dennis) คือæ»64ḶṚ¤Äċ0(อีกครั้งæ»63r0¤Äċ0และæ»63ŻṚ¤Äċ0จะทำงานด้วย)

Perl 5 , 37 ไบต์

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

ลองออนไลน์!

หรือ 46 ไบต์นี้หากไม่อนุญาตให้ใช้ "การทำให้เป็นสตริง": sub z

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

Swift (บนแพลตฟอร์ม 64 บิต), 41 ไบต์

ประกาศปิดที่เรียกว่าที่รับและส่งกลับf Intโซลูชันนี้ใช้งานได้อย่างถูกต้องกับแพลตฟอร์ม 64 บิตซึ่งIntมีtypealiasการInt64แก้ไข (บนแพลตฟอร์ม 32- บิตInt64สามารถใช้อย่างชัดเจนสำหรับประเภทพารามิเตอร์ของการปิดเพิ่ม 2 ไบต์)

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

ใน Swift แม้แต่ชนิดจำนวนเต็มพื้นฐานเป็นวัตถุธรรมดาที่ประกาศในไลบรารีมาตรฐาน ซึ่งหมายความว่าIntสามารถมีวิธีการและคุณสมบัติเช่นleadingZeroBitCount(ซึ่งจำเป็นสำหรับทุกประเภทที่สอดคล้องกับFixedWidthIntegerโปรโตคอลของไลบรารีมาตรฐาน)

Haskell , 24 ไบต์

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

ลองออนไลน์!

นี่เป็นพื้นฐานเหมือนกับโซลูชัน Java ของ Kevin Cruijssen แต่ฉันพบว่าเป็นอิสระ

อาร์กิวเมนต์ควรมีประเภทIntสำหรับบิลด์ 64 บิตหรือInt64อะไรก็ได้

คำอธิบาย

หากอาร์กิวเมนต์เป็นลบผลลัพธ์จะเป็น 0 ทันทีมิเช่นนั้นเราจะเลื่อนไปทางซ้ายเติมด้วยอักขระจนกว่าจะถึงจำนวนลบ การเติมนั้นช่วยให้เราหลีกเลี่ยงกรณีพิเศษสำหรับ 0

เพื่อการอ้างอิงนี่เป็นวิธีที่ชัดเจน / มีประสิทธิภาพ:

34 ไบต์

import Data.Bits
countLeadingZeros

ทำความสะอาด , 103 ไบต์

ใช้"builtin"เดียวกันกับคำตอบของ 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

เรียกใช้และแก้ไขข้อบกพร่อง

มันเป็นท่าเรือของโซลูชั่น 05AB1E ของเควิน

Perl 5 -p , 42 ไบต์

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

ลองออนไลน์!

ยาวกว่าโซลูชันที่อิงกับ bitstring แต่เป็นโซลูชันที่ใช้คณิตศาสตร์ได้ดี

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 (Mathematica) , 41 ไบต์

63-Floor@Log2@#&สูตรสำหรับตัวเลขบวกเป็นเพียง กฎการแทนที่ใช้สำหรับกรณีพิเศษของศูนย์และอินพุตเชิงลบ

อินพุตไม่จำเป็นต้องเป็นจำนวนเต็มแบบ 64 บิต สิ่งนี้จะนำพื้นของอินพุตเพื่อแปลงเป็นจำนวนเต็มอย่างมีประสิทธิภาพ หากคุณป้อนตัวเลขที่อยู่นอกขอบเขตปกติสำหรับจำนวนเต็ม 64 บิตมันจะบอกให้ส่งคืนจำนวนลบซึ่งระบุจำนวนบิตที่จะต้องใช้ในการเก็บจำนวนเต็มนี้

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

ลองออนไลน์!

วิธีแก้ปัญหาของ @ LegionMammal978 นั้นค่อนข้างสั้นที่ 28 ไบต์ อินพุตต้องเป็นจำนวนเต็ม ต่อเอกสาร: " BitLength[n]ได้อย่างมีประสิทธิภาพรุ่นที่มีประสิทธิภาพของFloor[Log[2,n]]+1." โดยจะจัดการกับกรณีของศูนย์อย่างถูกต้องรายงานมากกว่า0-∞

ภาษา Wolfram (Mathematica)ขนาด 28 ไบต์

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

ลองออนไลน์!

bitNumber - math.ceil (math.log (หมายเลข) / math.log (2))

เช่น 64 บิตหมายเลข: 9223372036854775807 math.ceil (math.log (9223372036854775807) / math.log (2)) ANS: 63