Question

如何在C中检查给定数字是偶数还是奇数？

Answer 1

使用模数（％）运算符检查除以2时是否有余数：

if (x % 2) { /* x is odd */ }

有些人批评我上面的答案，说明使用x＆amp; 1是“更快”或“更有效”。我不相信这是事实。

出于好奇，我创建了两个简单的测试用例程序：

/* modulo.c */
#include <stdio.h>

int main(void)
{
    int x;
    for (x = 0; x < 10; x++)
        if (x % 2)
            printf("%d is odd\n", x);
    return 0;
}

/* and.c */
#include <stdio.h>

int main(void)
{
    int x;
    for (x = 0; x < 10; x++)
        if (x & 1)
            printf("%d is odd\n", x);
    return 0;
}

然后我在我的一台机器上用gcc 4.1.3编译了5次不同的时间：

没有优化标志。
使用-O
使用-Os
使用-O2
使用-O3

我检查了每个编译的汇编输出（使用gcc -S），发现在每种情况下，and.c和modulo.c的输出都是相同的（它们都使用了andl $ 1，％eax指令）。我怀疑这是一个“新”功能，我怀疑它可以追溯到古代版本。我也怀疑任何现代（在过去20年制造）非神秘的编译器，商业或开源，缺乏这样的优化。我会测试其他编译器，但目前我还没有。

如果其他人愿意测试其他编译器和/或平台目标，并得到不同的结果，我会非常有兴趣知道。

最后，标准的模数版本保证无论整数是正数，负数还是零，都可以工作，无论实现的有符号整数的表示如何。按位和版本不是。是的，我意识到两个补码有点无处不在，所以这不是一个真正的问题。

Answer 2

你们这些人太有效率了。你真正想要的是：

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

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

  return odd;
}

重复isEven。

当然，这对负数不起作用。但凭借光彩而牺牲......

Answer 3

使用位算术：

if((x & 1) == 0)
    printf("EVEN!\n");
else
    printf("ODD!\n");

这比使用除法或模数更快。

Answer 4

[笑话模式=“开”]

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;
  }
}

[笑话模式=“关闭”]

编辑：为枚举添加了令人困惑的值。

Answer 5

回应ffpf - 几年前我和一位同事的论点完全相同，答案是不，它不适用于负数。

C标准规定负数可用3种方式表示：

2的补充
1的补充
符号和幅度

像这样检查：

isEven = (x & 1);

将用于2的补码和符号和幅度表示，但不适用于1的补码。

但是，我相信以下内容适用于所有情况：

isEven = (x & 1) ^ ((-1 & 1) | ((x < 0) ? 0 : 1)));

^{感谢ffpf指出文字框在我的字符不足之后正在吃掉所有东西！}

Answer 6

一个不错的是：

/*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
}

请注意，此方法使用涉及两个函数的尾递归。如果你的编译器像Scheme编译器一样支持尾递归，它可以有效地实现（变成while / until循环）。在这种情况下，堆栈不应该溢出！

Answer 7

当数除以2时，余数为0时，数字为0.如果除以2，则余数为1，则数字为奇数。

// Java
public static boolean isOdd(int num){
    return num % 2 != 0;
}

/* C */
int isOdd(int num){
    return num % 2;
}

方法很棒！

Answer 8

i % 2 == 0

Answer 9

我要说它除以2，如果有0余数，那就是偶数，否则它很奇怪。

使用模数（％）可以轻松实现。

例如。 4％2 = 0因此4是偶数 5％2 = 1因此5是奇数

Answer 10

问题的另一个解决方案
（欢迎儿童投票）

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

  }
  return half1 == half2;
}

Answer 11

我会建立一个奇偶校验表（0，如果是偶数1，如果奇数）整数（因此可以进行查找：D），但gcc不会让我制作这样大小的数组：

typedef unsigned int uint;

char parity_uint [UINT_MAX];
char parity_sint_shifted [((uint) INT_MAX) + ((uint) abs (INT_MIN))];
char* parity_sint = parity_sint_shifted - INT_MIN;

void build_parity_tables () {
    char parity = 0;
    unsigned int ui;
    for (ui = 1; ui <= UINT_MAX; ++ui) {
        parity_uint [ui - 1] = parity;
        parity = !parity;
    }
    parity = 0;
    int si;
    for (si = 1; si <= INT_MAX; ++si) {
        parity_sint [si - 1] = parity;
        parity = !parity;
    }
    parity = 1;
    for (si = -1; si >= INT_MIN; --si) {
        parity_sint [si] = parity;
        parity = !parity;
    }
}

