先看一道面試題：
長度為n的數組，由數字1到n組成，其中數字a不出現，數字b出現兩次，其它的數字恰好出現一次。怎樣通過只讀遍歷一次數組，找出數字a和b。
由於只能遍歷一次，在遍歷數組arr時，算出 a和b的差值，以及a和b的平方差，通過解方程，即可求得a和b。具體做法為：
設：
s1 = 1 + 2 + ... + n (= n * (n + 1) / 2)
s2 = arr[0] + arr[1] + ... + arr[n - 1]
r1 = 1 + 4 + ... + n^2 (= n * (n + 1) * (2 * n + 1) / 6)
r2 = arr[0]^2 + arr[1]^2 + ... + arr[n - 1]^2
c = a - b = s1 - s2
d = a^2 - b^2 = r1 - r2
顯然： a + b = (r1 - r2) / (s1 - s2)
根據a+b的值和a-b的值，很容易就可算出a和b。
算法雖然簡單，但實現起來，卻有一個很大問題：計算 s1、s2、r1、r2這4個數時，計算過程中可能出現溢出，造成結果不准。由於最終目的是為了計算出c和d，一個改進的方法是：
c = s1 - s2 = (1 - arr[0]) + (2 - arr[1]) + ... + (n - arr[n - 1])
d = (1 - arr[0]^2) + (4 - arr[1]^2) + ... + (n^2 - arr[n - 1]^2)
但這樣的做法，並不能解決問題，n稍微大點，照樣存在溢出問題。
那么怎樣才能避免計算溢出呢？答案很簡單，用模運算！每進行一次加減運算時，都取結果為原結果除以一個足夠大的常數M的余數。這樣加減運算中，就不會現現溢出問題。最后再由 c % M、d % M，推測出c、d的具體值。比如說，計算s2改為計算：
s2 % M = ((((arr[0] % M) + arr[1]) % M + ...) % M + arr[n - 1]) %M
從表面上看，采用模運算后，計算量會增加很多。但實際上，若M取合適的值時，計算量並不會增加！！
先回顧下計算機基本知識：兩個各N位（寄存器為N位）的二進制無符號整數a和b相加，若結果溢出了，CPU會怎么處理？當然是將溢出的那一位忽略掉（可能還要設置下溢出標志），得到的結果實際上是：(a + b) mod 2^N。無符號數間的算術運算，本質上就是模運算。現在的CPU都采用二補數來表示負整數，本質上也是運用模運算（教科書將二補數表示的負整數簡單定義為：對正整數取反后加1），這與無符號數間的運算是一致的，在實現上，比用其它方法（比如說一補數）表示負整數，要優美易實現。
在32位平台下， -x mod 2^32 = 2^32 – x (x > 0)，
因而-1的二進制表示就是：0xFFFFFFFF
了解了這些，就不會奇怪C/C++標准的規定：無符號數間的運算是模運算不會溢出；有符號數轉為無符數，采用模運算后的值。（為了兼容沒采用二補數的機器，無符號數轉為有符號數時，若無符號數的數值超出了有符號數可表示的范圍，結果是平台相關的。）
因而，在對32位CPU平台，可以先將有符號數轉為無符號數，再取M = 2 ^32。需要特別注意的是，應該采用多少位的無符號數保存計算中用到的數值，如何避免模運算可能帶來的問題：
① 無符號數類型的選擇：
a、b的取值范圍為：[1, n]，
c % M = (a - b) % M 的取值范圍為：[1, n] (a > b時)， [M - n, M - 1] (a < b時)
這兩個范圍不能重疊，而因 n < M - n 即 2 * n < M
若 M取2^32的話，且 n < 2^31， 可以采用32位無符號數表示c的值。
根據c % M值在哪一個范圍，可以確定a > b還是a < b，
由於運算過程中都是采用無符號數計算，當 a < b時，必須進行如下調整：
c % M 調整為 (-c) % M
d % M 調整為 (-d) % M
這樣才能保證結果的正確性。
② 用公式計算所有數字的和、平方和時，可能出現的問題：
模運算滿足： (a * b) % M = ((a % M) * (b % M)) % M
但不滿足： (a / b) % M = ((a % M) / (b % M)) % M
在計算 (n * (n + 1) / 2) % M時， 不能寫成：
s = ((n * (n + 1)) % M / 2) % M，
而應該寫成：
if (n % 2 == 0) s = ((n / 2) * (n + 1)) % M
else s = (((n + 1) / 2) * n) % M
或者：s = (INT((n + 1) / 2) * (n + (n + 1) % 2)) % M （其中INT(x)為取小數x的整數部份）。
完整代碼：
#include <climits>
#include <cassert>
#define SMALL_ARRAY 0
struct Pair {
int zero;
int twice;
};
//32位CPU平台，長度n一定小於2^16次方時，表示一個數的平方值，可用32位無符號數類型，效率很高。
//長度n若在[2^16, 2^31]區間，就必須用到64位無符號數類型，效率較高。
//長度n若在[2^31, 2^32)時，表示 所有數的和sum，就必須改用64位無符號數類型，效率不高。
Pair find_number(const int arr[], unsigned len)
{
const unsigned bits = CHAR_BIT * sizeof(unsigned);
#if SMALL_ARRAY
const unsigned max_len = 1u << (bits / 2u);
typedef unsigned int uint;
#else
const unsigned max_len = 1u << (bits - 1);
typedef unsigned long long uint;
#endif
assert(arr && len >= 2 && len < max_len);
const unsigned* const data = (const unsigned*)arr;
unsigned sum = 0;
uint square_sum = 0;
for (unsigned i = 0; i < len; ++i) {
const unsigned value = data[i];
sum += value;
square_sum += (uint)value * value; //注意兩個數的乘積是否會溢出
}
//1 + 2 + 3 + ... + len = len * (len + 1) / 2
const uint sum_all = (len + 1) / 2u * (uint)(len + (len + 1) % 2u);
//1^2 + 2^2 + 3^2 + ... + len^2 = len * (len + 1) * (2 * len + 1) / 6
const unsigned len2 = 2u * len + 1;
const uint square_sum_all = len2 % 3u == 0 ? len2 / 3u * sum_all : sum_all / 3u * len2;
unsigned difference = (unsigned)sum_all - sum;
uint square_difference = square_sum_all - square_sum;
const bool is_negative = difference > INT_MAX;
if (is_negative) {
difference = -difference;
square_difference = -square_difference;
}
assert(difference != 0 && square_difference % difference == 0);
const unsigned sum_two = square_difference / difference;
assert((sum_two + difference) % 2u == 0);
const unsigned larger = (sum_two + difference) / 2u;
const unsigned smaller = (sum_two - difference) / 2u;
if (is_negative) {
const Pair result = { smaller, larger};
return result;
}
const Pair result = { larger, smaller};
return result;
}
int main()
{
}