au niveau du bit le plus significatif de bit

Je veux trouver le bit le plus significatif est définie à 1. J'ai essayé tous les moyens possibles à partir de & à ORing tous les bits de 1 à 31 et ça ne fonctionne pas.

Comme si 1000000 je voudrais avoir 7.

Qu'avez-vous essayer dans le détail? Quel a été le résultat?
Est-ce devoirs?
J'ai fait toute la count += 1&(~x >> 1-31); et il m'a donné des numéros différents que ce que j'attend, je veux le bit le plus significatif à 1 et c'est tout
Comment doit-nombres négatifs-elle être traitée?
N'a pas d'importance j'ai besoin de le bit le plus significatif c'est 1 c'est tout. donc, même si j'ai -2 j'ai encore besoin de le bit le plus significatif avec le 1

OriginalL'auteur mkuk | 2012-02-02

bit-manipulation java

3

Si vous insistez sur l'utilisation directe des opérateurs au niveau du bit, vous pouvez essayer quelque chose comme ceci:
```
private int mostSignificantBit(int myInt){
  int mask = 1 << 31;
  for(int bitIndex = 31; bitIndex >= 0; bitIndex--){
    if((myInt & mask) != 0){
      return bitIndex;
    }
    mask >>>= 1;
  }
  return -1;
}
```
Nous initialisons le masque de 1 << 31 parce que cela représente un 1 suivi par 31 0. Nous utilisons cette valeur à tester si l'indice 31 (la 32e place) est à 1. Lorsque nous and cette valeur avec myInt, nous obtenons un 0, sauf si le bit correspondant est mis en myInt. Si c'est le cas, nous sommes de retour que bitIndex. Si non, alors on décale le masque de la droite par 1 et essayez de nouveau. Nous répétez jusqu'à ce que nous sommes à court d'endroits pour changer, auquel cas cela signifie aucun des bits étaient ensemble (peut-être que vous souhaitez lancer une exception ici, au lieu de retourner -1).

Noter que ce sera le retour de la valeur 0 pour 1 et 6 pour 64 (1000000 en binaire). Vous pouvez régler que si vous préférez. Notez également que j'ai utilisé le non signé à droite de l'opérateur plutôt que de la signature de décalage à droite. C'est parce que le but ici est de traiter les raw bits plutôt que de leur signature à l'interprétation, mais il n'a pas d'importance dans ce cas étant donné que toutes les valeurs négatives se termine dans la première itération de la boucle, avant de passer se produit.

En fait l'utilisation de la unsigned droit de l'opérateur de décalage est important. Si myInt est pas négatif, alors vous aurez besoin de maj mask et il commence comme une valeur négative.
Vous avez raison que mask aura toujours l'un des principaux 1 qui n'appartiennent pas si l'signé la touche maj droite est utilisée (car mask commence comme négatif). Toutefois, cela n'affecte pas les résultats de ma mise en œuvre parce que quand myInt n'est pas négatif, que le superflu de 1 bit est toujours anded avec un 0 (le bit de signe de myInt, qui nous a été positive).
Bon point! Je n'avais pas travaillé par les conséquences de la présence de pointe 1s en mask, qui (comme vous le soulignez) sont justement rien.

OriginalL'auteur Michael McGowan
16

http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Integer.html#numberOfLeadingZeros%28int%29
Vous voulez quelque chose comme 32 - Integer.numberOfLeadingZeros(value).

pas seulement au niveau du bit
Cela devrait faire ce que vous voulez. Avez-vous essayé?

OriginalL'auteur zch

Si il n'y est une réponse acceptée, j'ai une autre façons de partager ce qui, je pense est plus facile.

Si vous souhaitez utiliser des opérations bit à bit, voici le chemin. En gros, je suis en droit de décalage de l'entier jusqu'à devenir nulle. Aucun masque n'est requis.

private static int mostSignificantBit(int myInt){
    int i = 0;
    while (myInt != 0) {
        ++i;
        myInt >>>= 1;
    }
    return i;
}

Une autre façon est de calculer mathématiquement:

private static int mostSignificantBit(int myInt){
    if (myInt == 0) return 0;    //special handling for 0
    if (myInt < 0) return 32;    //special handling for -ve

    return (int)(Math.log(myInt)/Math.log(2)) +1;
}

OriginalL'auteur Adrian Shum

Les meilleurs de la mise en œuvre, je suis venu à travers trois itérations et une table de recherche.

unsigned int msb32(unsigned int x)
{
    static const unsigned int bval[] =
    { 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4 };

    unsigned int base = 0;
    if (x & 0xFFFF0000) { base += 32/2; x >>= 32/2; }
    if (x & 0x0000FF00) { base += 32/4; x >>= 32/4; }
    if (x & 0x000000F0) { base += 32/8; x >>= 32/8; }
    return base + bval[x];
}

OriginalL'auteur JJWalker

Successive approximation de minimiser les itérations à cinq boucles:

unsigned int mostSignificantBit(uint32_t val) {
  unsigned int bit = 0;

  /* 4 = log(sizeof(val) * 8) /log(2) - 1 */
  for(int r = 4; r >= 0 ; --r) {
    unsigned shift = 1 << r; /* 2^r */
    uint32_t sval = val >> shift;
    if (sval) {
        bit += shift;
        val = sval;
    }
  }
  return bit;
}

OriginalL'auteur D Lindsey

Pas le plus efficace, peut-être, mais cela devrait fonctionner::

public int firstBit(int i) {
    return i < 0 ? 31 : i == 0 ? 0 : Integer.toString(i, 2).length();
}

OriginalL'auteur Ted Hopp

0

Suffit d'utiliser numberOfTrailingZeros(valeur) méthode de Longue ou de la classe Integer.

OriginalL'auteur quit
0

Pour Little Endian format:
```
((yourByte & yourBitMask) >> msbIndex) && 0x01
```
OriginalL'auteur Bavithra Thangaraj
-1

Juste pour ajouter une autre approche
```
public static int mostSignificantBit(int b) {
    for (int i = 1 << 30, j = 0; i > 0; i /= 2, j++) {
           if ((b & i) > 0) {
            return 31-j;
        }
    }
    return -1;
}
```
Vous voulez probablement à l'entrée d'un int plutôt qu'un byte.
oui merci
Je ne pense pas que votre point de départ est correcte. Ce code donne la même réponse pour Integer.MAX_VALUE comme il le fait pour les nombres négatifs.

OriginalL'auteur Johan Sjöberg

-3

if( value | 0x40 ) return 7;
else if( value | 0x20 ) return 6;
else if( value | 0x10 ) return 5;
else if( value | 0x8 ) return 4;
else if( value | 0x4 ) return 3;
else if( value | 0x2 ) return 2;
else if( value | 0x1 ) return 1;

Ce qui s'est passé le retour de 8 à 31?

OriginalL'auteur user1185840

Vous devez vous connecter pour publier un commentaire.