도전

32 비트 2의 보수 형식 의 정수가 제공 되면 이진 표현에서 두 번째 로 중요도가 낮은 두 번째 0 의 인덱스를 반환합니다 . 여기서 인덱스 는 가장 중요하지 않은 비트 0를 31나타내고 인덱스 는 가장 중요한 비트 를 나타냅니다.

두 번째 0이 없으면 0, 음수, 잘못된 값을 반환하거나 사용자 언어에 맞는 방식으로 오류를보고 할 수 있습니다.

원하는 경우 1 인덱싱을 사용할 수 있지만 아래 테스트 사례는 0 인덱싱을 사용합니다.

원하는 경우 부호없는 정수를 사용할 수 있습니다. 그렇게하면 범위의 정수를 처리해야합니다 [0, 2^32). 부호있는 정수를 사용하는 경우 범위의 정수를 처리해야합니다 [-2^31, 2^31). 여기서 테스트 사례는 부호있는 정수를 사용하지만 -x(서명)은 2^32 - x(부호 없음)입니다.

테스트 사례

0 (0b00)-> 1
1 (0b001)-> 2
10 (0b1010)-> 2
11 (0b01011)-> 4
12 (0b1100)-> 1
23 (0b010111)-> 5
-1 (0b11..11)-> 없음
-2 (0b11..10)-> 없음
-4 (0b11..00)-> 1
-5 (0b11..1011)-> 없음
-9 (0b11..10111)-> 없음
2 ^ 31-2 (0b0111..1110)-> 31

채점

이것은 code-golf 이므로 각 언어에서 가장 짧은 답변이 이깁니다!

파이썬 2 , 45 바이트

lambda n:[i for i in range(32)if n|1<<i>n][1]

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

0 인덱싱, 부호없는 숫자를 사용하고 0 초에 오류가 발생합니다.

비 설정 비트의 인덱스 목록을 가장 낮은 값에서 가장 높은 값으로 만들고 두 번째 항목을 반환합니다.

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

0부터 시작하거나 -1두 번째 0이없는 경우 인덱스를 반환합니다 .

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

테스트 사례

let f =

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

console.log(f(0))       // -> 1
console.log(f(1))       // -> 2
console.log(f(10))      // -> 2
console.log(f(11))      // -> 4
console.log(f(12))      // -> 1
console.log(f(23))      // -> 5
console.log(f(-1))      // -> None
console.log(f(-2))      // -> None
console.log(f(-4))      // -> 1
console.log(f(-5))      // -> None
console.log(f(-9))      // -> None
console.log(f(2**31-2)) // -> 31

대체 표현

n=>31-Math.clz32((n=~n^++n&-n)&-n)

재귀 버전, 42 바이트

0부터 시작하거나 false두 번째 0이없는 경우 인덱스를 반환합니다 .

f=(n,p=k=0)=>n&1||!k++?p<32&&f(n>>1,p+1):p

어떻게?

f=(n,p=k=0)=>                               // given n, p, k
             n&1||                          // if the least significant bit of n is set
                  !k++?                     // or this is the 1st zero (k was not set):
                       p<31&&               //   return false if p is >= 31
                             f(n>>1,p+1)    //   or do a recursive call with n>>1 / p+1
                                        :p  // else: return p

테스트 사례

f=(n,p=k=0)=>n&1||!k++?p<32&&f(n>>1,p+1):p

console.log(f(0))       // -> 1
console.log(f(1))       // -> 2
console.log(f(10))      // -> 2
console.log(f(11))      // -> 4
console.log(f(12))      // -> 1
console.log(f(23))      // -> 5
console.log(f(-1))      // -> None
console.log(f(-2))      // -> None
console.log(f(-4))      // -> 1
console.log(f(-5))      // -> None
console.log(f(-9))      // -> None
console.log(f(2**31-2)) // -> 31

Neil이 제안한 대체 버전, 41 바이트

0부터 시작하는 인덱스를 반환하거나 두 번째 0이 없으면 너무 많은 재귀 오류가 발생합니다.

f=(n,c=1)=>n%2?1+f(~-n/2,c):c&&1+f(n/2,0)

젤리 , 7 바이트

|‘‘&~l2

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

두 번째 0이 없으면 [1,31] 범위에없는 것을 출력합니다. 여기에는 32 33와 (-inf+nanj). 나는 그것이 의미가 있다고 생각합니다.

