Người Hy Lạp cổ đại có những thứ gọi là số đơn lẻ và gấp đôi. Một ví dụ về số chẵn đơn lẻ là 14. Nó có thể được chia cho 2 lần và tại thời điểm đó trở thành một số lẻ (7), sau đó nó không chia hết cho 2 nữa. Một số chẵn gấp đôi là 20. Nó có thể được chia cho 2 lần, và sau đó trở thành 5.

Nhiệm vụ của bạn là viết một hàm hoặc chương trình lấy một số nguyên làm đầu vào và xuất ra số lần nó chia hết cho 2 dưới dạng một số nguyên, càng ít byte càng tốt. Đầu vào sẽ là một số nguyên khác không (bất kỳ giá trị dương hoặc âm, trong giới hạn ngôn ngữ của bạn).

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

14 -> 1

20 -> 2

94208 -> 12

7 -> 0

-4 -> 2

Câu trả lời với ít byte nhất sẽ thắng.

Mẹo: Hãy thử chuyển đổi số thành cơ sở 2. Xem những gì cho bạn biết.

Thạch , 4 byte

Æfċ2

Trong phiên bản mới nhất của Jelly, ÆEḢ(3 byte) hoạt động.

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

Hãy thử nó ở đây .

mã máy x86_64, 4 byte

Hướng dẫn BSF (bit quét chuyển tiếp) thực hiện chính xác điều này !

0x0f    0xbc    0xc7    0xc3

Trong lắp ráp kiểu gcc, đây là:

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

Đầu vào được đưa ra trong thanh ghi EDI và được trả về trong thanh ghi EAX theo các quy ước gọi c 64 bit tiêu chuẩn .

Do mã hóa nhị phân bổ sung của hai, điều này hoạt động cho các số -ve cũng như + ve.

Ngoài ra, mặc dù tài liệu có nội dung "Nếu nội dung của toán hạng nguồn là 0, nội dung của toán hạng đích không được xác định." , Tôi thấy trên máy ảo Ubuntu của mình có đầu ra f(0)là 0.

Hướng dẫn:

• Lưu ở trên evenness.svà lắp ráp vớigcc -c evenness.s -o evenness.o
• Lưu trình điều khiển kiểm tra sau đây evenness-main.cvà biên dịch với 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;
}

Sau đó:

• Liên kết: gcc evenness-main.o evenness.o -o evenness
• Chạy: ./evenness

@FarazMasroor yêu cầu thêm chi tiết về cách trả lời này.

Tôi quen thuộc với c hơn là sự phức tạp của lắp ráp x86, vì vậy thông thường tôi sử dụng trình biên dịch để tạo mã lắp ráp cho tôi. Tôi biết từ kinh nghiệm rằng các phần mở rộng gcc như __builtin_ffs(), __builtin_ctz()và__builtin_popcount() thường biên dịch và lắp ráp thành 1 hoặc 2 hướng dẫn trên x86. Vì vậy, tôi bắt đầu với một chức năng c như:

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

Thay vì sử dụng trình biên dịch gcc thông thường tất cả các cách để mã đối tượng, bạn có thể sử dụng -Stùy chọn để biên dịch chỉ để lắp ráp - gcc -S -c evenness.c. Điều này cung cấp cho một tập tin lắp ráp evenness.snhư thế này:

    .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

Rất nhiều trong số này có thể được chơi golf. Đặc biệt chúng ta biết rằng quy ước gọi c cho các hàm có chữ ký là tốt và đơn giản - tham số đầu vào được truyền vào thanh ghi và giá trị trả về được trả về trong thanh ghi. Vì vậy, chúng tôi có thể loại bỏ hầu hết các hướng dẫn - rất nhiều trong số chúng liên quan đến việc lưu các thanh ghi và thiết lập một khung ngăn xếp mới. Chúng tôi không sử dụng ngăn xếp ở đây và chỉ sử dụng thanh ghi, vì vậy không cần phải lo lắng về các thanh ghi khác. Điều này để lại mã lắp ráp "đánh gôn":int f(int n);EDIEAXEAX

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

Lưu ý như @zwol chỉ ra, bạn cũng có thể sử dụng trình biên dịch được tối ưu hóa để đạt được kết quả tương tự. Cụ thể -Ostạo ra chính xác các hướng dẫn ở trên (với một vài chỉ thị trình biên dịch bổ sung không tạo ra bất kỳ mã đối tượng bổ sung nào.)

Điều này hiện được lắp ráp với gcc -c evenness.s -o evenness.o, sau đó có thể được liên kết thành một chương trình trình điều khiển thử nghiệm như được mô tả ở trên.

Có một số cách để xác định mã máy tương ứng với lắp ráp này. Yêu thích của tôi là sử dụng disasslệnh tháo gỡ 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) 

Vì vậy, chúng ta có thể thấy rằng mã máy cho bsfhướng dẫn là 0f bc c7và cho retlà c3.

Python, 25 byte

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

