我用编译语言运行了一个简单的程序，它使用两个简单的循环来计算前几个自然数的阶乘，一个外部循环来跟踪我们正在计算阶乘的数字，而内部循环通过将每个自然数从 1 乘到数字本身。该程序对第一个自然数非常有效，然后大约从第 13 个值开始计算的阶乘显然是错误的。这是由于现代计算机中实现的整数运算，我不明白为什么会出现负值。我不明白为什么，这是我在不同的计算机上测试过的，经过非常少量的阶乘计算后，它总是达到零。当然，如果第 n 个阶乘被评估为 0，
编辑：您可能想知道为什么我使用两个不同的周期而不是只使用一个......我这样做是为了强制计算机从一开始就重新计算每个阶乘，只是为了测试阶乘确实总是 0 并且它是不是偶然的。
这是我的输出：
从 34! 开始，所有阶乘都可以被 2^32 整除。因此，当您的计算机程序以 2^32 为模计算结果时（尽管您没有说明您使用的是哪种编程语言，但很有可能），那么结果始终为 0。
这是一个在 Python 中计算阶乘 mod 2^32 的程序：
def sint(r):
r %= (1 << 32)
return r if r < (1 << 31) else r - (1 << 32)
r = 1
for i in xrange(1, 40):
r *= i
print '%d! = %d mod 2^32' % (i, sint(r))
这给出了这个输出，它与您自己的程序的输出一致：
1! = 1 mod 2^32
2! = 2 mod 2^32
3! = 6 mod 2^32
4! = 24 mod 2^32
5! = 120 mod 2^32
6! = 720 mod 2^32
7! = 5040 mod 2^32
8! = 40320 mod 2^32
9! = 362880 mod 2^32
10! = 3628800 mod 2^32
11! = 39916800 mod 2^32
12! = 479001600 mod 2^32
13! = 1932053504 mod 2^32
14! = 1278945280 mod 2^32
15! = 2004310016 mod 2^32
16! = 2004189184 mod 2^32
17! = -288522240 mod 2^32
18! = -898433024 mod 2^32
19! = 109641728 mod 2^32
20! = -2102132736 mod 2^32
21! = -1195114496 mod 2^32
22! = -522715136 mod 2^32
23! = 862453760 mod 2^32
24! = -775946240 mod 2^32
25! = 2076180480 mod 2^32
26! = -1853882368 mod 2^32
27! = 1484783616 mod 2^32
28! = -1375731712 mod 2^32
29! = -1241513984 mod 2^32
30! = 1409286144 mod 2^32
31! = 738197504 mod 2^32
32! = -2147483648 mod 2^32
33! = -2147483648 mod 2^32
34! = 0 mod 2^32
35! = 0 mod 2^32
36! = 0 mod 2^32
37! = 0 mod 2^32
38! = 0 mod 2^32
39! = 0 mod 2^32
这是这个阶乘范围的精确值的表格，显示了每个阶乘包含多少次方：
1! = 1. Divisible by 2^0
2! = 2. Divisible by 2^1
3! = 6. Divisible by 2^1
4! = 24. Divisible by 2^3
5! = 120. Divisible by 2^3
6! = 720. Divisible by 2^4
7! = 5040. Divisible by 2^4
8! = 40320. Divisible by 2^7
9! = 362880. Divisible by 2^7
10! = 3628800. Divisible by 2^8
11! = 39916800. Divisible by 2^8
12! = 479001600. Divisible by 2^10
13! = 6227020800. Divisible by 2^10
14! = 87178291200. Divisible by 2^11
15! = 1307674368000. Divisible by 2^11
16! = 20922789888000. Divisible by 2^15
17! = 355687428096000. Divisible by 2^15
18! = 6402373705728000. Divisible by 2^16
19! = 121645100408832000. Divisible by 2^16
20! = 2432902008176640000. Divisible by 2^18
21! = 51090942171709440000. Divisible by 2^18
22! = 1124000727777607680000. Divisible by 2^19
23! = 25852016738884976640000. Divisible by 2^19
24! = 620448401733239439360000. Divisible by 2^22
25! = 15511210043330985984000000. Divisible by 2^22
26! = 403291461126605635584000000. Divisible by 2^23
27! = 10888869450418352160768000000. Divisible by 2^23
28! = 304888344611713860501504000000. Divisible by 2^25
29! = 8841761993739701954543616000000. Divisible by 2^25
30! = 265252859812191058636308480000000. Divisible by 2^26
31! = 8222838654177922817725562880000000. Divisible by 2^26
32! = 263130836933693530167218012160000000. Divisible by 2^31
33! = 8683317618811886495518194401280000000. Divisible by 2^31
34! = 295232799039604140847618609643520000000. Divisible by 2^32
35! = 10333147966386144929666651337523200000000. Divisible by 2^32
36! = 371993326789901217467999448150835200000000. Divisible by 2^34
37! = 13763753091226345046315979581580902400000000. Divisible by 2^34
38! = 523022617466601111760007224100074291200000000. Divisible by 2^35
39! = 20397882081197443358640281739902897356800000000. Divisible by 2^35
每个乘法从右边追加零位，直到在某个迭代中，最左边的位由于溢出而被丢弃。实际效果：
int i, x=1;
for (i=1; i <=50; i++) {
x *= i;
for (int i = 31; i >= 0; --i) {
printf("%i",(x >> i) & 1);
}
printf("\n");
}
输出位：
00000000000000000000000000000000 1 000000000000000000000000000000 1 0 00000000000000000000000000000 11 0 0000000000000000000000000000 11 000 00000000000000000000000000 1111 000 0000000000000000000000 101101 0000 0000000000000000000 100111011 0000 0000000000000000 100111011 0000000 0000000000000 101100010011 0000000 0000000000 11011101011111 00000000 000000 100110000100010101 00000000 000 1110010001100111111 0000000000 0 111001100101000110011 0000000000 0 10011000011101100101 00000000000 0 11101110111011101011 00000000000 0 1110111011101011 000000000000000 11101110110011011 000000000000000 1100101001110011 0000000000000000 00000 11010001001 0000000000000000 10000010101101 000000000000000000 10111000110001 000000000000000000 11100000110000000000000000 _ 00 1100111 00000000000000000000000 1101 0000000000000000000000000000 1 0000000000000000000000000000000 000000000000000000000000000000000
请注意，在我们得到零之前 - 我们得到INT_MIN。添加另一个零位 - 丢弃符号位，因此从 INT_MIN 我们得到纯零。