계산 log(((x|(x+1))+1)&~x)/log(2)합니다.

Java, ... 194191186 바이트

static int f(int n){char[] c=Integer.toBinaryString(n).toCharArray();int j=0,o=2^32-2,i=c.length,l=i-1;if(n<0|n>o)return 0;for(;j<2&i>0;j+=c[--i]==48?1:0);if(j==2)return l-i;return 0;}

-159 바이트 작은 변수 명을 사용하여 여백 제거
@KevinCruijssen 팁 심지어 짧은 변수 감사 복용 후, -25 바이트
-18 바이트 이상의 공백, 함수명
단축 -3 바이트 @KevinCruijssen 덕분에, 실행 조건
-5 바이트 , @Arnold Palmer, @KevinCruijssen 덕분에 루프 단축

언 골프

public static int getPosSecondZero2(int number){
    int overflow = 2^32-2;
    if(number < 0 || number > overflow){
        return 0;
    }    
    String binaryString = Integer.toBinaryString(number);   
    char[] binaryCharArray = binaryString.toCharArray();    
    int count = 0;
    int idx = binaryCharArray.length;
    int length = binaryCharArray.length -1;
    while(count < 2 && idx>0){
        idx--;
        if(binaryCharArray[idx] == '0'){
            count++;
        }   
    }
    if(count == 2)
        return length-idx;
    return 0;
}

자바 (OpenJDK 8) , 44 38 바이트

i->i.numberOfTrailingZeros(~i&-i-2)&31

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

두 번째 0 비트가 없으면 0을 반환합니다.

IA-32 기계 코드, 14 13 바이트

16 진 덤프 :

F7 D1 0F BC C1 0F B3 C1 0F BC C9 91 C3

분해 목록 :

0:  f7 d1                   not    ecx
2:  0f bc c1                bsf    eax,ecx
5:  0f b3 c1                btr    ecx,eax
8:  0f bc c1                bsf    ecx,ecx
b:  91                      xchg   eax, ecx
c:  c3                      ret

ecx; 에서 입력을받습니다 . 출력은입니다 al. 오류가 발생하면 0을 반환합니다.

우선, 입력을 반전시켜 비트 스캔 명령을 사용하여 설정된 비트를 찾을 수 있습니다. 최하위 세트 비트를 찾아서 재설정하고 최하위 세트 비트를 다시 찾고 결과를 반환합니다.

비트 스캔 명령이 설정된 비트를 찾지 못하면 인텔 설명서에 출력이 정의되어 있지 않다고 나와 있습니다. 그러나 실제로 모든 프로세서는이 경우 대상 레지스터를 변경하지 않은 채로 둡니다 (Cody Gray에서 언급 한 것처럼 AMD 설명서에서는이 동작을 필수로 설명합니다).

따라서 다음과 같은 경우가 있습니다.

1. 0 비트 없음 (이진 111 ... 1) : ecx는 0으로 설정되고 0으로 not유지됩니다.
2. 하나의 0 비트 : ecx는 0으로 설정되고 btr이후에도 0으로 유지됩니다.bsf
3. 두 개의 0 비트 : ecx는 다음과 같이 적절한 값으로 설정됩니다. bsf

Dyalog APL, 20 바이트

{2⊃(⍳32)/⍨~⌽⍵⊤⍨32⍴2}

1- 인덱싱을 사용하고 INDEX ERROR두 번째 0이없는 경우 발생합니다.

어떻게?

⍵⊤⍨- 인코딩 ⍵A와

32⍴2 -길이가 32 인 이진 문자열

⌽ - 역전

~ -부정 (0 → 1, 1 → 0)

(⍳32)/⍨ -1-32 범위로 압축 (인덱스 0)

2⊃ -두 번째 요소를 선택하십시오

젤리 , 13 바이트

B¬Ṛ;1,1ḣ32TḊḢ

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

1- 인덱싱을 사용하고 부호없는 정수를 입력으로 가져옵니다. 0찾을 수 없음을 반환 합니다.

젤리 , 12 바이트

,4BUFḣ32¬TḊḢ

부호없는 옵션을 사용하고 1- 인덱싱 된 결과를 반환하는 정수 링크 (없는 경우 0을 반환).

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

또는

32Ḷ2*|€n⁸TḊḢ