n & -n không có bất cứ thứ gì ngoại trừ bit có ý nghĩa nhỏ nhất, ví dụ:

100010101010100000101010000
            v
000000000000000000000010000

Chúng tôi quan tâm đến số lượng các số 0 ở cuối, vì vậy chúng tôi chuyển đổi nó thành một chuỗi nhị phân bằng cách sử dụng binsố này ở trên "0b10000". Vì chúng tôi không quan tâm đến 0b, cũng như 1, chúng tôi trừ 3 từ độ dài chuỗi đó.

Bình thường, 6 byte

/P.aQ2

Hãy thử nó ở đây .

 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 ngắn hơn 31-Math.clz32. Hah

JavaScript ES6, 22 19 byte

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

Hình như đệ quy là con đường ngắn nhất.

Bình thường, 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

Ví dụ: biểu diễn nhị phân 94208là:

10111000000000000

Sau khi tách trên 1s và lấy phần tử cuối cùng của mảng kết quả, điều này trở thành:

000000000000

Đó là 12 số không, vì vậy nó là "12-ly chẵn."

Điều này hoạt động bởi vì x / 2về cơ bản x >> 1làthththat, một quyền của bithift 1. Do đó, một số chia hết cho 2 chỉ khi LSB là 0(giống như cách một số thập phân chia hết cho 10 khi chữ số cuối của nó là 0).

05AB1E , 4 5 byte

Bây giờ hỗ trợ số âm. Mã số:

Äb1¡g

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

Giải trình:

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

Sử dụng mã hóa CP-1252.

Bình thường, 6 byte

x_.BQ1

Về cơ bản chỉ là

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

MATL , 5 byte

Yf2=s

Điều này làm việc cho tất cả các số nguyên.

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

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

(Không kiểm tra đối số bằng 0 vì đối số khác không được chỉ định.)

Cập nhật (để phản hồi nhận xét) : Nếu chúng tôi cho phép khai báo hàm kiểu K & R, thì chúng tôi có thể có phiên bản 28 byte:

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

Trong trường hợp này, chúng tôi dựa trên thực tế là giá trị mặc định trình biên dịch cả nvà kiểu trả về của fđể int. Biểu mẫu này tạo cảnh báo với C99 mặc dù và không biên dịch thành mã C ++ hợp lệ.

Java 7, 39 hoặc có thể 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;}

Yay đệ quy! Tôi đã phải sử dụng !=thay vì so sánh ngắn hơn để nó không tràn vào đầu vào tiêu cực, nhưng khác hơn là nó khá đơn giản. Nếu đó là số lẻ, hãy gửi số không. Nếu thậm chí, thêm một và làm lại.

Có hai phiên bản vì hiện tại đầu ra cho số 0 là không xác định. Cái đầu tiên sẽ lặp lại cho đến khi ngăn xếp tràn ra và không xuất ra gì, bởi vì 0 là vô hạn chẵn. Cái thứ hai tạo ra một 0 đẹp, an toàn, nhưng có lẽ không phải là toán học nghiêm ngặt cho đầu ra.

JavaScript (ES6), 20 byte 19 byte.

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

Đây là một cổng của giải pháp Haskell của @nimi sang JavaScript. Nó sử dụng các thuộc tính "ngắn mạch" &&để trả về phía bên trái của nó nếu nó là falsey (trong trường hợp này là -0) hoặc nếu không thì trả về phía bên phải của nó. odd x = 0Do đó, để thực hiện, chúng tôi thực hiện phía bên trái 1 - (x % 2)bong bóng 0qua &&, nếu không, chúng tôi tái diễn 1 + f(x / 2).

Việc cạo 1 - (x % 2)như (~x) % 2là do @Neil bên dưới và có thuộc tính lạ khiến hàm trên phát ra -0cho các số lẻ nhỏ. Giá trị này là một đặc thù của quyết định của JS rằng các số nguyên được nhân đôi theo tiêu chuẩn IEEE754; hệ thống này có một mã riêng biệt +0và -0được đặt trong JavaScript đặc biệt ===cho nhau. Các ~nhà điều hành tính toán 32-bit-ký-nguyên Bitwise đảo về số lượng, mà cho số lẻ nhỏ sẽ có một số thậm chí tiêu cực. ( Math.pow(2, 31) + 1Ví dụ, số dương tạo ra 0chứ không phải -0.) Hạn chế lạ đối với các số nguyên có chữ ký 32 bit không có bất kỳ hiệu ứng nào khác; đặc biệt nó không ảnh hưởng đến tính chính xác.

Perl 6, 23 18 byte

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

sử dụng

> 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

Trình mã golf đầu tiên của tôi (yey!)

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

Làm thế nào tôi đến đây :

Đầu tiên tôi muốn lấy mã thực sự hoàn thành thông số kỹ thuật để giải quyết vấn đề, vì vậy tôi đã xây dựng phương thức mà không liên quan đến số byte:

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

