Orang-orang Yunani kuno memiliki hal-hal ini disebut angka genap tunggal dan ganda. Contoh angka genap tunggal adalah 14. Angka ini dapat dibagi 2 sekali, dan pada saat itu menjadi angka ganjil (7), setelah itu tidak dapat dibagi 2 lagi. Angka genap dua kali lipat adalah 20. Ini dapat dibagi 2 dua kali, dan kemudian menjadi 5.

Tugas Anda adalah menulis fungsi atau program yang menggunakan bilangan bulat sebagai input, dan menampilkan berapa kali bilangan itu dapat dibagi 2 sebagai bilangan bulat, sesedikit mungkin dalam byte. Masukan akan berupa bilangan nol bukan (nilai positif atau negatif, dalam batas bahasa Anda).

Kasus uji:

14 -> 1

20 -> 2

94208 -> 12

7 -> 0

-4 -> 2

Jawaban dengan byte terkecil menang.

Kiat: Cobalah mengonversi nomor menjadi basis 2. Lihat apa yang memberitahu Anda.

Jelly , 4 byte

Æfċ2

Dalam versi terbaru Jelly, ÆEḢ(3 byte) berfungsi.

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

Coba di sini .

kode mesin x86_64, 4 byte

Instruksi BSF (bit scan forward) melakukan hal ini !

0x0f    0xbc    0xc7    0xc3

Dalam perakitan gcc-style, ini adalah:

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

Input diberikan dalam register EDI dan dikembalikan dalam register EAX sesuai dengan konvensi panggilan c 64-bit standar .

Karena pengkodean biner komplemen dua, ini berfungsi untuk -ve serta + ve nomor.

Juga, terlepas dari dokumentasi yang mengatakan "Jika konten dari operan sumber adalah 0, konten dari operan tujuan tidak ditentukan." , Saya temukan di VM Ubuntu saya bahwa output f(0)adalah 0.

Instruksi:

• Simpan di atas sebagai evenness.sdan kumpulkangcc -c evenness.s -o evenness.o
• Simpan driver tes berikut sebagai evenness-main.cdan kompilasi dengan 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;
}

Kemudian:

• Tautan: gcc evenness-main.o evenness.o -o evenness
• Lari: ./evenness

@FarazMasroor meminta detail lebih lanjut tentang bagaimana jawaban ini diturunkan.

Saya lebih terbiasa dengan c daripada seluk-beluk perakitan x86, jadi biasanya saya menggunakan kompiler untuk menghasilkan kode perakitan untuk saya. Saya tahu dari pengalaman bahwa ekstensi gcc seperti __builtin_ffs(), __builtin_ctz()dan__builtin_popcount() biasanya mengkompilasi dan merakit ke 1 atau 2 instruksi pada x86. Jadi saya mulai dengan fungsi c seperti:

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

Alih-alih menggunakan kompilasi gcc biasa semua jalan ke kode objek, Anda dapat menggunakan -Sopsi untuk mengkompilasi hanya untuk perakitan - gcc -S -c evenness.c. Ini memberikan file perakitan evenness.sseperti ini:

    .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

Banyak dari ini bisa dimainkan. Secara khusus kita tahu bahwa konvensi pemanggilan c untuk fungsi dengan tanda tangan bagus dan sederhana - param input dilewatkan dalam register dan nilai balik dikembalikan dalam register. Jadi kita dapat mengambil sebagian besar instruksi - banyak dari mereka yang peduli dengan menyimpan register dan mengatur bingkai stack baru. Kami tidak menggunakan tumpukan di sini dan hanya menggunakan register, jadi tidak perlu khawatir tentang register lain. Ini meninggalkan kode perakitan "golf":int f(int n);EDIEAXEAX

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

Catatan seperti yang ditunjukkan oleh zwol, Anda juga dapat menggunakan kompilasi yang dioptimalkan untuk mencapai hasil yang serupa. Khususnya -Osmenghasilkan instruksi di atas persis (dengan beberapa arahan assembler tambahan yang tidak menghasilkan kode objek tambahan.)

Ini sekarang dirakit dengan gcc -c evenness.s -o evenness.o, yang kemudian dapat dihubungkan ke program driver tes seperti dijelaskan di atas.

Ada beberapa cara untuk menentukan kode mesin yang sesuai dengan rakitan ini. Favorit saya adalah menggunakan disassperintah pembongkaran gdb :

$ 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) 

Jadi kita bisa melihat bahwa kode mesin untuk bsfinstruksi 0f bc c7dan untuk retyaitu c3.

Python, 25 byte

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

n & -n nol apa pun kecuali bit paling tidak signifikan, misalnya ini:

