고대 그리스인들은 이러한 것들을 독특하고 이중의 짝수라고 불렀습니다. 단일 짝수의 예는 14입니다. 2로 한 번 나눌 수 있으며, 그 시점에서 홀수 (7)가되며, 이후 더 이상 2로 나눌 수 없습니다. 이중 짝수는 20입니다. 2를 2로 나눈 다음 5가됩니다.

당신의 임무는 정수를 입력으로 취하고 가능한 한 적은 바이트로 정수로 2로 나눌 수있는 횟수를 출력하는 함수 또는 프로그램을 작성하는 것입니다. 입력은 0이 아닌 정수입니다 (언어의 한계 내에서 양수 또는 음수 값).

테스트 사례 :

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 레지스터에 제공되며 표준 64 비트 c 호출 규칙 에 따라 EAX 레지스터에 반환됩니다 .

2의 보수 이진 인코딩으로 인해 -ve 및 + ve 숫자에 대해 작동합니다.

또한 "소스 피연산자의 내용이 0이면 대상 피연산자의 내용이 정의되어 있지 않습니다." 라는 문서에도 불구하고 . 우분투 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;
}

그때:

• 링크: gcc evenness-main.o evenness.o -o evenness
• 운영: ./evenness

@FarazMasroor는이 답변의 도출 방법에 대한 자세한 내용을 문의했습니다.

나는 x86 어셈블리의 복잡한 것보다 c에 더 익숙 하므로 일반적으로 컴파일러를 사용하여 어셈블리 코드를 생성합니다. 나는 것을 경험을 통해 알고 GCC의 같은 확장 __builtin_ffs(), __builtin_ctz()그리고__builtin_popcount() 일반적으로 컴파일 및 x86 1 개 또는 2 지침을 조립한다. 그래서 다음과 같은 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 호출 규칙int f(int n); 이 훌륭하고 단순 하다는 것을 알고 있습니다 . 입력 매개 변수가 EDI레지스터에 전달되고 리턴 값이 EAX레지스터에 리턴됩니다 . 따라서 우리는 대부분의 명령어를 제거 할 수 있습니다. 많은 명령어는 레지스터를 저장하고 새로운 스택 프레임을 설정하는 것과 관련이 있습니다. 여기서는 스택을 사용하지 않고 EAX레지스터 만 사용 하므로 다른 레지스터에 대해 걱정할 필요가 없습니다. 이것은 "골프 된"어셈블리 코드를 남깁니다.

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

@zwol가 지적했듯이 최적화 된 컴파일을 사용하여 비슷한 결과를 얻을 수도 있습니다. 특히 -Os위의 명령어를 생성합니다 (추가 객체 코드를 생성하지 않는 몇 가지 추가 어셈블러 지시문 사용).

이제와 함께 어셈블되어 gcc -c evenness.s -o evenness.o위에서 설명한대로 테스트 드라이버 프로그램에 링크 될 수 있습니다.

이 어셈블리에 해당하는 기계어 코드를 결정하는 몇 가지 방법이 있습니다. 내가 가장 좋아하는 것은 gdb disassdisassembly 명령 을 사용하는 것입니다 .

$ 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 c7and for ret임을 알 수 c3있습니다.

파이썬, 25 바이트

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

n & -n 최하위 비트를 제외한 모든 것을 제로화합니다. 예 :

100010101010100000101010000
            v
000000000000000000000010000

우리는 후행 0의 수에 관심이 있으므로 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.

자바 스크립트 (ES6), 18 바이트

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

보다 4 바이트 더 짧은 31-Math.clz32. 하

자바 스크립트 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의 0이므로 "12- 짝수"입니다.

이것은 x / 2본질적으로 x >> 1– 즉 비트 시프트 권한 이기 때문에 작동합니다 1. 따라서 LSB가있을 때만 숫자를 2로 나눌 수 있습니다 0(마지막 숫자가 10 일 때 10 진수를 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;}

(0이 아닌 인수가 지정되었으므로 0의 인수를 테스트하지 않습니다.)

업데이트 (의견에 대한 답변으로) : K & R 스타일 함수 선언을 허용하면 28 바이트 버전을 사용할 수 있습니다.

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

이 경우 컴파일러는 기본값 n과 반환 유형을 모두로 설정한다는 사실에 의존 f합니다 int. 이 형식은 C99로 경고를 생성하며 유효한 C ++ 코드로 컴파일되지 않습니다.

자바 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을 보내십시오. 짝수이면 하나를 추가하고 다시 수행하십시오.

현재 0에 대한 출력을 알 수 없기 때문에 두 가지 버전이 있습니다. 첫 번째는 스택이 오버플로 될 때까지 재귀하고 0은 무한대이므로 아무것도 출력하지 않습니다. 두 번째는 출력을 위해 훌륭하고 안전하지만 수학적으로 엄격하지 않은 0을 뱉습니다.

JavaScript (ES6), 20 바이트 19 바이트

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

