Sorun:

64 bit işaretli tamsayıda önde gelen sıfır sayısını bulun

Kurallar:

• Giriş dize olarak ele alınamaz; matematik ve bitsel işlemlerin algoritmayı tahrik ettiği herhangi bir şey olabilir
• Çıktı dilden bağımsız olarak sayının 64 bit imzalı tamsayı gösterimine göre doğrulanmalıdır.
• Varsayılan kod golf kuralları geçerlidir
• Bayt cinsinden en kısa kod kazanır

Test senaryoları:

Bu testler ikinin tamamlayıcı imzalı tam sayılarını varsayar. Dilinizde / çözümünüzde imzalı tamsayıların farklı bir temsili yoksa veya kullanılıyorsa, lütfen bunu arayın ve alakalı olabilecek ek test durumları sağlayın. Çift kesinlik ile ilgili bazı test senaryoları ekledim, ancak lütfen listelenmesi gereken başkalarını önermekten çekinmeyin.

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'ta x86_64 makine dili, 6 bayt

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

Haswell veya K10 veya üstü bir işlemci gerektirir lzcnt.

Çevrimiçi deneyin!

Altıgen , 78 70 bayt

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

Çevrimiçi deneyin!

Bu zorluk pratik bir dil için fazla önemsiz değil mi? ;)

_{yan uzunluk 6. 5 altıgen yan uzunluğa sığamıyorum.}

açıklama

Python , 31 bayt

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

Çevrimiçi deneyin!

Ekspres &iki bölümün bitselidir :

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

67-len(bin(-n))Negatif olmayan girişleri için doğru cevabı verir. Bit uzunluğunu alır ve -0bönekini telafi etmek için 64'ten 3 olan 67'den çıkarır . Olumsuzluk, n==0bunu reddetmenin -önünde bir işaret üretmediği için ayarlama hilesidir .

Bunun & ~n>>64cevabı, bunun 0olumsuz olmasını sağlar n. Ne zaman n<0, ~n>>640'a eşittir (64 bit tamsayılarda), ve bununla birlikte verir 0. Zaman n>=0, ~n>>64değerlendirir için-1 ve yapmanın bir &-1etkisi yoktur.

Python 2 , 36 bayt

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

Çevrimiçi deneyin!

Aritmetik alternatif.

Java 8, 32 26 bayt.

Long::numberOfLeadingZeros

FTW inşa eder.

Kevin Cruijssen sayesinde -6 bayt

Çevrimiçi deneyin!

C (gcc) , 14 bayt

__builtin_clzl

Tio'da iyi çalışıyor

C (gcc) , 35 29 bayt

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

Çevrimiçi deneyin!

6 bayt için Dennis'den

C (gcc) derleyici bayrakları, 29 byte David Foerster

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

Çevrimiçi deneyin!

Perl 6 , 35 28 26 bayt

Nwellnhof sayesinde -2 bayt

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

Çevrimiçi deneyin!

Bir sayı alan ve bir sayı döndüren anonim kod bloğu. Bu, sayıyı bir ikili dizeye dönüştürür ve baştaki sıfırları sayar. Negatif sayılar için çalışır çünkü ilk karakter -örn.-00000101 , bu nedenle önde gelen sıfır yoktur.

Açıklama:

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

Girişi BigInt değişmezi olarak alır.

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

Çevrimiçi deneyin!

$0$

Python 3 , 34 bayt

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

Çevrimiçi deneyin!

J , 18 bayt

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

Çevrimiçi deneyin!

J , 19 bayt

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

Çevrimiçi deneyin!

Açıklama:

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

Jo King sayesinde -2 bayt

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

Çevrimiçi deneyin!

Ruby , 22 bayt

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

Çevrimiçi deneyin!

05AB1E , 10 9 bayt

·bg65αsd*

G / Ç her ikisi de tamsayıdır

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

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

^{Bir hata tespit ettiğiniz için teşekkürler xnor !}

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

Oldukça fazla bellek ayırabilir, çevrimiçi deneyin!

Belki daha küçük bir sabitle test etmek istersiniz: 8 bit deneyin!

açıklama

mapM(pure[0,1])[1..64]Girdiyi ikiliye dönüştürmek için kullanmak yerine, mapM(pure[1,0])[1..64]aslında ters çevrilmiş dizeleri oluşturan$\lbrace0,1\rbrace^{64}$sözlükbilimsel sırayla. Böylece,$1$kullanarak s-öneki sum.fst.span(>0).

Powershell, 51 bayt

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

Test komut dosyası:

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

Çıktı:

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 bayt

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

Gibi giriş long(64-bit tamsayı) olarak çıkış int(32 bit tamsayı).

Bağlantı noktası @ l4m2 'nin C (gcc) cevabı .

Çevrimiçi deneyin.

Açıklama:

 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: @lukeg Java 8 yanıt görüntülendiği gibi yerleşik kullanarak 26 bayt olabilir .Long::numberOfLeadingZeros

APL + WIN, 34 bayt

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

Açıklama:

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 # Etkileşimli Derleyici) , 42 bayt

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

Çevrimiçi deneyin!

C # (Visual C # Etkileşimli Derleyici) , 31 bayt

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