char uparity (unsigned int n) {
    if (n == 0) {
        return 0;
    }
    return parity_uint [n - 1];
}

char sparity (int n) {
    if (n == 0) {
        return 0;
    }
    if (n < 0) {
        ++n;
    }
    return parity_sint [n - 1];
}

所以让我们改为使用偶数和奇数的数学定义。

如果存在整数k使得n = 2k，则整数n是偶数。

如果存在整数k使得n = 2k + 1，则整数n是奇数。

以下是代码：

char even (int n) {
    int k;
    for (k = INT_MIN; k <= INT_MAX; ++k) {
        if (n == 2 * k) {
            return 1;
        }
    }
    return 0;
}

char odd (int n) {
    int k;
    for (k = INT_MIN; k <= INT_MAX; ++k) {
        if (n == 2 * k + 1) {
            return 1;
        }
    }
    return 0;
}

让C-integers表示给定C编译中int的可能值。（注意，C-integers是整数的子集。）

现在有人可能会担心，对于C整数中的给定n，相应的整数k可能不存在于C整数中。但是通过一点证明，可以证明对于所有整数n，| n | ＆lt; = | 2n | （*），其中| n |如果n为正，则为“n，否则为-n”。换句话说，对于所有n个整数，至少有以下一个成立（事实上恰好是情况（1和2）或情况（3和4），但我不会在这里证明）：

案例1：n＆lt; = 2n。

案例2：-n＆lt; = -2n。

案例3：-n＆lt; = 2n。

案例4：n＆lt; = -2n。

现在取2k = n。（如果n是偶数，那么确实存在，但我不会在这里证明。如果n不均匀，那么even中的循环无法提前返回，所以没关系。）但这意味着k＆lt; n如果n不是0乘（*）和事实（这里再次证明）对于所有m，整数中的z，2m = z意味着z不等于m给定m不是0.在n为0的情况下，2 * 0 = 0所以0是偶数我们完成（如果n = 0则0是C-整数，因为n在函数even中是C-整数，因此k = 0是C-整数）。因此，如果n是偶数，则C-整数中的n存在于n中的n。

类似的论证表明，如果n为奇数，则在C整数中存在k，使得n = 2k + 1.

因此，此处提供的函数even和odd将适用于所有C整数。

Answer 12

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

Answer 13

正如有些人发布的那样，有很多方法可以做到这一点。根据{{3}}，最快的方法是模数运算符：

if (x % 2 == 0)
               total += 1; //even number
        else
               total -= 1; //odd number

但是，作者的一些this website运行速度比上面的常见模数运算慢：

if ((x & 1) == 0)
               total += 1; //even number
        else
               total -= 1; //odd number

System.Math.DivRem((long)x, (long)2, out outvalue);
        if ( outvalue == 0)
               total += 1; //even number
        else
               total -= 1; //odd number

if (((x / 2) * 2) == x)
               total += 1; //even number
        else
               total -= 1; //odd number

if (((x >> 1) << 1) == x)
               total += 1; //even number
        else
               total -= 1; //odd number

        while (index > 1)
               index -= 2;
        if (index == 0)
               total += 1; //even number
        else
               total -= 1; //odd number

tempstr = x.ToString();
        index = tempstr.Length - 1;
        //this assumes base 10
        if (tempstr[index] == '0' || tempstr[index] == '2' || tempstr[index] == '4' || tempstr[index] == '6' || tempstr[index] == '8')
               total += 1; //even number
        else
               total -= 1; //odd number

有多少人甚至知道other code that was bench marked方法或为什么要使用它？

Answer 14

这是@RocketRoy关于his answer的讨论的后续行动，但对于想要比较这些结果的人来说，它可能会有用。

