我的面试问题是这样的:
给定一个包含40亿个整数的输入文件，提供一种算法来生成一个文件中不包含的整数。假设您有1gb内存。如果你只有10mb的内存，你会怎么做。
我的分析:
文件大小为4×109×4 bytes = 16gb。
我们可以进行外部排序，从而知道整数的范围。
我的问题是，在已排序的大整数集中检测缺失整数的最佳方法是什么?
我的理解(看完所有答案后):
假设我们讨论的是32位整数，有232 = 4*109个不同的整数。
情况1:我们有1gb = 1 * 109 * 8位= 80亿位内存。
解决方案:
如果我们用一位表示一个不同的整数，这就足够了。我们不需要排序。
实现:
int radix = 8;
byte[] bitfield = new byte[0xffffffff/radix];
void F() throws FileNotFoundException{
Scanner in = new Scanner(new FileReader("a.txt"));
while(in.hasNextInt()){
int n = in.nextInt();
bitfield[n/radix] |= (1 << (n%radix));
}
for(int i = 0; i< bitfield.lenght; i++){
for(int j =0; j<radix; j++){
if( (bitfield[i] & (1<<j)) == 0) System.out.print(i*radix+j);
}
}
}
情形二:10mb内存= 10 * 106 * 8bits = 8000万bits
Solution:
For all possible 16-bit prefixes, there are 216 number of
integers = 65536, we need 216 * 4 * 8 = 2 million bits. We need build 65536 buckets. For each bucket, we need 4 bytes holding all possibilities because the worst case is all the 4 billion integers belong to the same bucket.
Build the counter of each bucket through the first pass through the file.
Scan the buckets, find the first one who has less than 65536 hit.
Build new buckets whose high 16-bit prefixes are we found in step2
through second pass of the file
Scan the buckets built in step3, find the first bucket which doesnt
have a hit.
The code is very similar to above one.
结论:
我们通过增加文件传递来减少内存。
为那些迟到的人澄清一下:这个问题，正如所问的，并不是说有一个整数没有包含在文件中——至少大多数人不是这么理解的。不过，评论线程中的许多评论都是关于任务的变化。不幸的是，把它引入评论线程的评论后来被它的作者删除了，所以现在看起来它的孤儿回复只是误解了一切。这很让人困惑，抱歉。
好的，这并没有经过充分的思考，因为它假设文件中的整数遵循某种静态分布。显然他们不需要这样做，但即使这样，也应该试试这个:
有≈43亿个32位整数。我们不知道它们在文件中是如何分布的，但最糟糕的情况是具有最高香农熵的情况:均匀分布。在这种情况下，任何一个整数不出现在文件中的概率为
((2³²-1)/2³²)⁰⁰⁰⁰≈.4
The lower the Shannon entropy, the higher this probability gets on the average, but even for this worst case we have a chance of 90% to find a nonoccurring number after 5 guesses with random integers. Just create such numbers with a pseudorandom generator, store them in a list. Then read int after int and compare it to all of your guesses. When there's a match, remove this list entry. After having been through all of the file, chances are you will have more than one guess left. Use any of them. In the rare (10% even at worst case) event of no guess remaining, get a new set of random integers, perhaps more this time (10->99%).
内存消耗:几十个字节，复杂度:O(n)，开销:neclectable，因为大部分时间将花费在不可避免的硬盘访问上，而不是比较int类型。
当我们不假设静态分布时，实际最坏的情况是每个整数都出现最大值。曾经，因为那时只有
1 - 4000000000/2³²≈6%
所有的整数都不会出现在文件中。因此，您需要更多的猜测，但这仍然不会消耗大量的内存。
如果我们假设数字的范围总是2^n(2的偶次幂)，那么排异或将成立(如另一张海报所示)。至于为什么，让我们证明一下:
这个理论
给定任何以0为基础的整数范围，其中有2^n个元素，其中缺少一个元素，您可以通过简单地将已知值乘在一起来找到缺少的元素。
证明
我们看一下n = 2。对于n=2，我们可以表示4个唯一的整数:0、1、2、3。它们有一个模式:
0-00
1-01
2-10
3-11
现在，如果我们仔细观察，每个位都被精确地设置了两次。因此，由于它被设置为偶数次，而这些数字的异或将产生0。如果缺少一个数字，排他性或将产生一个数字，当与缺少的数字排他性时，结果将为0。因此，丢失的号码和得到的排他号码完全相同。如果去掉2，得到的xor将是10(或2)。
现在来看n+1。让我们称每个比特在n中被设置的次数为x，称每个比特在n+1中被设置的次数为y。y的值将等于y = x * 2，因为有x个元素的n+1位设置为0,x个元素的n+1位设置为1。因为2x总是偶数，所以n+1总是将每一位设置为偶数次。
因此，既然n=2可行，n+1也可行，那么xor方法将适用于所有n>=2的值。
0为基础范围的算法
这很简单。它使用2*n位内存，因此对于任何<= 32的范围，2个32位整数都可以工作(忽略文件描述符消耗的任何内存)。它只对文件进行一次传递。
long supplied = 0;
long result = 0;
while (supplied = read_int_from_file()) {
result = result ^ supplied;
}
return result;
任意基范围的算法
该算法适用于任何起始数到任何结束数的范围，只要总范围等于2^n…这基本上是重新定义了范围，使最小值为0。但它确实需要遍历文件2次(第一次获取最小值，第二次计算缺少的int)。
long supplied = 0;
long result = 0;
long offset = INT_MAX;
while (supplied = read_int_from_file()) {
if (supplied < offset) {
offset = supplied;
}
}
reset_file_pointer();
while (supplied = read_int_from_file()) {
result = result ^ (supplied - offset);
}
return result + offset;
任意范围
我们可以将这种修改后的方法应用于任意范围的集合，因为所有范围都会至少穿过2^n的幂次。这只适用于有一个单一的缺失位。它需要对一个未排序的文件进行2次传递，但它每次都会找到一个丢失的数字:
long supplied = 0;
long result = 0;
long offset = INT_MAX;
long n = 0;
double temp;
while (supplied = read_int_from_file()) {
if (supplied < offset) {
offset = supplied;
}
}
reset_file_pointer();
while (supplied = read_int_from_file()) {
n++;
result = result ^ (supplied - offset);
}
// We need to increment n one value so that we take care of the missing
// int value
n++
while (n == 1 || 0 != (n & (n - 1))) {
result = result ^ (n++);
}
return result + offset;
基本上，在0附近重新设置范围。然后，它在计算异或时计算要追加的未排序值的数量。然后，它将未排序值的计数加1，以处理缺少的值(计算缺少的值)。然后，继续求n的值，每次加1，直到n是2的幂。然后将结果重新基于原始基数。完成了。
下面是我在PHP中测试的算法(使用数组而不是文件，但概念相同):
function find($array) {
$offset = min($array);
$n = 0;
$result = 0;
foreach ($array as $value) {
$result = $result ^ ($value - $offset);
$n++;
}
$n++; // This takes care of the missing value
while ($n == 1 || 0 != ($n & ($n - 1))) {
$result = $result ^ ($n++);
}
return $result + $offset;
}
在一个具有任何范围的值的数组中(我测试了包括负号)，其中一个在该范围内是缺失的，它每次都找到正确的值。
另一种方法
既然我们可以使用外部排序，为什么不只是检查间隙呢?如果我们假设文件在运行这个算法之前已经排序:
long supplied = 0;
long last = read_int_from_file();
while (supplied = read_int_from_file()) {
if (supplied != last + 1) {
return last + 1;
}
last = supplied;
}
// The range is contiguous, so what do we do here? Let's return last + 1:
return last + 1;
