1-bit y 2 bits Caracteres

Naveen Verma:

Tenemos dos caracteres especiales. El primer carácter puede ser representado por un bit 0. El segundo carácter puede ser representado por dos bits (10 o 11).

Ahora bien, dada una cadena representada por varios bits. Retorno si el último carácter debe ser un personaje de un bit o no. La cadena dada siempre va a terminar con un cero.

Ejemplo 1: Entrada: bits = [1, 0, 0] Salida: True

De entrada: bits = [1, 1, 1, 0] Salida: Falso

class Solution {
public boolean isOneBitCharacter(int[] bits) {
    int n = bits.length-1;
    int count = 0;
    for(int i=n;i<=n;i--){
        if(bits[i]==1){
            count++;
        }else break;

    }return count%2==0;
}
}

este código no funciona para algunos casos de prueba mi segundo caso de ejemplo de prueba no está trabajando

rango:

Para flujos de bits de largos sería mucho más rápido para investigar el flujo de bits desde el final ... Sin embargo, es un poco más difícil de detectar los casos. Cuando nos fijamos en los bits termina:

.....00 // 1 bit
.....01 // error
.....10 // 1/2 bit
.....11 // 2 bit

podemos determinar la respuesta de inmediato a menos que el .....10caso está presente en cuyo caso tenemos que investigar un poco más:

....110 // 1/2 bit
....010 // 2 bit

y otra vez:

....1110 // 1/2 bit
....0110 // 1 bit

y otra vez:

...11110 // 1/2 bit
...01110 // 2 bit

Como se puede ver los consiguientes cuentan determinar si la última palabra es de 1 o 2 bits (que es alterna) para el recuento de su extraña 1 e incluso por su palabra de 2 bits.

Así que simplemente detectar cuyo caso se trata y tirar answe de inmediato o contar los consiguientes antes de la última cero y determinar la respuesta de eso.

De esta manera no es necesario para procesar flujo entero sólo se encuentra el final hasta cero.

Entonces:

.....11 // 2 bit or error
.....01 // error
.....00 // 1 bit
....010 // 2 bit
...0110 // 1 bit
..01110 // 2 bit
.011110 // 1 bit
0111110 // 2 bit

sólo en caso de que se pulsa el inicio de la corriente (sin cero al inicio) su necesaria para procesar gama entera pero que es improbable ... como un solo caso en el que el aspecto corriente de la siguiente manera:

111.....111X

por lo que no o simplemente solo cero al final, pero el recuento de los anteriores último bit todavía le dirá si el final es 1 o 2 bits de longitud ... para eso se puede hacer:

last_word_bit_length= 1 + (consequent_ones_count&1)

Yo no código en Java, por lo que aquí un ejemplo C ++ en su lugar (no debe ser difícil para portarlo):

int last_word_bits(int *bits,int n)
    {
    int i=0;
    if (n<1) return 0;                      // empty
    if (n>=1) i|=bits[n-1];
    if (n>=2) i|=bits[n-2]<<1;
    if (i==1) return 0;                     // ...00 or ...0 -> error
    if (i==0) return 1;                     // ...01 -> 1
    if (i==3) return 2;                     // ...11 -> 2 or error
    // count consequent ones
    for (i=0,n-=2;n>=0;n--,i++)
     if (bits[n]==0) break;
    return 1+(i&1);
    }

dando respuestas:

{1,0,0} -> 1
{1,1,1,0} -> 2

Estoy esperando flujo de bits no contiene errores de lo contrario el caso especial i==3necesidad de contar con los también ... para determinar si se trata o no de error