tl; dr 从我所看到的，Roy的方法（(0xFFFFFFFF == (x | 0xFFFFFFFE)）并未完全优化为x & 1 {{1}方法，但在实践中，运行时间应该在所有情况下均等。

所以，首先我使用Compiler Explorer比较编译后的输出：

测试的功能：

mod

CLang 3.9.0 with -O3：

int isOdd_mod(unsigned x) {
    return (x % 2);
}

int isOdd_and(unsigned x) {
    return (x & 1);
}

int isOdd_or(unsigned x) {
    return (0xFFFFFFFF == (x | 0xFFFFFFFE));
}

GCC 6.2 with -O3：

isOdd_mod(unsigned int):                          # @isOdd_mod(unsigned int)
        and     edi, 1
        mov     eax, edi
        ret

isOdd_and(unsigned int):                          # @isOdd_and(unsigned int)
        and     edi, 1
        mov     eax, edi
        ret

isOdd_or(unsigned int):                           # @isOdd_or(unsigned int)
        and     edi, 1
        mov     eax, edi
        ret

向CLang致敬，它意识到这三种情况在功能上是相同的。然而，Roy的方法在GCC中没有得到优化，所以YMMV。

与Visual Studio类似;为这三个功能检查拆卸释放x64（VS2015），我可以看到比较部分对于＆＃34; mod＆＃34;和＆＃34;和＆＃34;案件，罗伊的＆＃34;或者＃34;情况下：

isOdd_mod(unsigned int):
        mov     eax, edi
        and     eax, 1
        ret

isOdd_and(unsigned int):
        mov     eax, edi
        and     eax, 1
        ret

isOdd_or(unsigned int):
        or      edi, -2
        xor     eax, eax
        cmp     edi, -1
        sete    al
        ret

但是，在运行实际基准测试来比较这三个选项（普通模式，按位或按位和）之后，结果完全相同（同样，Visual Studio 2005 x86 / x64，发布版本，未附加调试器）。

发布程序集使用// x % 2 test bl,1 je (some address) // x & 1 test bl,1 je (some address) // Roy's bitwise or mov eax,ebx or eax,0FFFFFFFEh cmp eax,0FFFFFFFFh jne (some address)和test案例的and指令，而Roy的案例使用mod方法，但它很重要展开和优化，以便在实践中没有区别。

20次运行后的结果（i7 3610QM，Windows 10电源计划设置为高性能）：

[Test: Plain mod 2 ] AVERAGE TIME: 689.29 ms (Relative diff.: +0.000%)
[Test: Bitwise or  ] AVERAGE TIME: 689.63 ms (Relative diff.: +0.048%)
[Test: Bitwise and ] AVERAGE TIME: 687.80 ms (Relative diff.: -0.217%)

这些选项之间的差异小于0.3％，因此在所有情况下组装都是相同的。

以下是代码，如果有人想尝试，请注意我只在Windows上测试过它（检查cmp eax,0FFFFFFFFh有条件的#if LINUX定义并在需要时实现它，取自{{ 3}}）。

get_time

Answer 15

试试这个：return (((a>>1)<<1) == a)

示例：

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

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

Answer 16

阅读这个相当有趣的讨论，我记得我有一个真实的，时间敏感的功能，测试主循环内的奇数和偶数。它是一个整数幂函数，发布在StackOverflow的其他地方，如下所示。基准测试非常令人惊讶。至少在这个真实世界的函数中，模数较慢，并且显着如此。 获胜者，需要67％的模数时间，是一个或（|）方法，在本页的其他地方无处可寻。

static dbl  IntPow(dbl st0, int x)  {
    UINT OrMask = UINT_MAX -1;
    dbl  st1=1.0;
    if(0==x) return (dbl)1.0;

    while(1 != x)   {
        if (UINT_MAX == (x|OrMask)) {     //  if LSB is 1...    
        //if(x & 1) {
        //if(x % 2) {
            st1 *= st0;
        }    
        x = x >> 1;  // shift x right 1 bit...  
        st0 *= st0;
    }
    return st1 * st0;
}

对于3亿个循环，基准时序如下。

3.962 |和面具方法

4.851＆amp;方法

5.850％接近

对于那些认为理论或汇编语言列表的人来说，解决这些论点，这应该是一个警示性的故事。在你的哲学中，天堂和地球上有更多的东西，霍雷肖。

Answer 17

这是一个答案爪哇：

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();
}

Answer 18

我知道这只是语法糖而且仅适用于.net 但是扩展方法呢......

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

现在您可以执行以下操作

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

Answer 19

在“创意但令人困惑的类别”中，我提供：

int isOdd(int n) { return n ^ n * n ? isOdd(n * n) : n; }

此主题的特定于Microsoft C ++的变体：

__declspec(naked) bool __fastcall isOdd(const int x)
{
    __asm
    {
        mov eax,ecx
        mul eax
        mul eax
        mul eax
        mul eax
        mul eax
        mul eax
        ret
    }
}

Answer 20

IsOdd（int x）{return true; }

正确性证明 - 考虑所有正整数的集合，并假设存在非空的整数非奇数。因为正整数是有序的，所以会有一个最小而不是奇数，这本身就很奇怪，所以很明显这个数字不能在集合中。因此这个集合不能是非空的。重复负整数，除了寻找最大而非奇数。

Answer 21

便携式：

i % 2 ? odd : even;

不可移植：

i & 1 ? odd : even;

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

Answer 22

按位方法取决于整数的内部表示。 Modulo可以在任何模运算符的任何地方工作。例如，某些系统实际上使用低级别位进行标记（如动态语言），因此原始x＆amp;在这种情况下，1实际上不起作用。

Answer 23

int isOdd(int i){
  return(i % 2);
}

进行。

Answer 24

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);
}

