ชาวกรีกโบราณมีสิ่งเหล่านี้ที่เรียกว่าตัวเลขโดยลำพังและทวีคูณ ตัวอย่างของเลขคู่ตัวเดียวคือ 14 มันสามารถหารด้วย 2 ครั้งและ ณ จุดนั้นกลายเป็นเลขคี่ (7) หลังจากนั้นจะไม่หารด้วย 2 อีกต่อไป จำนวนคู่ที่เท่ากันคือ 20 มันสามารถหารด้วย 2 สองครั้งแล้วกลายเป็น 5

งานของคุณคือการเขียนฟังก์ชั่นหรือโปรแกรมที่ใช้จำนวนเต็มเป็นอินพุทและเอาท์พุทจำนวนครั้งที่มันหารด้วย 2 เป็นจำนวนเต็มในไม่กี่ไบต์ที่เป็นไปได้ อินพุตจะเป็นจำนวนเต็มไม่ใช่ศูนย์ (ค่าบวกหรือลบใด ๆ ภายในขีด จำกัด ของภาษาของคุณ)

กรณีทดสอบ:

14 -> 1

20 -> 2

94208 -> 12

7 -> 0

-4 -> 2

คำตอบที่มีจำนวนไบต์น้อยที่สุดจะเป็นผู้ชนะ

เคล็ดลับ:ลองแปลงตัวเลขเป็นเบส 2 ดูว่ามีอะไรบอกคุณ

เยลลี่ขนาด 4 ไบต์

Æfċ2

ใน Jelly เวอร์ชันล่าสุดÆEḢทำงานได้ (3 ไบต์)

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

ลองมันนี่

รหัสเครื่อง x86_64 ขนาด 4 ไบต์

คำสั่ง BSF (บิตสแกนไปข้างหน้า) ทำสิ่งนี้อย่างแน่นอน !

0x0f    0xbc    0xc7    0xc3

ในการประกอบแบบ gcc นี่คือ:

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

อินพุตจะถูกกำหนดในการลงทะเบียน EDI และส่งคืนในการลงทะเบียน EAX ตามมาตรฐานการเรียกแบบ64 บิตค

เนื่องจากการเข้ารหัสแบบสองส่วนเสริมของทั้งสองวิธีนี้ทำงานสำหรับ -ve เช่นเดียวกับ + ve ตัวเลข

นอกจากนี้แม้จะมีเอกสารอธิบายว่า"ถ้าเนื้อหาของตัวถูกดำเนินการต้นทางเป็น 0 เนื้อหาของตัวถูกดำเนินการปลายทางจะไม่ได้กำหนด" ฉันพบ Ubuntu VM ของฉันว่าผลลัพธ์ของf(0)เป็น 0

คำแนะนำ:

• บันทึกข้างต้นเป็นevenness.sและประกอบกับgcc -c evenness.s -o evenness.o
• บันทึกไดรเวอร์ทดสอบต่อไปนี้เป็นevenness-main.cและคอมไพล์ด้วย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;
}

แล้ว:

• Link: gcc evenness-main.o evenness.o -o evenness
• วิ่ง: ./evenness

@FarazMasroor ขอรายละเอียดเพิ่มเติมเกี่ยวกับวิธีการได้รับคำตอบนี้

ฉันคุ้นเคยกับcมากกว่าความซับซ้อนของชุดประกอบ x86 ดังนั้นโดยทั่วไปฉันจะใช้คอมไพเลอร์เพื่อสร้างรหัสชุดประกอบสำหรับฉัน ฉันรู้จากประสบการณ์ว่าส่วนขยาย GCC เช่น__builtin_ffs(), __builtin_ctz()และ__builtin_popcount()มักจะรวบรวมและประกอบไป 1 หรือ 2 คำแนะนำเกี่ยวกับ x86 ดังนั้นฉันเริ่มจากฟังก์ชั่นcเช่น:

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

แทนการใช้ GCC รวบรวมปกติทุกวิธีการรหัสวัตถุ, คุณสามารถใช้-Sตัวเลือกในการรวบรวมเพียงเพื่อประกอบ gcc -S -c evenness.c- สิ่งนี้จะให้ไฟล์ประกอบ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

