Eski Yunanlılar bunlara tek ve çift kat sayıları bile deniyordu. Tek başına bir sayının örneği 14'tür. Bir kez 2'ye bölünebilir ve bu noktada tek bir sayı (7) olur, bundan sonra artık 2 ile bölünemez. Şüpheli bir sayı bile 20'dir. İki kere 2'ye bölünebilir ve ardından 5 olur.

Göreviniz, bir tam sayıyı girdi olarak alan ve mümkün olduğu kadar az bayt cinsinden bir tam sayı olarak 2'ye bölünebilme sayısını veren bir işlev veya program yazmaktır. Girdi sıfır olmayan bir tamsayı olacaktır (dilinizin sınırları dahilindeki herhangi bir pozitif veya negatif değer).

Test durumları:

14 -> 1

20 -> 2

94208 -> 12

7 -> 0

-4 -> 2

En az bayt olan cevap kazanır.

İpucu: Numarayı baz 2'ye dönüştürmeyi deneyin. Size ne söylediğini görün.

Jöle , 4 bayt

Æfċ2

Jelly'in son sürümünde, ÆEḢ(3 byte) çalışır.

Æf      Calculate the prime factorization. On negative input, -1 appended to the end.
  ċ2    Count the 2s.

Burada dene .

x86_64 makine kodu, 4 bayt

BSF (ileri taramayı ileri tara) komutu tam olarak bunu yapar !

0x0f    0xbc    0xc7    0xc3

Gcc tarzı derlemede, bu:

    .globl  f
f:
    bsfl    %edi, %eax
    ret

Giriş, EDI kaydında verilir ve EAX kaydında standart 64 bit c çağrı kurallarına göre geri gönderilir.

İkisinin tamamlayıcı ikili kodlaması nedeniyle, + ve sayıları olduğu gibi -ve için de çalışıyor.

Ayrıca, "Kaynak işlenenin içeriği 0 ise, hedef işlenenin içeriği tanımsızdır" ifadesine rağmen. , Ubuntu VM'mde çıktısının f(0)0 olduğunu görüyorum .

Talimatlar:

• Yukarıdakileri kaydedin evenness.sve ile birleştiringcc -c evenness.s -o evenness.o
• Aşağıdaki test sürücüsünü aşağıdaki gibi kaydedin evenness-main.cve derleyin gcc -c evenness-main.c -o evenness-main.o:

#include <stdio.h>

extern int f(int n);

int main (int argc, char **argv) {
    int i;

    int testcases[] = { 14, 20, 94208, 7, 0, -4 };

    for (i = 0; i < sizeof(testcases) / sizeof(testcases[0]); i++) {
        printf("%d, %d\n", testcases[i], f(testcases[i]));
    }

    return 0;
}

Sonra:

• Bağlantı: gcc evenness-main.o evenness.o -o evenness
• Çalıştırmak: ./evenness

@FarazMasroor, bu cevabın nasıl türetildiği hakkında daha fazla bilgi istedi.

C ile x86 derlemesinin karmaşıklıklarından daha aşinayım , bu yüzden tipik olarak benim için derleme kodu üretmek için bir derleyici kullanıyorum. Ben deneyimlerinden biliyorum gcc gibi uzantıları __builtin_ffs(), __builtin_ctz()ve__builtin_popcount() tipik derlemek ve x86 üzerinde 1 veya 2 talimatlara birleştirin. Böylece şöyle bir c işleviyle başladım :

int f(int n) {
    return __builtin_ctz(n);
}

Normal gcc derlemesini nesne koduna tamamen kullanmak yerine, derleme - -Sseçeneğini sadece derleme seçeneğini kullanabilirsiniz gcc -S -c evenness.c. Bu, böyle bir derleme dosyası verir evenness.s:

    .file   "evenness.c"
    .text
    .globl  f
    .type   f, @function
