Comment convertir un nombre négatif en positif par | = Opérateur en C #?

Nous savons tous que le bit le plus élevé d'un Int32 définit son signe. 1 indique que c'est négatif et 0 que c'est positif (éventuellement inversé). Puis-je convertir un nombre négatif à positif en changeant son plus haut bits?

J'ai essayé de le faire en utilisant le code suivant:

i |= Int32.MaxValue;

Mais ça ne fonctionne pas.

source d'informationauteur Domi.Zhang

  1. 21

    Si vous êtes à la recherche d'un bit à bit façon de le faire (comme une question d'entrevue, etc), vous avez besoin pour réduire à néant le nombre (bit à bit) et ajouter 1:

    int x = -13;
int positiveX = ~x + 1;

    Cela permettra d'inverser le signe si il est positif ou négatif. Une petite mise en garde, cela ne fonctionnera PAS si x est de type int.MinValue, bien que, depuis la plage négative est un de plus que la plage positive.

    Bien sûr, dans le monde réel de code que je venais d'utiliser Math.Abs() comme déjà mentionné...

  2. 34

    Pourquoi ne pas simplement utiliser le Math.Abs(yourInt) méthode? Je ne vois pas la nécessité d'utiliser des opérations bit à bit ici.

  3. 2

    Le bit définit c'est un signe, c'est vrai. Mais ce n'est pas tout:

    Pour convertir une valeur positive à une valeur négative, vous devez:

    1. Nier le numéro (par exemple, +1, qui est 0000 0001 en binaire, se transforme en 1111 1110)
    2. Ajouter 1 (1111 1110 se transforme en 1111 1111qui est de -1)

    Ce processus est connu comme En complément à deux.

    En inversant le processus est aussi simple:

    1. Soustraire 1 (par exemple, -1, 1111 1111 se transforme en 1111 1110)
    2. Nier le nombre (1111 1110 se transforme en 0000 0001qui est de +1).

    Comme vous pouvez le voir, cette opération est impossible à mettre en œuvre à l'aide de la binaire ou-opérateur. Vous avez besoin de la bit-à-bit-pas et ajouter/soustraire.

    Les exemples ci-dessus utilisent 8 bits entiers, mais le processus fonctionne exactement de la même pour tous les nombres entiers. Les nombres à virgule flottantecependant, n'utilisez qu'un bit de signe.

  4. 1

    J'ai résolu ça en faisant:

    Int a = IntToSolve; //Whatever int you want
b = a < 0 ? a*-1 : a*1 ;

    Ceci vous permettra de sortie positive ints.
    Dans l'autre sens serait:

    Int a = IntToSolve; //Same but from positive to negative
b = a < 0 ? a*1 : a*-1 ;
  5. 0

    Quoi de mal avec Math.Abs(i) si vous voulez aller de l'-ve +ve, ou -1*i si vous voulez aller dans les deux sens?

  6. 0

    Il est impossible avec la |= de l'opérateur. Il ne peut pas annuler bits. Et puisque le bit de signe est défini sur les nombres négatifs, vous ne pouvez pas annuler.

  7. 0

    Votre quête, malheureusement, n'est futile. L'opérateur de bits or sera pas pouvoir arbitraire flip un peu. Vous pouvez ensemble un peu, mais si ce bit est déjà défini, OU ne sera pas capable de l'effacer.

  8. 0

    Vous ne pouvez absolument pas car le négatif est les deux compléments de l'original. Donc, même si il est vrai que dans un nombre négatif le bit de poids fort est à 1 n'est pas assez pour mettre un 1 peu pour obtenir le négatif. Vous devez réduire à zéro tous les bits et un.

  9. 0

    Si vous parlez d'utiliser des opérations bit à bit, il ne fonctionne pas comme ça. Je suppose que vous pensiez que vous auriez flip le bit le plus élevé (le signe du drapeau) pour obtenir le négatif, mais il ne fonctionne pas comme vous l'attendez.

    Le nombre 6 est représenté comme 00000000 00000000 00000000 00000110 en un entier signé 32 bits. Si vous retournez le bit le plus élevé (la signature bits) à 1, vous obtiendrez 10000000 00000000 00000000 00000110qui est -2147483642 en décimal. Pas exactement ce que vous attendiez, j'imagine. C'est parce que les nombres négatifs sont stockés dans "une logique négative", ce qui signifie que 11111111 11111111 11111111 11111111 est -1.

    Si vous retournez tous les bits à une valeur positive xvous obtenez -(x+1). Par exemple:

    00000000 00000000 00000000 00000110 = 6
11111111 11111111 11111111 11111001 = -7

    Vous avez encore d'utiliser une addition (ou une soustraction) pour obtenir le résultat correct, cependant.

  10. 0
    changeTime = changeTime >= 0 ? changeTime : -(changeTime);