สิ่งนี้สามารถเล่นกอล์ฟได้มาก โดยเฉพาะอย่างยิ่งเรารู้ว่าอนุสัญญาการเรียกc สำหรับฟังก์ชั่นที่มีลายเซ็นดีและเรียบง่าย - พารามิเตอร์การป้อนข้อมูลจะถูกส่งผ่านในการลงทะเบียนและค่าตอบแทนจะถูกส่งกลับในการลงทะเบียน ดังนั้นเราจึงสามารถนำเอาคำแนะนำส่วนใหญ่ออกมาได้ส่วนมากจะเกี่ยวข้องกับการบันทึกการลงทะเบียนและการตั้งค่าสแต็กเฟรมใหม่ เราไม่ใช้สแต็คที่นี่และใช้รีจิสเตอร์เท่านั้นดังนั้นไม่จำเป็นต้องกังวลเกี่ยวกับรีจิสเตอร์อื่น ใบนี้ประกอบรหัส "golfed":int f(int n);EDIEAXEAX

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

หมายเหตุตามที่ @zwol ชี้ให้เห็นคุณยังสามารถใช้การรวบรวมที่ปรับให้เหมาะสมเพื่อให้ได้ผลลัพธ์ที่คล้ายกัน โดยเฉพาะอย่างยิ่ง-Osจะสร้างคำแนะนำข้างต้นอย่างแน่นอน (พร้อมกับคำสั่งแอสเซมเบลอร์เพิ่มเติมบางรายการที่ไม่สร้างโค้ดออบเจ็กต์เพิ่มเติม)

ตอนนี้ประกอบกับgcc -c evenness.s -o evenness.oซึ่งสามารถเชื่อมโยงกับโปรแกรมควบคุมการทดสอบตามที่อธิบายไว้ข้างต้น

มีหลายวิธีในการกำหนดรหัสเครื่องที่สอดคล้องกับชุดประกอบนี้ สิ่งที่ฉันชอบคือการใช้disassคำสั่งgdb disassembly:

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

ดังนั้นเราจะเห็นว่ารหัสเครื่องสำหรับbsfการเรียนการสอนเป็น0f bc c7และมีretc3

Python ขนาด 25 ไบต์

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

n & -n เลขศูนย์ใด ๆ ยกเว้นบิตนัยสำคัญน้อยที่สุดเช่นนี้

100010101010100000101010000
            v
000000000000000000000010000

เรามีความสนใจในจำนวนของเลขท้ายเพื่อให้เราแปลงเป็นสตริงไบนารีใช้ซึ่งจำนวนดังกล่าวข้างต้นจะเป็นbin "0b10000"เนื่องจากเราไม่สนใจ0bหรือ1เราลบ 3 จากความยาวสตริงนั้น

Pyth, 6 ไบต์

/P.aQ2

ลองมันนี่

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

JavaScript (ES6), 18 ไบต์

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

4 31-Math.clz32ไบต์สั้นกว่า ฮะ

JavaScript ES6, 22 19 ไบต์

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

ดูเหมือนว่าการเรียกซ้ำเป็นเส้นทางที่สั้นที่สุด

Pyth, 8 ไบต์

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

ตัวอย่างเช่นการเป็นตัวแทนไบนารีของ94208คือ:

10111000000000000

หลังจากแยก1และรับองค์ประกอบสุดท้ายของอาร์เรย์ผลลัพธ์จะกลายเป็น:

000000000000

นั่นคือ 12 ศูนย์ดังนั้นมันคือ "12-ly สม่ำเสมอ"

งานนี้เพราะx / 2เป็นหลักx >> 1ใช่หรือไม่เพราะเป็นที่ bitshift 1ขวาของ ดังนั้นตัวเลขจะหารด้วย 2 เมื่อ LSB เท่ากับ0(เช่นเดียวกับวิธีหารด้วยทศนิยม 10 เมื่อหลักสุดท้ายคือ0)

05AB1E , 4 5 ไบต์

ตอนนี้รองรับจำนวนลบ รหัส:

Äb1¡g

ลองออนไลน์!

คำอธิบาย:

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

ใช้การเข้ารหัส CP-1252

Pyth, 6 ไบต์

x_.BQ1

โดยพื้นฐานแล้วเพียง

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

MATL , 5 ไบต์

Yf2=s

สิ่งนี้ใช้ได้กับจำนวนเต็มทั้งหมด

ลองออนไลน์!

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) ไบต์

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

(ไม่ได้ทดสอบอาร์กิวเมนต์ศูนย์เนื่องจากระบุอาร์กิวเมนต์ที่ไม่ใช่ศูนย์)

อัปเดต (ตอบกลับความคิดเห็น) : หากเราอนุญาตให้มีการประกาศฟังก์ชันสไตล์ K&R เราสามารถมีรุ่น 28 ไบต์ได้:

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

ในกรณีนี้เราพึ่งพาความจริงที่ว่าค่าเริ่มต้นของคอมไพเลอร์ทั้งสองnและประเภทของการกลับมาของการf intฟอร์มนี้สร้างคำเตือนด้วย C99 แม้ว่าและจะไม่คอมไพล์เป็นรหัส C ++ ที่ถูกต้อง