Daha kısa, @ l4m2'nin C (gcc) cevabına dayanarak . Böyle işlevler beyan edebileceğinizi hiç bilmiyordum, teşekkürler @Dana!

Çevrimiçi deneyin!

Jöle ,  10  9 bayt

-1 Outgolfer Erik'in düzgün bir hilesi sayesinde (negatif olmayan şimdi basitçe AƑ)

ḤBL65_×AƑ

Bir tamsayı veren bir tamsayıyı (aralık dahilinde) kabul eden monadik bir Bağlantı.

Çevrimiçi deneyin! Veya test takımına bakın .

10 kişi ḤBL65_ɓ>-×

İşte "BOSS" dediği için sevdiğim 10 baytlık bir çözüm daha ...

BoṠS»-~%65

Test paketi burada

... BoṠS63r0¤i, BoṠS63ŻṚ¤iveya BoṠS64ḶṚ¤içalışır.

Başka bir 10 byter (Dennis'den) æ»64ḶṚ¤Äċ0(tekrar æ»63r0¤Äċ0ve æ»63ŻṚ¤Äċ0aynı zamanda çalışacak)

Perl 5 , 37 bayt

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

Çevrimiçi deneyin!

Veya "dizgileştirmeye" izin verilmiyorsa bu 46 bayt: sub z

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

Swift (64 bit platformda), 41 bayt

Adlı bir kapatma bildirir f eden ve döndüren birInt . Bu çözüm sadece doğru 64 bit platformları, işler Intolduğu typealiasiçin ed Int64. (32 bit bir platformda, Int642 bayt ekleyerek kapağın parametre türü için açıkça kullanılabilir.)

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

Swift'te, temel tamsayı türü bile standart kütüphanede bildirilen sıradan bir nesnedir. Bu, Intaşağıdaki gibi yöntem ve özelliklere sahip olabileceği anlamına gelirleadingZeroBitCount (standart kütüphanenin FixedWidthIntegerprotokolüne uygun tüm tiplerde gerekli olan) .

Haskell , 24 bayt

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

Çevrimiçi deneyin!

Bu temelde Kevin Cruijssen'in Java çözümü ile aynı, ancak bağımsız olarak buldum.

Bağımsız değişken, Int64 bit derleme için türe sahip olmalıdır veyaInt64 herhangi bir şey için .

açıklama

Argüman negatifse, sonuç biz sola kaydırmaya, Aksi hemen 0'dır olanlarla doldurarak negatif bir sayı ulaşana kadar. Bu dolgu 0 için özel bir durumdan kaçınmamızı sağlar.

Sadece referans olarak, işte bariz / verimli yol:

34 bayt

import Data.Bits
countLeadingZeros

Temiz , 103 bayt

Ceilingcat'in cevabı ile aynı "yerleşik" kullanır .

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

Çevrimiçi deneyin!

Temiz , 58 bayt

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

Çevrimiçi deneyin!

Stax , 10 bayt

în»╧3(∞┼⌠g

Çalıştır ve hata ayıkla

Kevin'in 05AB1E çözümünün bir limanı.

Perl 5 -p , 42 bayt

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

Çevrimiçi deneyin!

Bit dizisi tabanlı bir çözümden daha uzun, ama iyi bir matematik tabanlı çözüm.

APL (NARS), 15 karakter, 30 bayt

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

nasıl kullanılacağını görmek için birkaç sayıyı test edin:

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

Pas, 18 bayt

i64::leading_zeros

Çevrimiçi deneyin!

K (ngn / k) , 6 bayt

64-#2\

Çevrimiçi deneyin!

2\ argümanı ikili olarak kodlamak

# uzunluk

64- 64'ten çıkart

PHP, 50 46 bayt

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

Pipo ile çalıştırın -Rveya çevrimiçi deneyin ,

<?=$argn<0?0:0|64-log($argn+1,2);yuvarlama sorunları var; bu yüzden çok yol aldım.

Wolfram Dili (Mathematica) , 41 bayt

Pozitif sayılar için formül sadece 63-Floor@Log2@#& . Özel sıfır ve negatif giriş durumları için değiştirme kuralları kullanılır.

Girişin 64 bit işaretli bir tam sayı olması gerekmez. Bu, girdiyi tamsayı haline getirmek için etkili bir şekilde katlanır. 64 bit tam sayı için normal sınırların dışında bir sayı girerseniz, bu tamsayıyı saklamak için daha fazla bitin gerekli olacağını belirten bir negatif sayı döndürür.

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

Çevrimiçi deneyin!

@ LegionMammal978'in çözümü 28 baytta oldukça kısadır. Giriş bir tamsayı olmalıdır. Belgelere göre: " BitLength[n]etkin bir şekilde verimli bir sürümüdür Floor[Log[2,n]]+1." Sıfır raporlama durumunu otomatik olarak doğru 0yerine ele alır-∞ .

Wolfram Dili (Mathematica) , 28 bayt

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

Çevrimiçi deneyin!

bitNumber - math.ceil (math.log (sayı) / math.log (2))

64 bit NUMBER: 9223372036854775807 math.ceil (math.log (9223372036854775807) / math.log (2)) ANS: 63