Desafio

Dado um número inteiro no formato de complemento de dois bits de 32 bits , retorne o índice do segundo dígito zero menos significativo na representação binária, em que um índice 0representa o bit menos significativo e um índice 31representa o bit mais significativo.

Se não houver um segundo zero, você pode retornar 0, qualquer número negativo, qualquer valor falso ou relatar um erro de uma maneira que faça sentido no seu idioma.

Você pode usar a indexação 1, se preferir, mas os casos de teste abaixo usarão a indexação 0.

Você pode usar números inteiros não assinados, se preferir; Se o fizer, você deve manipular números inteiros no intervalo [0, 2^32). Se você usar números inteiros assinados, deverá manipular números inteiros no intervalo [-2^31, 2^31). Os casos de teste aqui usarão números inteiros assinados, mas observe que -x(assinado) é 2^32 - x(não assinado).

Casos de teste

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

Pontuação

Isso é código-golfe , então a resposta mais curta em cada idioma vence!

Python 2 , 45 bytes

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

Experimente online!

Usa indexação 0, números não assinados e gera um erro no segundo zero.

Simplesmente cria uma lista de índices de bits não definidos, do menor para o maior, e retorna a segunda entrada.

JavaScript (ES6), 34 bytes

Retorna um índice com base em 0 ou -1se nenhum segundo zero for encontrado.

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

Casos de teste

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

Expressão alternativa

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

Versão recursiva, 42 bytes

Retorna um índice com base em 0 ou falsese nenhum segundo zero for encontrado.

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

Como?

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

Casos de teste

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

Versão alternativa sugerida por Neil, 41 bytes

Retorna um índice baseado em 0 ou gera um erro de recursão em excesso se nenhum segundo zero for encontrado.

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

Geléia , 7 bytes

|‘‘&~l2

Experimente online!

Ele gera algo que não está no intervalo [1,31] se não houver o segundo zero. Isso inclui 32 33e (-inf+nanj). Eu acho que isso faz algum sentido.

Calcula log(((x|(x+1))+1)&~x)/log(2).

Java, ... 194191186 bytes

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 Bytes por usar nomes de variáveis ​​menores e remover espaços em branco
-25 Bytes, depois de pegar variáveis ​​ainda mais curtas e graças às dicas do @KevinCruijssen
-18 Bytes, mais espaços em branco, nome da função
-3 Bytes, graças ao @KevinCruijssen, reduzindo a condição
-5 Bytes , Graças a @Arnold Palmer, @KevinCruijssen, encurtando o loop

Ungolfed

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 bytes

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

Experimente online!

Retorna 0 se nenhum segundo bit zero existir.

Código de máquina IA-32, 14 13 bytes

Hexdump:

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

Lista de desmontagem:

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

Recebe entrada ecx; saída é em al. Retorna 0 em erro.

Antes de tudo, inverte a entrada, para poder usar as instruções de verificação de bits para procurar por bits definidos. Ele procura o bit de conjunto menos significativo, redefine-o, procura o bit de conjunto menos significativo novamente e retorna o resultado.

Se a instrução bit-scan não encontrar nenhum bit definido, a documentação da Intel diz que a saída é indefinida. No entanto, na prática, todos os processadores deixam o registro de destino inalterado nesse caso (conforme observado por Cody Gray, a documentação da AMD descreve esse comportamento como obrigatório).

Portanto, existem os seguintes casos:

1. Nenhum bit zero (binário 111 ... 1): ecx é definido como 0 por note permanece 0
2. Um bit zero: ecx é definido como 0 por btre permanece 0 apósbsf
3. Dois bits zero: ecx é definido no valor adequado por bsf

Dyalog APL, 20 bytes

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

Usa indexação 1, lança INDEX ERRORem caso de nenhum segundo zero.

Como?

⍵⊤⍨- codificar ⍵como

32⍴2 - sequência binária de comprimento 32

⌽ - marcha ré

~ - negar (0 → 1, 1 → 0)

(⍳32)/⍨ - comprimir com o intervalo de 1 a 32 (deixando índices de zeros)

2⊃ - escolha o segundo elemento

Gelatina , 13 bytes

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

Experimente online!

Usa indexação 1, obtém um número inteiro sem sinal como entrada. Retorna 0para não encontrado.

Gelatina , 12 bytes

,4BUFḣ32¬TḊḢ

Um link monádico, usando um número inteiro, usando a opção não assinada e retornando o resultado indexado em 1 (retorna 0 quando não existe).

Experimente online!

ou

32Ḷ2*|€n⁸TḊḢ

Tente isso

Como?

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

código de máquina x86_64, 34 32 bytes

Não tenho certeza se essa é a abordagem correta, muitos bytes (acontece que não é ):

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

Experimente online!

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

Obrigado @CodyGray pelos -2bytes.

8o , 149 bytes

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

Código comentado

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

Uso e saída

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 bytes

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

lê de stdin; retorna 0para nenhum segundo zero e o local, caso contrário.

Experimente online!