Java 7, 39 หรืออาจจะ 44 ไบต์

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

การเรียกซ้ำย่ะ! ฉันต้องใช้การ!=เปรียบเทียบที่สั้นกว่าดังนั้นมันจะไม่ล้นในแง่ลบ แต่อย่างอื่นตรงไปตรงมา ถ้ามันแปลกส่งศูนย์ ถ้าเป็นเช่นนั้นให้เพิ่มและทำอีกครั้ง

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

JavaScript (ES6), 20 ไบต์ 19 ไบต์

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

นี่คือพอร์ตของโซลูชัน Haskell โดย @nimi ถึง JavaScript มันใช้คุณสมบัติ "ลัดวงจร" &&ซึ่งคืนด้านซ้ายถ้ามันเป็นเท็จ (ซึ่งในกรณีนี้คือ-0) หรือมิฉะนั้นจะส่งกลับทางด้านขวาของมัน ในการดำเนินการodd x = 0ดังนั้นเราจึงทำด้านซ้ายมือ1 - (x % 2)ซึ่งฟอง0ผ่านมิฉะนั้นเราจะ&& recurse1 + f(x / 2)

การโกนของ1 - (x % 2)as (~x) % 2is เกิดจาก @Neil ด้านล่างและมีคุณสมบัติแปลก ๆ ที่ทำให้ฟังก์ชั่นด้านบนปล่อย-0จำนวนคี่เล็ก ๆ ค่านี้เป็นลักษณะเฉพาะของการตัดสินใจของ JS ที่จำนวนเต็มเป็น IEEE754 เป็นสองเท่า ระบบนี้มีระบบแยกต่างหาก+0และ-0เป็นระบบที่พิเศษใน JavaScript เพื่อ===ให้กันและกัน ~ประกอบการคำนวณผกผันบิต 32 บิตลงนามจำนวนเต็มหมายเลขซึ่งสำหรับเลขคี่ขนาดเล็กจะมีจำนวนติดลบ ( Math.pow(2, 31) + 1ตัวอย่างเช่นสร้างจำนวนบวก0มากกว่า-0) ข้อ จำกัด ที่แปลกสำหรับจำนวนเต็มแบบ 32 บิตที่ลงนามแล้วนั้นไม่มีผลกระทบใด ๆ โดยเฉพาะอย่างยิ่งมันไม่ส่งผลกระทบต่อความถูกต้อง

Perl 6, 23 18 ไบต์

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

การใช้

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

การส่งรหัสกอล์ฟครั้งแรกของฉัน (yey!)

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

ฉันมาที่นี่ได้อย่างไร :

ก่อนอื่นฉันต้องการรับโค้ดที่เติมเต็มสเป็คจริงเพื่อให้เข้าใจถึงปัญหาดังนั้นฉันจึงสร้างวิธีโดยไม่คำนึงถึงจำนวนไบต์:

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

ด้วยความรู้นี้ฉันยกเลิกการเรียกใช้ฟังก์ชั่นใหม่อีกครั้งในขณะที่ลูปและเพิ่ม$*(ARGV) เป็นอินพุตและ i เป็นการนับจำนวนกี่ครั้งที่จำนวนนั้นลดลงครึ่งหนึ่งก่อนที่มันจะแปลก

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

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

ดังนั้นฉันจึงรวบรวมผลลัพธ์บางอย่างเกี่ยวกับค่าที่ป้อนเข้าเป็นแบบไบนารี่:

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

ฉันสังเกตเห็นว่าผลลัพธ์คือจำนวนตำแหน่งทางด้านซ้ายที่เราต้องทำการสำรวจก่อนที่จำนวนจะเป็นเลขคี่

ทำการจัดการสตริงอย่างง่าย ๆ ฉันแบ่งสตริงในเหตุการณ์ล่าสุด 1 และนับความยาวของ 0s ที่เหลืออยู่:

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

ใช้การ("%b" % x)จัดรูปแบบเพื่อเปลี่ยนตัวเลขเป็นไบนารีและString # sliceเพื่อแบ่งสตริงของฉัน

ฉันได้เรียนรู้เล็ก ๆ น้อย ๆ เกี่ยวกับทับทิมในภารกิจนี้และหวังว่าจะได้เล่นกอล์ฟมากขึ้นในไม่ช้า!

J, 6 ไบต์

1&q:@|

คำอธิบาย:

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

C, 37 ไบต์

f(int x){return x?x&1?0:1+f(x/2):0;} ตรวจสอบบิตสุดท้ายซ้ำจนกว่าจะไม่ใช่ 0