100010101010100000101010000
            v
000000000000000000000010000

Kami tertarik pada jumlah trailing nol, jadi kami mengonversinya menjadi string biner bin, yang untuk nomor di atas akan menjadi "0b10000". Karena kita tidak peduli dengan 0b, atau 1, kita mengurangi 3 dari panjang string itu.

Pyth, 6 byte

/P.aQ2

Coba di sini .

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

JavaScript (ES6), 18 byte

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

4 byte lebih pendek dari 31-Math.clz32. Hah.

JavaScript ES6, 22 19 byte

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

Sepertinya rekursi adalah rute terpendek.

Pyth, 8 byte

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

Sebagai contoh, representasi biner 94208adalah:

10111000000000000

Setelah memisahkan pada 1s dan mengambil elemen terakhir dari array yang dihasilkan, ini menjadi:

000000000000

Itu 12 nol, jadi "12-ly even."

Ini bekerja karena x / 2pada dasarnya x >> 1—yaitu, hak bithift dari 1. Oleh karena itu, angka dapat dibagi 2 hanya ketika LSB 0(seperti halnya angka desimal dapat dibagi 10 ketika digit terakhirnya 0).

05AB1E , 4 5 byte

Sekarang mendukung angka negatif. Kode:

Äb1¡g

Cobalah online!

Penjelasan:

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

Menggunakan pengodean CP-1252.

Pyth, 6 byte

x_.BQ1

Pada dasarnya adil

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

MATL , 5 byte

Yf2=s

Ini berfungsi untuk semua bilangan bulat.

Cobalah online!

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) byte

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

(Tidak menguji untuk argumen nol karena argumen bukan nol ditentukan.)

Pembaruan (sebagai tanggapan terhadap komentar) : Jika kami mengizinkan deklarasi fungsi gaya K&R, maka kami dapat memiliki versi 28-byte:

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

Dalam hal ini, kami bergantung pada fakta bahwa kompiler default keduanya ndan tipe kembali fke int. Formulir ini menghasilkan peringatan dengan C99 dan tidak mengkompilasi sebagai kode C ++ yang valid.

Java 7, 39 atau mungkin 44 byte

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;}

Rekursi Yay! Saya harus menggunakan !=bukannya perbandingan yang lebih pendek sehingga tidak akan meluap pada input negatif, tetapi selain itu cukup mudah. Jika aneh, kirim nol. Jika genap, tambahkan satu dan lakukan lagi.

Ada dua versi karena sekarang output untuk nol tidak diketahui. Yang pertama akan berulang sampai stack meluap, dan tidak menghasilkan apa-apa, karena 0 bahkan genap. Yang kedua mengeluarkan 0 yang bagus, aman, tapi mungkin-tidak-matematis-ketat untuk output.

JavaScript (ES6), 20 byte 19 byte.

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

Ini adalah port solusi Haskell oleh @nimi ke JavaScript. Ia menggunakan properti "korsleting" &&yang mengembalikan sisi kirinya jika itu falsey (yang dalam hal ini -0) atau mengembalikan sisi kanannya. odd x = 0Oleh karena itu untuk menerapkan kami membuat sisi kiri 1 - (x % 2)yang gelembung 0melalui &&, kalau tidak kita kambuh 1 + f(x / 2).

Cukur 1 - (x % 2)as (~x) % 2adalah karena @Neil di bawah, dan memiliki properti aneh yang menyebabkan fungsi di atas untuk memancarkan -0angka ganjil kecil. Nilai ini adalah kekhasan keputusan JS bahwa integer adalah ganda IEEE754; sistem ini memiliki fungsi yang terpisah +0dan -0khusus dalam JavaScript untuk digunakan ===satu sama lain. The ~Operator menghitung 32-bit-menandatangani-bulat bitwise inversi untuk nomor, yang untuk angka ganjil kecil akan menjadi nomor bahkan negatif. (Angka positif Math.pow(2, 31) + 1misalnya menghasilkan 0daripada -0.) Pembatasan aneh untuk bilangan bulat 32-bit tidak memiliki efek lain; khususnya itu tidak memengaruhi kebenaran.

Perl 6, 23 18 byte

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

pemakaian

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

Ruby 24 byte

Pengiriman golf kode pertama saya (ya!)

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

Bagaimana saya sampai di sini :

Pertama saya ingin mendapatkan kode yang benar-benar memenuhi spesifikasi untuk mengatasi masalah saya, jadi saya membangun metode ini tanpa memperhatikan jumlah byte:

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

dengan pengetahuan ini saya de-recursed fungsi menjadi loop sementara dan ditambahkan $*(ARGV) sebagai input dan saya sebagai hitungan berapa kali jumlah telah dibelah dua sebelum menjadi aneh.

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