Answer 25

为了让我们这些在学习期间没有做多布尔代数的人使用按位运算符方法，这里有一个解释。可能对OP没什么用处，但我觉得要明确为什么NUMBER＆amp; 1作品。

请注意，就像上面有人回答的那样，表示负数的方式可以阻止此方法的工作。实际上，它甚至可以破坏模运算符方法，因为每种语言在处理负操作数方面都有所不同。

但是，如果您知道NUMBER将始终为正，则效果很好。

如上所述Tooony指出，只有二进制（和否定）中的最后一位数字才是重要的。

布尔逻辑AND门指示两个输入必须是1（或高电压），才能返回1。

1＆amp; 0 = 0。

0＆amp; 1 = 0。

0＆amp; 0 = 0。

1＆amp; 1 = 1。

如果您将任何数字表示为二进制（我在此处使用了8位表示），则奇数在末尾有1，偶数为0。

例如：

1 = 00000001

2 = 00000010

3 = 00000011

4 = 00000100

如果您取任何数字并使用按位AND（＆amp;在java中），则它将返回00000001，= 1表示该数字为奇数。或者00000000 = 0，表示数字是偶数。

E.g

奇怪吗？

1＆amp; 1 =

00000001＆amp;

00000001 =

00000001＆lt; - 奇数

2＆amp; 1 =

00000010＆amp;

00000001 =

00000000＆lt; - 偶数

54＆amp; 1 =

00000001＆amp;

00110110 =

00000000＆lt; - 偶数

这就是为什么这样做的原因：

if(number & 1){

   //Number is odd

} else {

   //Number is even
}

很抱歉，如果这是多余的。

Answer 26

Number Zero parity |零http://tinyurl.com/oexhr3k

Python代码序列。

# defining function for number parity check
def parity(number):
    """Parity check function"""
    # if number is 0 (zero) return 'Zero neither ODD nor EVEN',
    # otherwise number&1, checking last bit, if 0, then EVEN, 
    # if 1, then ODD.
    return (number == 0 and 'Zero neither ODD nor EVEN') \
            or (number&1 and 'ODD' or 'EVEN')

# cycle trough numbers from 0 to 13 
for number in range(0, 14):
    print "{0:>4} : {0:08b} : {1:}".format(number, parity(number))

<强>输出：

   0 : 00000000 : Zero neither ODD nor EVEN
   1 : 00000001 : ODD
   2 : 00000010 : EVEN
   3 : 00000011 : ODD
   4 : 00000100 : EVEN
   5 : 00000101 : ODD
   6 : 00000110 : EVEN
   7 : 00000111 : ODD
   8 : 00001000 : EVEN
   9 : 00001001 : ODD
  10 : 00001010 : EVEN
  11 : 00001011 : ODD
  12 : 00001100 : EVEN
  13 : 00001101 : ODD

Answer 27

+66％更快＆gt; `!(i%2) / i%2 == 0`

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

如果二进制

中的 1 ，则代码会检查整数的最后一位

说明

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...

注意对于奇数数字，最右边的位始终为1。

＆amp; 按位AND运算符检查返回行中最右边的位，如果它是1

认为它是真实的＆amp;假

当我们将 n 与 1 进行比较时，这意味着二进制中的0001（零的数量并不重要）。
然后让我们想象一下，我们有一个整数 n ，大小为1个字节。

它由8位/ 8位二进制数字表示。

如果int n 7 ，我们将其与 1 进行比较，就像

一样

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

F 代表false， T 代表true。

只有最右边的位才比较，如果它们都为真。因此，自动7 & 1 T rue。

