Thử thách

Cho một số nguyên ở định dạng bổ sung hai bit 32 bit , trả về chỉ số của chữ số 0 có ý nghĩa nhỏ thứ hai trong biểu diễn nhị phân, trong đó một chỉ số 0đại diện cho bit có trọng số thấp nhất và chỉ số 31đại diện cho bit có ý nghĩa nhất.

Nếu không có số 0 thứ hai, bạn có thể trả về 0, bất kỳ số âm nào, bất kỳ giá trị sai lệch nào hoặc báo cáo lỗi theo cách có ý nghĩa trong ngôn ngữ của bạn.

Bạn có thể sử dụng lập chỉ mục 1 nếu bạn thích, nhưng các trường hợp thử nghiệm bên dưới sẽ sử dụng lập chỉ mục 0.

Bạn có thể sử dụng số nguyên không dấu nếu bạn thích; nếu bạn làm như vậy, thì bạn phải xử lý các số nguyên trong phạm vi [0, 2^32). Nếu bạn sử dụng số nguyên đã ký, bạn phải xử lý số nguyên trong phạm vi [-2^31, 2^31). Các trường hợp thử nghiệm ở đây sẽ sử dụng số nguyên đã ký, nhưng lưu ý rằng -x(đã ký) là 2^32 - x(chưa ký).

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

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

Chấm điểm

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất trong mỗi ngôn ngữ sẽ thắng!

Python 2 , 45 byte

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

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

Sử dụng lập chỉ mục 0, số không dấu và đưa ra lỗi không có số 0.

Đơn giản chỉ cần tạo một danh sách các chỉ số của các bit không được đặt, từ thấp nhất đến cao nhất và trả về mục nhập thứ hai.

JavaScript (ES6), 34 byte

Trả về chỉ mục dựa trên 0 hoặc -1nếu không tìm thấy số 0 thứ hai.

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

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

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

Biểu thức thay thế

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

Phiên bản đệ quy, 42 byte

Trả về chỉ mục dựa trên 0 hoặc falsenếu không tìm thấy số 0 thứ hai.

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

Làm sao?

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

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

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

Phiên bản thay thế được đề xuất bởi Neil, 41 byte

Trả về chỉ mục dựa trên 0 hoặc đưa ra lỗi đệ quy quá nhiều nếu không tìm thấy số 0 thứ hai.

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

Thạch , 7 byte

|‘‘&~l2

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

Nó xuất ra thứ gì đó không nằm trong phạm vi [1,31] nếu không có số 0 thứ hai. Điều này bao gồm 32 33và (-inf+nanj). Tôi đoán điều đó có ý nghĩa.

Nó tính toán log(((x|(x+1))+1)&~x)/log(2).

Java, ... 194 191 186 byte

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 Byte để sử dụng tên biến nhỏ hơn và xóa khoảng trắng
-25 Byte, sau khi lấy các biến thậm chí ngắn hơn và nhờ các mẹo @KevinCruijssen
-18 Byte, nhiều khoảng trắng hơn, tên hàm
-3 Byte, nhờ @KevinCruijssen, rút ​​ngắn nếu điều kiện
-5 Byte , Cảm ơn @Arnold Palmer, @KevinCruijssen, rút ​​ngắn vòng lặp

Ung dung

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

Java (OpenJDK 8) , 44 38 byte

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

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

Trả về 0 nếu không có bit 0 thứ hai tồn tại.

Mã máy IA-32, 14 13 byte

Hexdump:

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

Danh sách tháo gỡ:

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

Nhận đầu vào trong ecx; đầu ra là trong al. Trả về 0 khi lỗi.

Trước hết, nó đảo ngược đầu vào, vì vậy nó có thể sử dụng các hướng dẫn quét bit để tìm kiếm các bit được thiết lập. Nó tìm kiếm bit set ít quan trọng nhất, đặt lại nó, tìm bit set ít quan trọng nhất một lần nữa và trả về kết quả.

Nếu hướng dẫn quét bit không tìm thấy bất kỳ bit nào được đặt, tài liệu Intel cho biết đầu ra không được xác định. Tuy nhiên, trong thực tế, tất cả các bộ xử lý đều giữ nguyên thanh ghi đích trong trường hợp này (như được lưu ý bởi Cody Gray, tài liệu AMD mô tả hành vi này là bắt buộc).

Vì vậy, có những trường hợp sau:

1. Không có bit nào (nhị phân 111 ... 1): ecx được đặt thành 0 by notvà vẫn là 0
2. Một bit 0: ecx được đặt thành 0 by btrvà vẫn là 0 saubsf
3. Hai bit 0: ecx được đặt thành giá trị phù hợp theo bsf

APL Dyalog, 20 byte

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

Sử dụng 1 chỉ mục, ném INDEX ERRORtrong trường hợp không có giây thứ hai.

Làm sao?

⍵⊤⍨- mã hóa ⍵dưới dạng

32⍴2 - chuỗi nhị phân có độ dài 32

⌽ - đảo ngược

~ - phủ định (0 → 1, 1 → 0)

(⍳32)/⍨ - nén với phạm vi 1-32 (để lại các chỉ số 0)

2⊃ - chọn phần tử thứ hai

Thạch , 13 byte

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

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

Sử dụng lập chỉ mục 1, được lấy số nguyên không dấu làm đầu vào. Trả về 0cho không tìm thấy.

Thạch , 12 byte

,4BUFḣ32¬TḊḢ

Một liên kết đơn, lấy một số nguyên, sử dụng tùy chọn không dấu và trả về kết quả 1 chỉ mục (trả về 0 khi không tồn tại).

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

hoặc là

32Ḷ2*|€n⁸TḊḢ

Hãy thử nó

Làm sao?

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

mã máy x86_64, 34 32 byte

Không chắc đây có phải là cách tiếp cận đúng hay không, khá nhiều byte (hóa ra không phải vậy ):

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

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

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

Cảm ơn @CodyGray cho -2byte.

8 , 149 byte

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:@

Mã nhận xét

: 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:@
;

Sử dụng và đầu ra

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 byte

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

đọc từ stdin; trả về 0không có giây thứ hai và nơi khác.

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