시도 해봐

어떻게?

1.

,4BUFḣ32¬TḊḢ - Link: number, n   e.g. 14
,4           - pair with 4            [14,4]
  B          - to binary              [[1,1,1,0],[1,0,0]]
   U         - upend                  [[0,1,1,1],[0,0,1]]
    F        - flatten                [0,1,1,1,0,0,1]
     ḣ32     - head to 32             [0,1,1,1,0,0,1] (truncates the right if need be)
        ¬    - not (vectorises)       [1,0,0,0,1,1,0]
         T   - truthy indexes         [1,5,6]
          Ḋ  - dequeue                [5,6]
           Ḣ - head                   5
             -   if the dequeued list is empty the head yields 0

2.

32Ḷ2*|€n⁸TḊḢ - Link: number, n   e.g. 14
32Ḷ          - lowered range of 32    [ 0, 1, 2, 3, 4, 5, ...,31]
   2*        - 2 exponentiated        [ 1, 2, 4, 8,16,32, ...,2147483648]
     |€      - bitwise or for €ach    [15,14,14,14,30,46, ...,2147483662]
        ⁸    - chain's right argument 14
       n     - not equal?             [ 1, 0, 0, 0, 1, 1, ..., 1]
         T   - truthy indexes         [ 1, 5, 6, ..., 32]
          Ḋ  - dequeue                [ 5, 6, ..., 32]
           Ḣ - head                   5
             -   if the dequeued list is empty the head yields 0

x86_64 기계 코드, 34 32 바이트

이것이 올바른 접근 방법인지 확실하지 않으면 많은 바이트가 있습니다 ( 그렇지 않음 ).

31 c0 83 c9 ff 89 fa 83 e2 01 83 f2 01 01 d1 7f 09 ff c0 d1 ef eb ee 83 c8 ff 83 f8 1f 7f f8 c3

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

second_zero:
  # Set eax = 0
  xor  %eax, %eax
  # Set ecx = -1
  xor %ecx,%ecx
  not %ecx

  # Loop over all bits
Loop:
  # Get current bit
  mov %edi, %edx
  and $0x1, %edx
  # Check if it's zero and possibly increment ecx
  xor $0x1, %edx
  add %edx, %ecx
  # If ecx > 0: we found the position & return
  jg Return
  # Increment the position
  inc %eax
  # Shift the input and loop
  shr %edi
  jmp Loop

Fix:
  # If there's not two 0, set value to -1
  xor %eax,%eax
  not %eax

Return:
  # Nasty fix: if position > 31 (e.g for -1 == 0b11..11)
  cmp $31, %eax
  jg  Fix

  ret

-2바이트 @CodyGray 감사 합니다.

8 , 149 바이트

2 base swap >s nip decimal s:len 32 swap n:- ( "0" s:<+ ) swap times s:rev null s:/ a:new swap ( "0" s:= if a:push else drop then ) a:each swap 1 a:@

주석이 달린 코드

: f \ n -- a1 a2 n 

  \ decimal to binary conversion
  2 base swap >s nip decimal     

  \ 32bit formatting (padding with 0)            
  s:len 32 swap n:- ( "0" s:<+ ) swap times  

  \ put reversed binary number into an array 
  s:rev null s:/

  \ build a new array with position of each zero 
  a:new swap ( "0" s:= if a:push else drop then ) a:each

  \ put on TOS the position of the 2nd least least-significant zero digit
  swap 1 a:@
;

사용법과 산출

ok> : f 2 base swap >s nip decimal s:len 32 swap n:- ( "0" s:<+ ) swap times s:rev null s:/ a:new swap ( "0" s:= if a:push else drop then ) a:each swap 1 a:@ ;

ok> [0, 1, 10, 11, 12, 23, -1, -2, -4, -5, -9, 2147483646]

ok> ( dup . " -> " .  f . 2drop cr ) a:each
0 -> 1
1 -> 2
10 -> 2
11 -> 4
12 -> 1
23 -> 5
-1 -> null
-2 -> null
-4 -> 1
-5 -> null
-9 -> null
2147483646 -> 31

R , 66 바이트

w=which.min
x=strtoi(intToBits(scan()));w(x[-w(x)])*any(!x[-w(x)])

stdin에서 읽습니다. 0초를 0으로 반환 하고 그렇지 않으면 장소를 반환합니다.

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