Inversione bit tramite bit a bit

Question

Sto cercando di eseguire l'inversione dei bit in un byte. Io uso il codice qui sotto

static int BitReversal(int n) 
{ 
    int u0 = 0x55555555; // 01010101010101010101010101010101 
    int u1 = 0x33333333; // 00110011001100110011001100110011 
    int u2 = 0x0F0F0F0F; // 00001111000011110000111100001111 
    int u3 = 0x00FF00FF; // 00000000111111110000000011111111 
    int u4 = 0x0000FFFF; 
    int x, y, z; 
    x = n; 
    y = (x >> 1) & u0; 
    z = (x & u0) << 1; 
    x = y | z; 

    y = (x >> 2) & u1; 
    z = (x & u1) << 2; 
    x = y | z; 

    y = (x >> 4) & u2; 
    z = (x & u2) << 4; 
    x = y | z; 

    y = (x >> 8) & u3; 
    z = (x & u3) << 8; 
    x = y | z; 

    y = (x >> 16) & u4; 
    z = (x & u4) << 16; 
    x = y | z; 

    return x; 
} 

Può inversore il bit (su una macchina a 32-bit), ma c'è un problema, Ad esempio, l'ingresso è 10.001.111,101 mila, voglio ottenere 10.111.110 mila uno, ma questo metodo invertirà l'intero byte inclusa la voce 0s. L'output è 10111110001000000000000000000000. Esiste un metodo per invertire solo il numero effettivo? Non voglio convertirlo in stringa e inversione, quindi convertire di nuovo. Esiste un metodo matematico puro o un metodo di operazione a bit?

migliori saluti,

Answer 1

modo di formaggio è quello di spostare fino ad ottenere un 1 a destra:

if (x != 0) { 
    while ((x & 1) == 0) { 
     x >>= 1; 
    } 
} 

Nota: Si dovrebbe cambiare tutte le variabili da unsigned int. Come scritto puoi avere un'estensione di segno indesiderata ogni volta che fai il turno giusto.

Answer 2

ottenere il più alto numero di bit utilizzando un approccio simile e spostare i bit risultanti a destra 33 - #bits e voilà!

Answer 3

Un metodo potrebbe essere quello di trovare il numero iniziale di bit di segno nel numero n, lo spostamento a sinistra n di quel numero e quindi eseguirlo tramite l'algoritmo di cui sopra.

Answer 4

Supponendo che tutti i 32 bit siano significativi e invertendo il tutto. Potresti provare a indovinare il numero di bit significativi trovando il valore 1 più alto, ma ciò non è necessariamente accurato, quindi ti suggerisco di modificare la funzione in modo da prendere un secondo parametro che indica il numero di bit significativi. Quindi, dopo aver invertito i bit, spostali verso destra.

Answer 5

Provare a utilizzare Integer.reverse (int x);