Haskell, 28 ไบต์

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

ตัวอย่างการใช้งาน: ->f 9420812

หากตัวเลขเป็นเลขคี่ผลลัพธ์จะเป็น0อีกค่า1บวกกับการโทรซ้ำด้วยจำนวนครึ่งหนึ่ง

Befunge, 20

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

การประมวลผลโค้ดจะย้ายไปทางขวาและล้อมรอบไปที่อักขระตัวที่สองของบรรทัดแรก (เนื่องจากการตามท้าย#) จนกระทั่ง2%เอาท์พุท1ซึ่งทำให้_สลับทิศทางไปทางซ้ายจากนั้น|ขึ้นไปซึ่งล้อมรอบไปยัง<แถวที่สอง ซึ่งเอาต์พุตและออก เราเพิ่มองค์ประกอบที่สองไปยังด้านบนสุดของสแต็กทุกครั้งที่ผ่านลูปแล้วหารด้านบนด้วย 2

จอประสาทตา29 17

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

ลองออนไลน์!

บันทึก 2 ไบต์ขอบคุณ Martin!

ใช้อินพุต unary นี่ตรงกับจำนวนที่มากที่สุดของ1มันซ้ำแล้วซ้ำอีกว่าจำนวนนั้น1ตรงกับส่วนที่เหลือของ1s ในจำนวน ทุกครั้งที่มันทำสิ่งนี้มันจะเป็นการเติม;ให้กับสตริง ในตอนท้ายเราจะนับจำนวน;s ในสตริง

หากคุณต้องการการป้อนทศนิยมให้เพิ่ม:

\d+
$0$*1

ไปที่จุดเริ่มต้นของโปรแกรม

Jolf, 6 ไบต์

ลองที่นี่!

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

ค่อนข้างง่าย ... รุ่งโรจน์ถึง ETHProductions สำหรับขับไล่ Jolf ไปกับเวอร์ชั่นที่ควรจะใช้!

PARI / GP ขนาด 17 ไบต์

n->valuation(n,2)

ภาษาเครื่อง 6502, 7 ไบต์

ในการค้นหาค่าสถานที่ที่มีค่าน้อยที่สุด 1 บิตของค่าที่ไม่ใช่ศูนย์ในตัวสะสมให้คงผลลัพธ์ไว้ใน register X:

A2 FF E8 4A 90 FC 60

ในการรันโปรแกรมจำลอง 6502 บน e-tradition.netให้ใส่คำนำหน้าแล้วA9ตามด้วยเลขจำนวนเต็ม 8 บิต

Disassembles ต่อไปนี้:

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

นี่เทียบเท่ากับ C ต่อไปนี้ยกเว้น C ต้องintมีอย่างน้อย 16 บิต:

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

การทำงานแบบเดียวกันบน 65816 สมมติว่า MX = 01 (ตัวสะสม 16 บิตดัชนี 8 บิต) และเทียบเท่ากับตัวอย่างข้อมูล C ข้างต้น

Brachylog , 27 15 ไบต์

$pA:2xlL,Al-L=.

คำอธิบาย

$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 ไบต์

rizmf2e=

อ่านจำนวนเต็ม, ค่าสัมบูรณ์, แยกตัวประกอบเฉพาะ, นับสองครั้ง

JavaScript ES6, 36 38ไบต์

Golfed สองไบต์ด้วย @ETHproductions

คำตอบน่าเบื่อพอสมควร แต่ก็ทำงานได้ดี อาจคล้ายกับคำตอบอื่นมากเกินไปถ้าเขาเพิ่มการเปลี่ยนแปลงที่แนะนำแล้วฉันจะลบของฉันออก

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

เพื่อให้ทำงานได้กำหนดให้กับตัวแปร ( a=>{for...) a(100)ในขณะที่มันเป็นฟังก์ชั่นที่ไม่ระบุชื่อแล้วเรียกมันด้วย

ES6, 22 ไบต์

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

ผลตอบแทน -1 ถ้าคุณผ่าน 0

DUP , 20 ไบต์

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

Try it here!

แปลงเป็นการเรียกซ้ำการส่งออกตอนนี้เป็นหมายเลขบนสุดของสแต็ก การใช้งาน:

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

คำอธิบาย

[                ]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 ไบต์

¢w b1

ทดสอบออนไลน์!

รุ่นก่อนหน้าควรมีขนาดห้าไบต์ แต่อันนี้ใช้งานได้จริง

มันทำงานอย่างไร

       // 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 ไบต์

2 ไบต์ปิดขอบคุณ@JohnWHSmith 2 ไบต์ปิดขอบคุณ@luserdroog

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

ทดสอบอาศัยอยู่บนideone