Saya cukup bangga dengan ini dan hampir menyerahkannya sebelum saya tersadar bahwa semua pembagian oleh dua ini terdengar agak biner bagi saya, sebagai seorang insinyur perangkat lunak, tetapi bukan seorang ilmuwan komputer, ini bukan hal pertama yang muncul dalam pikiran.

Jadi saya mengumpulkan beberapa hasil tentang seperti apa nilai input dalam biner:

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

Saya perhatikan bahwa hasilnya adalah jumlah posisi di sebelah kiri yang harus kami lalui sebelum jumlahnya menjadi ganjil.

Melakukan beberapa manipulasi string sederhana saya membagi string pada kemunculan terakhir 1 dan menghitung panjang 0s yang tersisa:

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

menggunakan ("%b" % x)pemformatan untuk mengubah angka menjadi biner, dan String # slice untuk mengiris string saya.

Saya telah belajar beberapa hal tentang ruby ​​dalam pencarian ini dan berharap untuk lebih banyak golf segera!

J, 6 byte

1&q:@|

Penjelasan:

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

C, 37 byte

f(int x){return x?x&1?0:1+f(x/2):0;} Periksa bit terakhir secara rekursif hingga bukan 0.

Haskell, 28 byte

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

Contoh penggunaan: f 94208-> 12.

Jika nomornya ganjil, hasilnya adalah 0, selain itu 1ditambah panggilan rekursif dengan setengah nomor.

Befunge, 20

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

Eksekusi kode terus bergerak ke kanan dan membungkus ke karakter kedua dari baris pertama (terima kasih untuk trailing #) sampai 2%output 1, yang menyebabkan _untuk beralih ke kiri, lalu |ke atas, yang membungkus ke pada <pada baris kedua, yang keluar dan keluar. Kami menambah elemen tumpukan kedua ke atas setiap kali melalui loop, kemudian membaginya dengan 2.

Retina ,29 17

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

Cobalah online!

2 byte disimpan berkat Martin!

Mengambil input yang tidak disadari. Ini berulang kali cocok dengan jumlah terbesar yang 1bisa dimiliki sehingga jumlah yang 1cocok persis dengan jumlah sisanya 1. Setiap kali ia melakukan ini, ia menambahkan ;ke string. Pada akhirnya, kami menghitung jumlah ;s dalam string.

Jika Anda ingin input desimal, tambahkan:

\d+
$0$*1

ke awal program.

Jolf, 6 byte

Coba di sini!

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

Agak sederhana ... Kudos to ETHProduk untuk mengusir Jolf dengan versi yang benar-benar berfungsi!

PARI / GP, 17 byte

n->valuation(n,2)

6502 bahasa mesin, 7 byte

Untuk menemukan nilai tempat 1 bit paling signifikan dari nilai bukan nol di akumulator, biarkan hasilnya di register X:

A2 FF E8 4A 90 FC 60

Untuk menjalankan ini pada 6502 simulator di e-tradition.net , awali dengan A9diikuti oleh integer 8-bit.

Ini membongkar sebagai berikut:

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

Ini setara dengan C berikut, kecuali bahwa C intharus setidaknya 16-bit:

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;
}

Hal yang sama bekerja pada 65816, dengan asumsi MX = 01 (akumulator 16-bit, indeks 8-bit), dan setara dengan potongan C di atas.

Brachylog , 27 15 byte

$pA:2xlL,Al-L=.

Penjelasan

$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 byte

rizmf2e=

Baca integer, nilai absolut, faktorisasi prima, hitung berpasangan.

JavaScript ES6, 36 38 byte

Golf dua byte berkat produk @ETH

Jawabannya cukup membosankan, tetapi berhasil. Mungkin sebenarnya terlalu mirip dengan jawaban lain, jika dia menambahkan perubahan yang disarankan maka saya akan menghapus milik saya.

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

Untuk menjalankan, tetapkan ke variabel ( a=>{for...) karena ini merupakan fungsi anonim, lalu panggil dengan a(100).

ES6, 22 byte

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

Mengembalikan -1 jika Anda lulus 0.

DUP , 20 byte

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

Try it here!

Dikonversi menjadi rekursi, output sekarang menjadi nomor teratas di stack. Pemakaian:

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

Penjelasan

[                ]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 byte

¢w b1

Uji secara online!

Versi sebelumnya seharusnya lima byte, tetapi yang ini benar-benar berfungsi.

Bagaimana itu bekerja

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

2 byte off terima kasih @JohnWHSmith . 2 byte off terima kasih @luserdroog .

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

Tes langsung pada ideone .