@nimi에서 JavaScript 로의 Haskell 솔루션 포트입니다. "short-circuit"속성을 &&사용합니다.이 속성 은 거짓 인 경우 (이 경우는 -0) 왼쪽을 반환 하거나 그렇지 않은 경우 오른쪽을 반환합니다. 구현 odd x = 0하기 위해 우리는 왼쪽을 통해 1 - (x % 2)거품 0을냅니다 &&. 그렇지 않으면로 되돌아갑니다 1 + f(x / 2).

아래의 @Neil로 인한 1 - (x % 2)as 의 면도는 (~x) % 2위의 함수가 -0작은 홀수 로 방출되는 이상한 속성을 가지고 있습니다. 이 값은 정수가 IEEE754 배가된다는 JS의 결정의 특징입니다. 이 시스템은 분리 +0되어 -0있으며 JavaScript로 서로 특수하게 구성되어 있습니다 ===. ~연산자 작은 홀수 대한 부정적인 짝수 될 수 대한 32 비트 서명 정수 비트 반전을 계산한다. ( Math.pow(2, 31) + 1예를 들어 양수 가 0아닌 오히려 생성합니다 -0.) 32 비트 부호있는 정수에 대한 이상한 제한은 다른 영향을 미치지 않습니다. 특히 정확성에 영향을 미치지 않습니다.

펄 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

루비 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

이 지식으로 함수를 while 루프로 되풀이하고 $*(ARGV)를 입력으로 추가 하고 i를 숫자가 홀수가되기 전에 절반으로 줄인 횟수로 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에서 문자열을 분할하고 나머지 0의 길이를 세었습니다.

("%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이 될 때까지 재귀 적으로 확인하십시오.

하스켈, 28 바이트

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

사용 예 : f 94208-> 12.

숫자가 홀수이면 결과는 0이고, 그렇지 않으면 1숫자가 절반 인 재귀 호출입니다.

베 펀지, 20

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

코드 실행 오른쪽으로 이동하고 (덕분에 후행하는 제 1 라인의 두 번째 문자로 감싸 유지 #될 때까지) 2%에 출력 1유발 _한 후, 왼쪽으로 방향을 전환 |받는 감싸는까지, <두 번째 행에 출력하고 종료합니다. 루프를 통해 매번 스택의 최상위에서 두 번째 요소까지 증가시킨 다음 상위를 2로 나눕니다.

망막 ,29 17

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

온라인으로 사용해보십시오!

Martin 덕분에 2 바이트가 절약되었습니다!

단항 입력을받습니다. 이것은 반복적으로 가장 많은 양의 1s 와 일치하며, 그 수의 1s 가 숫자의 나머지 s와 정확히 일치 1하도록 할 수 있습니다. 이 작업을 수행 할 때마다 ;문자열 앞에 a 가 붙습니다 . 마지막으로 ;문자열에서 s 의 수를 계산 합니다.

십진수 입력을 원하면 다음을 추가하십시오.

\d+
$0$*1

프로그램의 시작 부분에.

줄프, 6 바이트

여기 사용해보십시오!

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

오히려 간단합니다 ... 실제로 작동 해야하는 버전으로 Jolf를 쫓아 낸 ETHProductions에게 찬사를 보냅니다!

PARI / GP, 17 바이트

n->valuation(n,2)

6502 기계 언어, 7 바이트

누산기에서 0이 아닌 값의 최하위 1 비트의 자리 값을 찾으려면 결과를 레지스터 X에 그대로 둡니다.

A2 FF E8 4A 90 FC 60

e-tradition.net 의 6502 시뮬레이터에서 이를 실행하려면 접두사 A9뒤에 8 비트 정수를 붙 입니다.

이것은 다음과 같이 분해됩니다.

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가 int16 비트 이상이어야 한다는 점을 제외하면 다음 C와 같습니다.

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

MX = 01 (16 비트 누산기, 8 비트 인덱스)을 가정 할 때 65816에서도 동일하게 작동하며 위의 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=

정수 읽기, 절대 값, 소인수 분해, 2를 세십시오.

자바 스크립트 ES6, 36 38 바이트

@ETHproductions 덕분에 2 바이트 골프

상당히 지루한 대답이지만 그 일을합니다. 제안 된 변경 사항을 추가하면 내 답변을 제거 할 것입니다.

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

실행하려면 a=>{for...익명 함수이므로 변수 ( )에 변수를 할당 한 다음로 호출하십시오 a(100).

ES6, 22 바이트

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

0을 전달하면 -1을 반환합니다.

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}

apt, 9 5 바이트

¢w b1

온라인으로 테스트하십시오!

이전 버전은 5 바이트 여야했지만 실제로 작동합니다.

작동 원리

       // 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 바이트

@JohnWHSmith 덕분에 2 바이트가 떨어져 있습니다. @luserdroog 덕분에 2 바이트 떨어져 있습니다.

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

ideone에서 라이브 테스트 .