[C] 整数が偶数か奇数かをチェックするには?



Answers

あなたたちは効率的すぎるwaaaaaaaayです。 あなたが本当に欲しいのは次のとおりです:

public boolean isOdd(int num) {
  int i = 0;
  boolean odd = false;

  while (i != num) {
    odd = !odd;
    i = i + 1;
  }

  return odd;
}

isEvenために繰り返します。

もちろん、それは負の数では機能しません。 しかし輝きは犠牲になる...

Question

与えられた数字がCで偶数か奇数かどうかをどうやって調べることができますか?




+66% faster > !(i%2) / i%2 == 0

int isOdd(int n)
{
    return n & 1;
}

The code checks the last bit of the integer if it's 1 in Binary

説明

Binary  :   Decimal
-------------------
0000    =   0
0001    =   1
0010    =   2
0011    =   3
0100    =   4
0101    =   5
0110    =   6
0111    =   7
1000    =   8
1001    =   9
and so on...

Notice the rightmost bit is always 1 for Odd numbers.

the & bitwise AND operator checks the rightmost bit in our return line if it's 1

Think of it as true & false

When we compare n with 1 which means 0001 in binary (number of zeros doesn't matter).
then let's just Imagine that we have the integer n with a size of 1 byte.

It'd be represented by 8-bit / 8-binary digits.

If the int n was 7 and we compare it with 1 , It's like

7 (1-byte int)|    0  0  0  0    0  1  1  1
       &
1 (1-byte int)|    0  0  0  0    0  0  0  1
********************************************
Result        |    F  F  F  F    F  F  F  T

Which F stands for false and T for true.

It compares only the rightmost bit if they're both true. So, automagically 7 & 1 is T rue.

What if I want to check the bit before the rightmost?

単に変更n & 1n & 2表す2 0010ようにバイナリにして。

初心者であれば16進表記を使うことをお勧めします
return n & 1;>>return n & 0x01;




私たちの研究の間に多くのブール代数をしなかった私たちのためのビットごとの演算子メソッドについてもっと詳しく説明するために、ここでは説明します。 多分OPにはあまり役に立たないでしょうが、なぜNUMBER&1が動作するのかを明確にする気がしました。

上の回答者のように注意してください、負の数が表される方法は、このメソッドの動作を停止することができます。 実際には、各言語が負のオペランドを扱う方法が異なる可能性があるため、モジュロ演算子メソッドを破ることさえできます。

しかし、NUMBERが常に正であることが分かっているなら、これはうまくいきます。

上のTooonyは、バイナリ(および拒否)の最後の桁だけが重要であるという点を立証しました。

ブール論理ANDゲートは、1が返されるためには両方の入力が1(または高電圧)でなければならないことを指示する。

1&0 = 0である。

0&1 = 0である。

0&0 = 0。

1&1 = 1である。

任意の数値をバイナリとして表すと(ここでは8ビット表現を使用しています)、奇数は最後に1を、偶数には0をとります。

例えば:

1 = 00000001

2 = 00000010

3 = 00000011

4 = 00000100

あなたが任意の数を取って、ビット単位のAND(&in java)を1で使用すると、00000001、= 1が返され、数字が奇数であることを意味します。 または00000000 = 0で、数字が偶数であることを意味します。

例えば

奇妙ですか?

1&1 =

00000001&

00000001 =

00000001 < - Odd

2&1 =

00000010&

00000001 =

00000000 < - 均一

54&1 =

00000001&

00110110 =

00000000 < - 均一

これがこの理由です:

if(number & 1){

   //Number is odd

} else {

   //Number is even
}

これは冗長な場合は申し訳ありません。




私はこれが文法的な砂糖であり、.netにのみ適用可能だが、拡張メソッドについては何かを知っている...

public static class RudiGroblerExtensions
{
    public static bool IsOdd(this int i)
    {
        return ((i % 2) != 0);
    }
}

今すぐあなたは次のことを行うことができます

int i = 5;
if (i.IsOdd())
{
    // Do something...
}



これを試してください: return (((a>>1)<<1) == a)

例:

a     =  10101011
-----------------
a>>1 --> 01010101
a<<1 --> 10101010

b     =  10011100
-----------------
b>>1 --> 01001110
b<<1 --> 10011100



ビット単位の方法は、整数の内部表現に依存します。 モジュロはモジュロ演算子があればどこでも動作します。 たとえば、実際には、動的言語のようなタグ付けに低レベルのビットを使用するシステムがあるため、未処理のx&1は実際には動作しません。




[ジョークモード= "オン"]

public enum Evenness
{
  Unknown = 0,
  Even = 1,
  Odd = 2
}

public static Evenness AnalyzeEvenness(object o)
{

  if (o == null)
    return Evenness.Unknown;

  string foo = o.ToString();

  if (String.IsNullOrEmpty(foo))
    return Evenness.Unknown;

  char bar = foo[foo.Length - 1];

  switch (bar)
  {
     case '0':
     case '2':
     case '4':
     case '6':
     case '8':
       return Evenness.Even;
     case '1':
     case '3':
     case '5':
     case '7':
     case '9':
       return Evenness.Odd;
     default:
       return Evenness.Unknown;
  }
}

[ジョークモード= "オフ"]

EDIT:enumに混乱する値を追加しました。




ポータブル:

i % 2 ? odd : even;

ポータブルでない:

i & 1 ? odd : even;

i << (BITS_PER_INT - 1) ? odd : even;



問題のもう一つの解決策
(子供たちは投票に参加できます)

bool isEven(unsigned int x)
{
  unsigned int half1 = 0, half2 = 0;
  while (x)
  {
     if (x) { half1++; x--; }
     if (x) { half2++; x--; }

  }
  return half1 == half2;
}



いいところは:

/*forward declaration, C compiles in one pass*/
bool isOdd(unsigned int n);

bool isEven(unsigned int n)
{
  if (n == 0) 
    return true ;  // I know 0 is even
  else
    return isOdd(n-1) ; // n is even if n-1 is odd
}

bool isOdd(unsigned int n)
{
  if (n == 0)
    return false ;
  else
    return isEven(n-1) ; // n is odd if n-1 is even
}

このメソッドは、2つの関数を含む末尾再帰を使用することに注意してください。 コンパイラがSchemeコンパイラのような末尾再帰をサポートしている場合、効率的に実装できます(while / untilループの種類に変わります)。 この場合、スタックはオーバーフローすべきではありません!




ここでは、Javaの答えです:

public static boolean isEven (Integer Number) {
    Pattern number = Pattern.compile("^.*?(?:[02]|8|(?:6|4))$");
    String num = Number.toString(Number);
    Boolean numbr = new Boolean(number.matcher(num).matches());
    return numbr.booleanValue();
}



// C#
bool isEven = ((i % 2) == 0);



If you want to be efficient, use bitwise operators ( x & 1 ), but if you want to be readable use modulo 2 ( x % 2 )




I execute this code for ODD & EVEN:

#include <stdio.h>
int main()
{
    int number;
    printf("Enter an integer: ");
    scanf("%d", &number);

    if(number % 2 == 0)
        printf("%d is even.", number);
    else
        printf("%d is odd.", number);
}



i % 2 == 0





Links