Как проверить, является ли целое число четным или нечетным, используя побитовые операторы

Question

Как проверить, является ли целое число четным или нечетным, используя побитовые операторы

Answer 1

Подумайте, что значит «четный» и «нечетный» в терминах «бит».Поскольку двоичные целочисленные данные хранятся с битами, указывающими кратные 2, бит самого младшего порядка будет соответствовать 2 ⁰ , что, конечно, равно 1, тогда как все остальные другие биты будут соответствоватькратно 2 (2 ¹ = 2, 2 ² = 4 и т. д.).Благодарность ASCII art:

NNNNNNNN
||||||||
|||||||+−− bit 0, value =   1 (2<sup>0</sup>)
||||||+−−− bit 1, value =   2 (2<sup>1</sup>)
|||||+−−−− bit 2, value =   4 (2<sup>2</sup>)
||||+−−−−− bit 3, value =   8 (2<sup>3</sup>)
|||+−−−−−− bit 4, value =  16 (2<sup>4</sup>)
||+−−−−−−− bit 5, value =  32 (2<sup>5</sup>)
|+−−−−−−−− bit 6, value =  64 (2<sup>6</sup>)
+−−−−−−−−− bit 7 (highest order bit), value = 128 (2<sup>7</sup>) for unsigned numbers,
                 value = -128 (-2<sup>7</sup>) for signed numbers (2's complement)

Я показал только 8 бит там, но вы поняли.

Таким образом, вы можете определить, является ли целое число четным или нечетным, глядя только намладший бит: если он установлен, число нечетное.Если нет, то даже.Вы не заботитесь о других битах, потому что все они обозначают кратные 2, и поэтому они не могут сделать значение нечетным.

Способ , который вы смотрите на этот бит, заключается в использованииоператор AND вашего языка.В C и многих других языках, синтаксически полученных из B (да, B), этот оператор равен &.В бейсиках это обычно And.Вы берете свое целое число, И это с 1 (который является числом только с установленным битом самого низкого порядка), и если результат не равен 0, бит был установлен.

Я намеренно не на самом деле даю код здесь, не только потому, что я не знаю, какой язык вы используете, но и потому, что вы отметили вопрос «домашнее задание».: -)

Answer 2

На С (и на большинстве С-подобных языков)

if (number & 1) {
  // It's odd 
}

Answer 3

if (number & 1)
    number is odd
else // (number & 1) == 0
    number is even

Например, давайте возьмем целое число 25, что нечетно. В двоичном 25 это 00011001. Обратите внимание, что младший значащий бит b0 равен 1.

00011001    
00000001   (00000001 is 1 in binary)
       &
--------
00000001

Answer 4

Просто сноска к ответу Джима.

В C #, в отличие от C, поразрядное И возвращает полученное число, поэтому вы хотите написать:

if ((number & 1) == 1) {
   // It's odd
}

Answer 5

if(x & 1)                               // '&' is a bit-wise AND operator
    printf("%d is ODD\n", x);
else
    printf("%d is EVEN\n", x);

Примеры:

    For 9:

      9 ->        1 0 0 1
      1 ->     &  0 0 0 1
      -------------------
      result->    0 0 0 1

Итак, 9 И 1 дает нам 1, так как самый правый бит каждого нечетного числа равен 1.

     For 14:

       14 ->      1 1 1 0
       1  ->   &  0 0 0 1
       ------------------
       result->   0 0 0 0

Так 14 И 1дает нам 0, так как самый правый бит каждого четного числа равен 0.

Answer 6

Вы можете сделать это просто используя побитовый оператор AND &.

if(num & 1)
{
    //I am odd number.
}

Подробнее здесь - Проверка четного нечетного с помощью битового оператора в C

Answer 7

#include <iostream>
#include <algorithm>
#include <vector>

void BitConvert(int num, std::vector<int> &array){
    while (num > 0){
        array.push_back(num % 2);
        num = num / 2;
    }
}

void CheckEven(int num){
    std::vector<int> array;
    BitConvert(num, array);
    if (array[0] == 0)
        std::cout << "Number is even";
    else
        std::cout << "Number is odd";
}

int main(){
    int num;
    std::cout << "Enter a number:";
    std::cin >> num;

    CheckEven(num);
    std::cout << std::endl;

    return 0;
}

Answer 8

Также в Java вам придется использовать if((number&1)==1){//then odd}, потому что в языках, подобных Java и C #, int не приводится к boolean. Вам придется использовать реляционные операторы для возврата boolean значение, т.е. true и false в отличие от языков, подобных C и C ++, которые обрабатывают ненулевое значение как true.