với kiến ​​thức này, tôi đã phân tích lại hàm thành một vòng lặp while và thêm $*(ARGV) làm đầu vào và i là số lần giảm một nửa số trước khi nó trở thành số lẻ.

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

Tôi khá tự hào về điều này và gần như đã gửi nó trước khi tôi nhận ra rằng tất cả những điều này chia cho hai người nghe có vẻ hơi nhị phân đối với tôi, là một kỹ sư phần mềm nhưng không phải là một nhà khoa học máy tính, đây không phải là điều đầu tiên nảy ra trong đầu tôi.

Vì vậy, tôi đã thu thập một số kết quả về các giá trị đầu vào trông như thế nào trong nhị phân:

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

Tôi nhận thấy rằng kết quả là số vị trí bên trái chúng ta phải đi qua trước khi số đó trở thành số lẻ.

Thực hiện một số thao tác chuỗi đơn giản, tôi chia chuỗi trên lần xuất hiện cuối cùng của 1 và đếm độ dài của 0 còn lại:

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

sử dụng ("%b" % x)định dạng để biến một số thành nhị phân và chuỗi # lát để cắt chuỗi của tôi.

Tôi đã học được một vài điều về ruby ​​trong nhiệm vụ này và mong muốn sớm có nhiều golf hơn!

J, 6 byte

1&q:@|

Giải trình:

     |    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;} Kiểm tra đệ quy bit cuối cùng cho đến khi nó không phải là 0.

Haskell, 28 byte

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

Ví dụ sử dụng: f 94208-> 12.

Nếu số là số lẻ, kết quả là 0, 1cộng với một cuộc gọi đệ quy với một nửa số.

Befunge, 20

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

Thực thi mã tiếp tục di chuyển sang phải và quấn quanh ký tự thứ hai của dòng đầu tiên (nhờ vào dấu #) cho đến khi 2%đầu ra 1, điều này làm _cho việc chuyển hướng sang trái, sau đó |lên, bao quanh sang <hàng thứ hai, mà đầu ra và lối ra. Chúng tôi tăng phần tử thứ hai lên trên cùng của ngăn xếp mỗi lần qua vòng lặp, sau đó chia đỉnh cho 2.

Võng mạc ,29 17

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

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

2 byte được lưu nhờ Martin!

Đưa đầu vào unary. Điều này liên tục khớp với số lượng 1s lớn nhất có thể sao cho số 1s đó khớp chính xác với số còn lại 1trong số đó. Mỗi lần thực hiện việc này, nó sẽ thêm một ;chuỗi. Cuối cùng, chúng tôi đếm số ;s trong chuỗi.

Nếu bạn muốn nhập số thập phân, thêm:

\d+
$0$*1

đến đầu chương trình.

Jolf, 6 byte

Hãy thử nó ở đây!

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

Khá đơn giản ... Kudos to ETHSản phẩm để hất cẳng Jolf với phiên bản thực sự nên hoạt động!

PARI / GP, 17 byte

n->valuation(n,2)

Ngôn ngữ máy 6502, 7 byte

Để tìm giá trị vị trí của 1 bit có ý nghĩa nhỏ nhất của giá trị khác 0 trong bộ tích lũy, để lại kết quả trong thanh ghi X:

A2 FF E8 4A 90 FC 60

Để chạy cái này trên trình giả lập 6502 trên e-tradition.net , hãy thêm tiền tố vào A9sau với số nguyên 8 bit.

Điều này tháo rời như sau:

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

Điều này tương đương với C sau đây, ngoại trừ C yêu cầu intít nhất 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;
}

Điều tương tự cũng hoạt động trên 65816, giả sử MX = 01 (bộ tích lũy 16 bit, chỉ số 8 bit) và tương đương với đoạn mã C ở trên.

Brachylog , 27 15 byte

$pA:2xlL,Al-L=.

Giải trình

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

Đọc số nguyên, giá trị tuyệt đối, thừa số nguyên tố, đếm twos.

JavaScript ES6, 36 38 byte

Chơi gôn hai byte nhờ @ETHproductions

Câu trả lời khá nhàm chán, nhưng nó làm công việc. Có thể thực sự quá giống với một câu trả lời khác, nếu anh ta thêm các thay đổi được đề xuất thì tôi sẽ xóa của tôi.

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

Để chạy, gán nó cho một biến ( a=>{for...) vì đây là hàm ẩn danh, sau đó gọi nó bằng a(100).

ES6, 22 byte

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

Trả về -1 nếu bạn vượt qua 0.

DUP , 20 byte

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

Try it here!

Chuyển đổi sang đệ quy, đầu ra hiện là số hàng đầu trên ngăn xếp. Sử dụng:

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

Giải trình

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

Kiểm tra nó trực tuyến!

Phiên bản trước nên có năm byte, nhưng phiên bản này thực sự hoạt động.

Làm thế nào nó hoạt động

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

Tắt 2 byte cảm ơn @JohnWHSmith . Tắt 2 byte cảm ơn @luserdroog .

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

Kiểm tra trực tiếp trên ideone .