f:
.LFB0:
    .cfi_startproc
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register 6
    movl    %edi, -4(%rbp)
    movl    -4(%rbp), %eax
    rep bsfl    %eax, %eax
    popq    %rbp
    .cfi_def_cfa 7, 8
    ret
    .cfi_endproc
.LFE0:
    .size   f, .-f
    .ident  "GCC: (Ubuntu 4.8.4-2ubuntu1~14.04.1) 4.8.4"
    .section    .note.GNU-stack,"",@progbits

Bunun bir çoğu dışarı atılabilir. Özellikle , imzalı işlevler için c çağrı kuralınınint f(int n); hoş ve basit olduğunu biliyoruz - giriş paramı EDIkayıt defterine geçirilir ve dönüş değeri EAXkayıt defterine döndürülür . Bu yüzden talimatların çoğunu çıkarabiliriz - birçoğu kayıtların kaydedilmesi ve yeni bir yığın çerçeve oluşturulması ile ilgilidir. Yığını burada kullanmıyoruz ve sadece EAXkayıt defterini kullanıyoruz, bu nedenle diğer kayıtlar için endişelenmenize gerek yok. Bu "golf" derleme kodunu bırakır:

    .globl  f
f:
    bsfl    %edi, %eax
    ret

@Zwol'un işaret ettiği gibi, benzer bir sonuç elde etmek için optimize edilmiş derlemeyi de kullanabilirsiniz. Özellikle -Os, yukarıdaki talimatları tam olarak üretir (fazladan nesne kodu üretmeyen birkaç ek montajcı direktifiyle).

Bu, şimdi gcc -c evenness.s -o evenness.oyukarıda açıklandığı gibi bir test sürüşü programına bağlanan ile birleştirilir.

Bu düzene karşılık gelen makine kodunu belirlemenin birkaç yolu vardır. En sevdiğim şey gdb disassdisassembly komutunu kullanmak :

$ gdb ./evenness
GNU gdb (Ubuntu 7.7.1-0ubuntu5~14.04.2) 7.7.1
...
Reading symbols from ./evenness...(no debugging symbols found)...done.
(gdb) disass /r f
Dump of assembler code for function f:
   0x00000000004005ae <+0>: 0f bc c7    bsf    %edi,%eax
   0x00000000004005b1 <+3>: c3  retq   
   0x00000000004005b2 <+4>: 66 2e 0f 1f 84 00 00 00 00 00   nopw   %cs:0x0(%rax,%rax,1)
   0x00000000004005bc <+14>:    0f 1f 40 00 nopl   0x0(%rax)
End of assembler dump.
(gdb) 

Böylece bsfkomutun makine kodunun 0f bc c7ve için retolduğunu görebiliriz c3.

Python, 25 bayt

lambda n:len(bin(n&-n))-3

n & -n en az anlamlı bit dışında bir şeyi sıfırlar, örneğin bu:

100010101010100000101010000
            v
000000000000000000000010000

İzleyen sıfırların sayısıyla ilgileniyoruz, bu yüzden binyukarıdaki sayı için kullanılacak olan ikili dizgiye dönüştürüyoruz "0b10000". 0bNe de ne de umurumuzda olmadığından 1, bu dizelerin uzunluğundan 3 çıkardık.

Pyth, 6 bayt

/P.aQ2

Burada dene .

 P.aQ         In the prime factorization of the absolute value of the input
/    2        count the number of 2s.

JavaScript (ES6), 18 bayt

n=>Math.log2(n&-n)

4 bayttan daha kısa 31-Math.clz32. Hah.

JavaScript ES6, 22 19 bayt

f=x=>x%2?0:f(x/2)+1

Özyineleme en kısa yol gibi görünüyor.

Pyth, 8 bayt

lec.BQ\1

     Q    autoinitialized to eval(input())
   .B     convert to binary string
  c   \1  split on "1", returning an array of runs of 0s
 e        get the last run of 0s, or empty string if number ends with 1
l         take the length

Örneğin, ikili gösterimi 94208:

10111000000000000

S'ye bölündükten 1ve elde edilen dizinin son elemanını aldıktan sonra, bu olur:

000000000000

Bu 12 sıfır, yani "12-ly bile".

Bu işe yarıyor, çünkü x / 2aslında x >> 1- öyle, bir parça değiştirme hakkı 1. Bu nedenle, bir sayı yalnızca LSB olduğunda 2 ile bölünebilir 0(tıpkı bir ondalık sayının, son basamağı olduğunda 10 ile nasıl bölündüğü gibi 0).

05AB1E , 4 5 bayt

Şimdi negatif sayıları destekliyor. Kod:

Äb1¡g

Çevrimiçi deneyin!

Açıklama:

Ä      # Abs(input)
 b     # Convert the number to binary
  1¡   # Split on 1's
    g  # Take the length of the last element

CP-1252 kodlamasını kullanır.

Pyth, 6 bayt

x_.BQ1

Temelde sadece

convert2BinString(evaluatedInput())[::-1].index("1")

MATL , 5 bayt

Yf2=s

Bu tüm tamsayılar için çalışır.

Çevrimiçi deneyin!

Yf      % implicit input. Compute (repeated) prime factors. For negative input
        % it computes the prime factors of the absolute value, except that for
        % -1 it produces an empty array instead of a single 1
2=s     % count occurrences of "2" in the array of prime factors

C, 36 (28) bayt

int f(int n){return n&1?0:f(n/2)+1;}

(Sıfır olmayan bir argüman için sıfır olmayan bir argüman olarak test edilmedi.)

Güncelle (Yoruma cevap olarak) : K&R tarzı işlev bildirimlerine izin verirsek, 28 baytlık bir sürümümüz olabilir:

f(n){return n&1?0:f(n/2)+1;}

Bu durumda, biz aslında itimat derleyici varsayılan hem nve dönüş türü fiçin int. Bu form C99 ile olsa bir uyarı oluşturur ve geçerli C ++ kodu olarak derlenmez.

Java 7, 39 veya belki 44 bayt

int s(int a){return a%2!=0?0:s(a/2)+1;}

int s(int a){return a%2!=0|a==0?0:s(a/2)+1;}

Yay özyinelemede! Daha !=kısa bir karşılaştırma yerine kullanmak zorunda kaldım, bu yüzden negatif girdiden taşmazdı, ama bunun dışında oldukça basit. Tuhafsa, sıfır gönder. Olsa bile, bir tane ekleyin ve tekrar yapın.

İki versiyon var çünkü şu an için sıfır çıkışı bilinmiyor. Birincisi yığın taşana kadar tekrar eder ve hiçbir şey çıkmaz, çünkü 0 sonsuzdur. İkincisi çıktı için güzel, güvenli, ancak büyük olasılıkla matematiksel olarak zor olmayan bir 0 veriyor.

JavaScript (ES6), 20 bayt 19 bayt.

f=x=>~x%2&&1+f(x/2)

Bu, JavaScript için @nimi tarafından Haskell çözümünün bir limanıdır. &&Falsey ise (bu durumda -0) sol tarafını döndüren ya da sağ tarafını döndüren "kısa devre" özelliklerini kullanır . Uygulamak için odd x = 0bu nedenle sol tarafını yapmak 1 - (x % 2)kabarcıklar 0sayesinde &&, aksi takdirde biz için Recurse, 1 + f(x / 2).

Tıraş 1 - (x % 2)olarak (~x) % 2aşağıda @Neil kaynaklanmaktadır ve yayması için yukarıdaki işlevini neden garip bir özelliği vardır -0, küçük tek sayı için. Bu değer, JS'nin tamsayıların IEEE754'ün iki katına çıktığı yönündeki kararının bir özelliğidir; Bu sistem ayrı +0ve birbirinden ayrı -0olmak ===için JavaScript'te özel olarak yazılmış . ~Operatör küçük tek sayı için negatif bir çift sayı olacak numarası, 32-bit imzalı tamsayı bit düzeyinde inversiyon hesaplar. ( Math.pow(2, 31) + 1Örneğin pozitif sayı 0yerine üretmektedir -0.) 32 bit işaretli tam sayılara olan garip kısıtlamanın başka hiçbir etkisi yoktur; özellikle de doğruluğu etkilemez.

