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

小开

我会把它除以2如果余数为0就是偶数，否则就是奇数。

使用模数(%)使得这很容易。

< p > eg. . 4% 2 = 0因此4是偶数因此5是奇数

小开

最佳答案

使用模(%)运算符检查除以2时是否有余数:

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

一些人批评我上面的回答，说使用 x & 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;
}

然后我用 gcc4.1.3在我的一台机器上编译了5次:

没有优化标志。
和 O
和 O 一起
用氧气
用氧气

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

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

最后，按照标准，模版本是保证，无论整数是正数、负数还是零，都可以正常工作，而不管实现是否表示带符号的整数。按位-和版本不是。是的，我意识到“两个”的补语在某种程度上是无处不在的，所以这不是一个真正的问题。

小开

i % 2 == 0

小开

使用位算术:

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

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

小开

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

小开

一个数字是偶数，如果除以2，余数为0。如果一个数除以2，余数为1，则该数为奇数。

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


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

方法是伟大的！

小开

按位方法取决于整数的内部表示形式。模将工作的任何地方有一个模运算符。例如，有些系统实际上使用底层位进行标记(比如动态语言) ，所以原始的 x & 1在这种情况下实际上不会起作用。

小开

你们太有效率了，你们真正想要的是:

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


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


return odd;
}

重复 isEven。

当然，这对负数不起作用，但随着才华而来的是牺牲..。

小开

这个问题的另一个解决方案 (欢迎小朋友投票)

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

小开

对于切，我几年前和一个同事有过完全相同的争论，答案是没有，它不适用于负数。

C 标准规定负数可以有三种表示方式:

2的补数

1的补数

星座和星等

像这样检查:

isEven = (x & 1);

将为2的补数和符号和大小表示工作，但不为1的补数。

不过，我相信以下方法对所有情况都适用:

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

^{感谢 ffpf 指出，文本框正在吃一切后，我不符合字符！}

小开

一个不错的例子是:

/*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 类型的循环)。在这种情况下，堆栈不应该溢出！

小开

我知道这只是语法上的 Sugar 和 只适用于.net，但是扩展方法呢。

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

现在可以执行以下操作

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

小开

[笑话模式 = “开”]

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

[笑话模式 = “关闭”]

编辑: 向枚举添加了混淆值。

小开

IsOdd (int x){返回 true; }

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

小开

便携式:

i % 2 ? odd : even;

不可携带:

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

小开

为了方便讨论..。
你只需要查看任何给定数字中的最后一个数字，看它是偶数还是奇数。有符号的、无符号的、正面的、负面的——它们在这方面都是一样的。因此，这应该在所有方面都适用:-

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

但这会使代码在将来更难维护。想象一下，您希望将奇数的文本更改为“ is not even”。然后其他人稍后想要找出您所做的更改并执行 svn diff 或类似的操作..。
如果你不是担心便携性，而是担心速度，你可以看看最不重要的部分。如果那个位被设置为1，它是一个奇数，如果它是0，它是一个偶数。在一个小型的 endian 系统上，比如 Intel 的 x86体系结构，它应该是这样的:-

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

小开

如果希望高效，请使用位运算符(x & 1) ，但如果希望可读，请使用模2(x % 2)

小开

在“创造性但令人困惑的类别”中，我提供:

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

小开

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

搞定。

小开

我将构建一个整数的奇偶数表(如果奇数为偶数，则为0)(因此可以进行查找: 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]; }

因此，让我们转而求助于偶数和奇数的数学定义。

整数 n 即使存在一个整数 k，使得 n = 2k。

如果存在一个整数 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- 整数表示给定 C 编译中 int的可能值。(注意，C- 整数是整数的子集。)

现在，人们可能会担心，对于给定的 C- 整数 n，对应的整数 k 可能不存在于 C- 整数中。但是只要稍加证明，就可以证明对于所有整数 n，| n | < = | 2n | (*) ，其中 | n | 是“ n，如果 n 是正数，否则-n”。换句话说，对于整数中的所有 n，至少有以下一种情况(确切地说是情况(1和2)或情况(3和4) ，但我不会在这里证明它) :

案例1: n < = 2n。

案例2:-n < = -2 n。

案例3:-n < = 2n。

案例4: n < = -2 n。

现在取2k = n (如果 n 是偶数，这样的 k 确实存在，但我不会在这里证明。如果 n 不是偶数，那么 even中的循环无论如何都不会提前返回，所以没关系。)但是这意味着如果 n 不是0的话 k < n (*) ，并且事实上(这里也没有证明) ，对于所有的 m，整数中的 z，2m = z 意味着 z 不等于 m，给定 m 不等于0。在 n 为0的情况下，2 * 0 = 0，所以0是偶数(如果 n = 0，那么0是 C- 整数，因为在函数 even中 n 是 C- 整数，所以 k = 0是 C- 整数)。因此，如果 n 是偶数，则 C 整数中的 k 存在于 C 整数中的 n。

一个类似的论证表明，如果 n 是奇数，那么在 C- 整数中存在一个 k，使得 n = 2k + 1。

因此，这里介绍的函数 even和 odd将适用于所有的 C 整数。

小开

这里有一个答案 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(); }

小开

阅读这个相当有趣的讨论，我记得我有一个真实的、时间敏感的函数，它在主循环中测试奇数和偶数。它是一个整数幂函数，发布在 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环境监察及审核手册

5.850%

对于那些认为理论或汇编语言列表可以解决这类争论的人来说，这应该是一个警示故事。天地之间有很多东西 Horatio 比你的哲学所梦想的还要多。

小开

为了给那些在我们的研究中没有做很多布尔代数的人更多的关于位算子方法的阐述，这里有一个解释。可能对 OP 没有多大用处，但是我想弄清楚为什么 NUMBER & 1可以工作。

请注意，如有人回答以上，负数的方式表示可以停止这个方法的工作。事实上，它甚至还可以打破模运算符方法，因为每种语言在处理负操作数的方式上都有所不同。

但是，如果您知道 NUMBER 将始终为正，则此方法可以很好地工作。

正如上面图尼指出的那样，只有二进制(和二进制)中的最后一个数字才是重要的。

布尔逻辑和门规定，两个输入必须是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)它将返回0000001，= 1意味着数字是奇数。或者0000000 = 0，表示数字是偶数。

例如

奇怪吗？

1 & 1 =

0000001 &

0000001 =

0000001 < ー奇数

2 & 1 =

0000010 &

0000001 =

0000000 < ー偶数

54 & 1 =

0000001 &

00110110 =

0000000 < ー偶数

这就是为什么这种方法有效:

if(number & 1){ //Number is odd } else { //Number is even }

抱歉，如果这是多余的。

小开

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

例如:

a = 10101011 ----------------- a>>1 --> 01010101 a<<1 --> 10101010 b = 10011100 ----------------- b>>1 --> 01001110 b<<1 --> 10011100

小开

正如一些人所说，有很多方法可以做到这一点。根据本网站，最快的方法是模运算符:

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

然而，下面是作者的一些被标记的其他代码，它的运算速度比上面的公模运算慢:

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

有多少人甚至知道数学系统 DivRem方法，或者他们为什么要使用它？

小开

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

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

我们只需要检查任意数字的整除性，为了检查整除性，我们使用 %运算符

使用 if else 检查偶数

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

使用 if else 检查偶数或奇数的 C 程序

使用条件/三元运算符

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

C 程序用条件运算符检查偶数或奇数.

使用按位运算符

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

小开

零号奇偶校验 | 零 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

小开

模运算符“%”可用于检查数字是奇数还是偶数。也就是一个数除以2，如果余数为0，那么它就是一个偶数，否则它就是一个奇数。< br >

#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’&’，如果答案是1，那么它的其他值就是奇数。也就是说我们必须检查二进制数字 n 的最后一位，如果最后一位是0，那么 n 就是奇数。

例如: 假设 N = 15，在二进制中 N = 1111，现在我们用1与它 AND

1111 0001 &----- 0001
因为结果是1，所以 N = 15是奇数同样，假设 N = 8，在二进制 N = 1000中，现在我们用1
AND 它
1000 0001 &----- 0000

因为结果是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; }

小开

这是与@RocketRoy 关于他的回答讨论的后续内容，但是对于任何想要比较这些结果的人来说，它可能是有用的。

从我所看到的来看，Roy 的方法((0xFFFFFFFF == (x | 0xFFFFFFFE))并没有像 mod方法那样完全优化到 x & 1，但是在实践中运行时间应该在所有情况下都是相等的。

因此，首先我使用编译器资源管理器比较了编译后的输出:

测试功能:

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

CLang 3.9.0 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

海湾合作委员会6.2-O3:

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

归根结底，它意识到这三种情况在功能上是相等的。然而，Roy 的方法在 GCC 中没有优化，所以 YMMV。

它与 Visual Studio 类似; 在检查 X64(VS2015)反汇编版本中的这三个函数时，我可以看到，对于“ mod”和“ and”的情况，比较部分是相等的，对于 Roy 的“ or”情况，比较部分稍大一些:

// 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)

但是，在运行一个实际的基准测试来比较这三个选项(普通的 mod、按位或按位和)之后，结果是完全相同的(同样，Visual Studio 2005 x86/x64，发布版本，没有附加调试器)。

发布组件使用 test指令的 and和 mod案例，而罗伊的案例使用的 cmp eax,0FFFFFFFFh方法，但它是大量展开和优化，所以在实践中没有差异。

运行20次后的结果(i73610QM，Windows 10电源计划设置为 High Performance) :

[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 上测试过(检查 #if LINUX条件的 get_time定义，如果需要的话实现它，从这个答案中获取)。

#include <stdio.h> #if LINUX #include <sys/time.h> #include <sys/resource.h> double get_time() { struct timeval t; struct timezone tzp; gettimeofday(&t, &tzp); return t.tv_sec + t.tv_usec*1e-6; } #else #include <windows.h> double get_time() { LARGE_INTEGER t, f; QueryPerformanceCounter(&t); QueryPerformanceFrequency(&f); return (double)t.QuadPart / (double)f.QuadPart * 1000.0; } #endif #define NUM_ITERATIONS (1000 * 1000 * 1000) // using a macro to avoid function call overhead #define Benchmark(accumulator, name, operation) { \ double startTime = get_time(); \ double dummySum = 0.0, elapsed; \ int x; \ for (x = 0; x < NUM_ITERATIONS; x++) { \ if (operation) dummySum += x; \ } \ elapsed = get_time() - startTime; \ accumulator += elapsed; \ if (dummySum > 2000) \ printf("[Test: %-12s] %0.2f ms\r\n", name, elapsed); \ } void DumpAverage(char *test, double totalTime, double reference) { printf("[Test: %-12s] AVERAGE TIME: %0.2f ms (Relative diff.: %+6.3f%%)\r\n", test, totalTime, (totalTime - reference) / reference * 100.0); } int main(void) { int repeats = 20; double runningTimes[3] = { 0 }; int k; for (k = 0; k < repeats; k++) { printf("Run %d of %d...\r\n", k + 1, repeats); Benchmark(runningTimes[0], "Plain mod 2", (x % 2)); Benchmark(runningTimes[1], "Bitwise or", (0xFFFFFFFF == (x | 0xFFFFFFFE))); Benchmark(runningTimes[2], "Bitwise and", (x & 1)); } { double reference = runningTimes[0] / repeats; printf("\r\n"); DumpAverage("Plain mod 2", runningTimes[0] / repeats, reference); DumpAverage("Bitwise or", runningTimes[1] / repeats, reference); DumpAverage("Bitwise and", runningTimes[2] / repeats, reference); } getchar(); return 0; }

小开

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

小开

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

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

代码检查整数的最后一位是否是 Binary 中的 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。

如果是1 < br > ，则 & 位 AND 操作符检查返回行中最右边的位

就当是真假吧
当我们将 N和 1进行比较时，意味着二进制中的 0001(零的数量并不重要) 然后让我们假设我们有一个大小为1字节的整数 N
它将由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就是 True。

如果我想在最右边之前检查这个位呢？

只需将 n & 1改为 n & 2，其中2在二进制中表示 0010，以此类推。
如果您是位操作的初学者，我建议使用十六进制表示法 return n & 1; > return n & 0x01;

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

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

解释

就当是真假吧

如果我想在最右边之前检查这个位呢？

+ 66% 更快 > `!(i%2) / i%2 == 0`