如果我想检查最右边的位，该怎么办？

只需将n & 1更改为n & 2，其中2表示二进制中的0010，依此类推。

如果您是按位操作的初学者，我建议使用十六进制表示法 return n & 1;＆gt;＆gt; return n & 0x01;。

Answer 28

检查偶数或奇数是一项简单的任务。

我们知道任何可被2整除的数字都是偶数奇数。

我们只需检查任何数字的可分性，并检查可分性，我们使用%运算符

使用if else检查奇数

if(num%2 ==0)  
{
    printf("Even");
}
else
{
    printf("Odd");
}

C program to check even or odd using if else

使用条件/三元运算符

(num%2 ==0) printf("Even") : printf("Odd");

C program to check even or odd using conditional operator。

使用按位运算符

if(num & 1)  
{
    printf("Odd");
}
else 
{
    printf("Even");
}

Answer 29

如果您想要高效，请使用按位运算符（x & 1），但如果您想要可读，请使用模2（x % 2）

Answer 30

为了讨论......

您只需要查看任何给定数字的最后一位数字，看它是偶数还是奇数。签名，无签名，积极，消极 - 他们对此都是一样的。所以这应该全面运作： -

void tellMeIfItIsAnOddNumberPlease(int iToTest){
  int iLastDigit;
  iLastDigit = iToTest - (iToTest / 10 * 10);
  if (iLastDigit % 2 == 0){
    printf("The number %d is even!\n", iToTest);
  } else {
    printf("The number %d is odd!\n", iToTest);
  }
}

这里的关键是在第三行代码中，除法运算符执行整数除法，因此结果缺少结果的小数部分。因此，例如222/10将结果为22。然后将它再次乘以10并且你有220.从原来的222减去那个你最终得到2，其中魔术与原始数字中的最后一个数字相同。 ;-) 括号用于提醒我们计算的顺序。首先进行除法和乘法，然后从原始数字中减去结果。我们可以将它们排除在外，因为除法和乘法的优先级高于减法，但这给了我们“更易读”的代码。

如果我们愿意的话，我们可以完全不可读。对于现代编译器来说，它没有任何区别： -

printf("%d%s\n",iToTest,0==(iToTest-iToTest/10*10)%2?" is even":" is odd");

但它会使代码在未来更难维护。想象一下，您想将奇数的文本更改为“不均匀”。然后其他人想要找出你所做的改变并执行svn diff或类似的......

如果您不担心可移植性而更关心速度，您可以查看最不重要的位。如果该位设置为1则为奇数，如果为0，则为偶数。在像英特尔的x86架构这样的小端系统上，它将是这样的： -

if (iToTest & 1) {
  // Even
} else {
  // Odd
}

Answer 31

模数运算符＆＃39;％＆＃39;可以用来检查一个数字是奇数还是偶数。那就是当一个数字除以2时，如果余数为0则为偶数，否则为奇数。

#include <stdio.h>
int main()
{
    int n;//using modulus operator
    scanf("%d",&n);//take input n from STDIN 
    printf("%s",n%2==0?"Even":"Odd");//prints Even/Odd depending on n to STDOUT
    return 0;
}

但是使用比特操作比上述方法快得多，所以如果你拿一个数字并且逻辑地应用AND＆＃39;＆amp;＆＃39;对它来说，如果答案是1，那么它的偶数就是奇数。那基本上我们必须检查二进制数n的最后一位。如果最后一位是0，则n甚至是奇数。

例如：假设N = 15，二进制N = 1111，现在我们将它与1

由于结果为1，因此数字N = 15为奇数。

再次，假设N = 8，二进制N = 1000，现在我们将它与1

由于结果为0，因此数字N = 8为偶数。

#include <stdio.h>

int main()
{
    int n;//using AND operator
    scanf("%d",&n);//take input n from STDIN 
    printf("%s",n&1?"Odd":"Even");//prints Even/Odd depending on n to STDOUT
    return 0;
}

如何检查整数是偶数还是奇数？

31 个答案:

+66％更快＆gt; `!(i%2) / i%2 == 0`

说明

认为它是真实的＆amp;假

如果我想检查最右边的位，该怎么办？

如何检查整数是偶数还是奇数？

31 个答案:

+66％更快＆gt; !(i%2) / i%2 == 0

说明

认为它是真实的＆amp;假

如果我想检查最右边的位，该怎么办？

+66％更快＆gt; `!(i%2) / i%2 == 0`