Perl 6, 23 18 bayt

{+($_,*/2...^*%2)}

kullanım

> my &f = {+($_,*/2...^*%2)}
-> ;; $_? is raw { #`(Block|117104200) ... }
> f(14)
1
> f(20)
2
> f(94208)
12
> f(7)
0
> f(-4)
2

Yakut 24 bayt

İlk kod golf gönderim (yey!)

("%b"%$*[0])[/0*$/].size

Buraya nasıl geldim :

Öncelikle problemi gidermek için şartı yerine getiren kodu almak istedim, bu yüzden byte sayısı gözetmeksizin metodu kurdum:

def how_even(x, times=1)
  half = x / 2
  if half.even?
    how_even(half, times+1)
  else
    times
  end
end

bu bilgiyi bir süre döngüsüne geri $*aldim ve girdi olarak (ARGV) girdi ve i tuhaflaşmadan önce sayının kaç kez yarıya düştüğünü saydım.

x=$*[0];i=1;while(x=x/2)%2<1;i+=1;end;i

Bununla gurur duyuyordum ve neredeyse bana sundu ki, bu iki bölücü bölünmenin bana biraz ikili geldiğini, yazılım mühendisi olarak geldiğini ama o kadar da bir bilgisayar bilimcisi olmadığını, bunun akla ilk gelen şey olmadığını söyledi.

Bu yüzden giriş değerlerinin ikili olarak nasıl göründüğü hakkında bazı sonuçlar topladım:

input      in binary      result
---------------------------------
   14               1110   1
   20              10100   2
94208  10111000000000000  12

Sonucun, sayı tuhaf hale gelmeden önce geçmemiz gereken sola konumların sayısı olduğunu fark ettim.

Bazı basit string manipülasyonları yaparak, string'i 1'in son oluşumunda böldüm ve kalan 0 saniyenin uzunluğunu saydım:

("%b"%$*[0])[/0*$/].size

("%b" % x)bir sayıyı ikiliye çevirmek için biçimlendirme kullanmak ve dizeimi kesmek için String # dilim .

Bu arayışla yakut hakkında birkaç şey öğrendim ve yakında daha fazla golf oynamayı dört gözle bekliyorum!

J, 6 bayt

1&q:@|

Açıklama:

     |    absolute value
1&q:      exponent of 2 in the prime factorization

C, 37 bayt

f(int x){return x?x&1?0:1+f(x/2):0;} 0 olmayana kadar son biti tekrar tekrar kontrol edin.

Haskell, 28 bayt

f x|odd x=0|1<2=1+f(div x 2)

Kullanım örneği: f 94208-> 12.

Numara tuhafsa, sonuç 0başka 1bir rakam artı yarı sayıyla tekrarlayan bir çağrı olur.

Befunge, 20

&:2%#|_\1+\2/#
   @.<

Kod yürütme sağa doğru ilerlemeye devam eder ve ilk satırın ikinci karakterine sarılır (izler sayesinde #) , 2%çıktılar çıkana kadar sola, sonra sola, sonra da ikinci sıraya sarılır. hangi çıkışlar ve çıkışlar. Yığın ikinci-üst elemanını ilmek boyunca her seferinde arttırır, sonra üstünü 2'ye böleriz.1_|<

retina ,29 17

+`\b(1+)\1$
;$1
;

Çevrimiçi deneyin!

Martin sayesinde 2 bayt kurtarıldı!

Unary girdi alır. Bu, art arda en fazla 1s miktarıyla eşleşir, öyle ki 1s sayısı, sayının s kalanıyla tam olarak eşleşir 1. Bunu her yapışında ;dizeye a hazırlar . Sonunda dizgideki ;s sayısını sayarız .

Ondalık giriş istiyorsanız, şunu ekleyin:

\d+
$0$*1

programın başlangıcına.

Jolf, 6 bayt

Burada dene!

Zlm)j2
Zl   2  count the number occurrences of 2 in
  m)j   the prime factorization of j (input)

Oldukça basit ... ETHProductions'a, gerçekten de çalışması gereken Jolf'u atlattığı için teşekkür ederim!

PARI / GP, 17 bayt

n->valuation(n,2)

6502 makine dili, 7 bayt

Akümülatörde sıfır olmayan değerin en az 1 bitinin yer değerini bulmak, sonucu X yazmacında bırakmak:

A2 FF E8 4A 90 FC 60

Bunu e-tradition.net adresindeki 6502 simülatöründe çalıştırmak için, A9onu 8 bitlik bir tamsayı ile öneki yapın .

Bu, aşağıdakileri parçalara ayırır:

count_trailing_zeroes:
    ldx #$FF
loop:
    inx
    lsr a     ; set carry to 0 iff A divisible by 2, then divide by 2 rounding down
    bcc loop  ; keep looping if A was divisible by 2
    rts       ; return with result in X

Bu, C'nin inten az 16 bit olması gerekmesi dışında, aşağıdaki C'ye eşdeğerdir :

unsigned int count_trailing_zeroes(int signed_a) {
    unsigned int carry;
    unsigned int a = signed_a;  // cast to unsigned makes shift well-defined
    unsigned int x = UINT_MAX;
    do {
        x += 1;
        carry = a & 1;
        a >>= 1;
    } while (carry == 0);
    return x;
}

Aynısı, MX = 01 (16 bitlik akümülatör, 8 bitlik indeks) olduğunu varsayarak 65816'da çalışır ve yukarıdaki C parçacığına eşittir.

Brachylog , 27 15 bayt

$pA:2xlL,Al-L=.

açıklama

$pA             § Unify A with the list of prime factors of the input
   :2x          § Remove all occurences of 2 in A
      lL,       § L is the length of A minus all the 2s
         Al-L=. § Unify the output with the length of A minus L

CJam, 8 bayt

rizmf2e=

Tamsayıyı oku, mutlak değer, asal çarpanlara ayırma, ikilik sayma.

JavaScript ES6, 36 38 bayt

@ETHproductions sayesinde iki byte golf oynadı

Oldukça sıkıcı cevap, ama işe yarıyor. Aslında başka bir cevaba çok benzeyebilir, önerilen değişiklikleri eklerse benimkini kaldıracağım.

b=>{for(c=0;b%2-1;c++)b/=2;alert(c)}

Çalıştırmak için, onu bir değişkene ( a=>{for...) isimsiz bir işlev olarak atayın , sonra çağırınız a(100).

ES6, 22 bayt

n=>31-Math.clz32(n&-n)

0 değerini geçerseniz -1 döndürür.

DUP , 20 bayt

[$2/%0=[2/f;!1+.][0]?]f:

Try it here!

Özyinelemeye dönüştürülen çıktı, şimdi yığındaki en üst sayıdır. Kullanımı:

94208[2/\0=[f;!1+][0]?]f:f;!

açıklama

[                ]f: {save lambda to f}
 2/\0=               {top of stack /2, check if remainder is 0}
      [     ][ ]?    {conditional}
       f;!1+         {if so, then do f(top of stack)+1}
              0      {otherwise, push 0}

Japt, 9 5 bayt

¢w b1

Çevrimiçi test edin!

Önceki sürüm beş bayt olmalıydı, ancak bu gerçekten işe yarıyor.

Nasıl çalışır

       // Implicit: U = input integer
¢      // Take the binary representation of U.
w      // Reverse.
b1     // Find the first index of a "1" in this string.
       // Implicit output

Cı, 44 40 38 36 bayt

2 byte kapalı @ JohnWHSmith . 2 bayt kapalı teşekkürler @ lucerdroog .

a;f(n){for(;~n&1;n/=2)a++;return a;}

İdeone üzerinde canlı testi yapın .