我最近在某个地方遇到了一个问题：
假设您有一个包含 1001 个整数的数组。整数是随机顺序的，但您知道每个整数都在 1 到 1000（含）之间。此外，每个数字在数组中只出现一次，除了一个数字出现两次。假设您只能访问数组的每个元素一次。描述一个算法来找到重复的数字。如果你在算法中使用了辅助存储，你能找到不需要它的算法吗？
我有兴趣了解的是第二部分，即不使用辅助存储。你有什么想法吗？
【问题讨论】：
标签： arrays algorithm duplicates
只需将它们全部加起来，然后从中减去仅使用 1001 个数字时的总和。
例如：
Input: 1,2,3,2,4 => 12
Expected: 1,2,3,4 => 10
Input - Expected => 2
【讨论】：
更新 2： 有人认为使用 XOR 查找重复号码是一种 hack 或技巧。我的官方回应是：“我不是在寻找重复的数字，我在寻找位集数组中的重复模式。XOR 绝对比 ADD 更适合操作位集”。 :-)
更新：只是为了睡前的乐趣，这里有一个“单行”替代解决方案，它需要零额外存储（甚至不需要循环计数器），只接触每个数组元素一次，是非破坏性且根本不扩展:-)
printf("Answer : %d\n",
array[0] ^
array[1] ^
array[2] ^
// continue typing...
array[999] ^
array[1000] ^
1 ^
2 ^
// continue typing...
999^
1000
);
请注意，编译器实际上会在编译时计算该表达式的后半部分，因此“算法”将执行 1002 次操作。
如果在编译时也知道数组元素的值，编译器会将整个语句优化为一个常量。 :-)
原解：虽然能找到正确答案，但不符合问题的严格要求。它使用一个额外的整数来保存循环计数器，并且它访问每个数组元素 3 次 - 在当前迭代中读取和写入两次，在下一次迭代中读取一次。
好吧，您至少需要一个额外的变量（或 CPU 寄存器）来存储您遍历数组时当前元素的索引。
不过，除此之外，这里还有一种破坏性算法，可以安全地扩展到最多 MAX_INT 的任何 N。
for (int i = 1; i < 1001; i++)
{
array[i] = array[i] ^ array[i-1] ^ i;
}
printf("Answer : %d\n", array[1000]);
我将通过一个简单的提示将弄清楚为什么这会起作用的练习留给你:-)：
a ^ a = 0
0 ^ a = a
【讨论】：
Franci Penov 的非破坏性解决方案。
这可以通过使用XOR 运算符来完成。
假设我们有一个大小为5:4, 3, 1, 2, 2的数组
哪些在索引中： 0, 1, 2, 3, 4
现在对所有元素和所有索引执行XOR。我们得到2，它是重复元素。发生这种情况是因为，0 在 XORing 中没有任何作用。剩余的n-1 索引与数组中的相同n-1 元素配对，并且数组中唯一未配对的元素 将是重复的。
int i;
int dupe = 0;
for(i = 0; i < N; i++) {
dupe = dupe ^ arr[i] ^ i;
}
// dupe has the duplicate.
这个解决方案的最大特点是它不会出现在基于加法的解决方案中出现的溢出问题。
由于这是一道面试题，最好先从基于加法的解决方案开始，确定溢出限制，然后给出基于XOR的解决方案:)
这使用了一个额外的变量，所以不完全满足问题的要求。
【讨论】：
{ 1043, 1042, 1044, 1042 } 通过 XOR-ing 与 { 0, 1042, 1043, 1044 }。
将所有数字加在一起。最终的总和将是 1+2+...+1000+重复数字。
【讨论】：
套用弗朗西斯·佩诺夫的解决方案。
（通常的）问题是：给定一个任意长度的整数数组，其中只包含重复偶数次的元素，除了一个重复奇数次的值，找出这个值。
解决办法是：
acc = 0
for i in array: acc = acc ^ i
您当前的问题是适应。诀窍是你要找到重复两次的元素，所以你需要调整解决方案来弥补这个怪癖。
acc = 0
for i in len(array): acc = acc ^ i ^ array[i]
弗朗西斯的解决方案最终做了什么，虽然它破坏了整个数组（顺便说一句，它只能破坏第一个或最后一个元素......）
但是由于索引需要额外的存储空间，我认为如果你还使用额外的整数，你会被原谅......这个限制很可能是因为他们想阻止你使用数组。
如果他们需要O(1) 空格（1000 可以被视为 N，因为它在这里是任意的），它的措辞会更准确。
【讨论】：
添加所有数字。整数 1..1000 的和为 (1000*1001)/2。与你得到的不同的是你的号码。
【讨论】：
arr = [1,3,2,4,2]
print reduce(lambda acc, (i, x): acc ^ i ^ x, enumerate(arr), 0)
# -> 2
@Matthieu M.'s answer 中解释了它的工作原理。
【讨论】：
如果您知道我们有 1-1000 的确切数字，您可以将结果相加并从总数中减去 500500 (sum(1, 1000))。这将给出重复的数字，因为sum(array) = sum(1, 1000) + repeated number。
【讨论】：
嗯，有一个非常简单的方法可以做到这一点...... 1 到 1000 之间的每个数字都只出现一次，除了重复的数字......所以，1....1000 的总和是500500。所以，算法是：
总和 = 0 对于数组的每个元素： sum += 数组的那个元素 number_that_occurred_twice = sum - 500500【讨论】：
n = 1000
s = sum(GivenList)
r = str(n/2)
duplicate = int( r + r ) - s
【讨论】：
public static void main(String[] args) {
int start = 1;
int end = 10;
int arr[] = {1, 2, 3, 4, 4, 5, 6, 7, 8, 9, 10};
System.out.println(findDuplicate(arr, start, end));
}
static int findDuplicate(int arr[], int start, int end) {
int sumAll = 0;
for(int i = start; i <= end; i++) {
sumAll += i;
}
System.out.println(sumAll);
int sumArrElem = 0;
for(int e : arr) {
sumArrElem += e;
}
System.out.println(sumArrElem);
return sumArrElem - sumAll;
}
【讨论】：
没有额外的存储要求（除了循环变量）。
int length = (sizeof array) / (sizeof array[0]);
for(int i = 1; i < length; i++) {
array[0] += array[i];
}
printf(
"Answer : %d\n",
( array[0] - (length * (length + 1)) / 2 )
);
【讨论】：
length 才能使其通用。
参数和调用堆栈算作辅助存储吗？
int sumRemaining(int* remaining, int count) {
if (!count) {
return 0;
}
return remaining[0] + sumRemaining(remaining + 1, count - 1);
}
printf("duplicate is %d", sumRemaining(array, 1001) - 500500);
编辑：尾调用版本
int sumRemaining(int* remaining, int count, int sumSoFar) {
if (!count) {
return sumSoFar;
}
return sumRemaining(remaining + 1, count - 1, sumSoFar + remaining[0]);
}
printf("duplicate is %d", sumRemaining(array, 1001, 0) - 500500);
【讨论】：
public int duplicateNumber(int[] A) {
int count = 0;
for(int k = 0; k < A.Length; k++)
count += A[k];
return count - (A.Length * (A.Length - 1) >> 1);
}
【讨论】：
三角形数 T(n) 是从 1 到 n 的 n 个自然数之和。它可以表示为n(n+1)/2。因此，知道在给定的 1001 个自然数中，只有一个数字重复，您可以轻松地将所有给定数字相加并减去 T(1000)。结果将包含此副本。
对于一个三角数 T(n)，如果 n 是 10 的任意一次幂，也有一个漂亮的方法可以找到这个 T(n)，基于 base-10 表示：
n = 1000
s = sum(GivenList)
r = str(n/2)
duplicate = int( r + r ) - s
【讨论】：
我支持添加所有元素，然后从中减去所有索引的总和，但如果元素数量非常大，这将不起作用。 IE。会导致整数溢出！所以我设计了这个算法，它可能会在很大程度上减少整数溢出的机会。
for i=0 to n-1
begin:
diff = a[i]-i;
dup = dup + diff;
end
// where dup is the duplicate element..
但是通过这种方法，我将无法找出重复元素所在的索引！
为此，我需要再次遍历数组，这是不可取的。
【讨论】：
基于 XORing 连续值的属性改进 Fraci 的答案：
int result = xor_sum(N);
for (i = 0; i < N+1; i++)
{
result = result ^ array[i];
}
地点：
// Compute (((1 xor 2) xor 3) .. xor value)
int xor_sum(int value)
{
int modulo = x % 4;
if (modulo == 0)
return value;
else if (modulo == 1)
return 1;
else if (modulo == 2)
return i + 1;
else
return 0;
}
或者在伪代码/数学语言 f(n) 中定义为（优化）：
if n mod 4 = 0 then X = n
if n mod 4 = 1 then X = 1
if n mod 4 = 2 then X = n+1
if n mod 4 = 3 then X = 0
而在规范形式中，f(n) 是：
f(0) = 0
f(n) = f(n-1) xor n
【讨论】：
我对问题 2 的回答：
求从 1 到（到）N 的数字的总和和乘积，例如 SUM、PROD。
求 1 - N- x -y 的数字的总和和乘积，（假设缺少 x，y），比如说 mySum，myProd，
因此：
SUM = mySum + x + y;
PROD = myProd* x*y;
因此：
x*y = PROD/myProd; x+y = SUM - mySum;
如果解这个方程，我们可以找到 x,y。
【讨论】：
在 aux 版本中，首先将所有值设置为 -1，然后在迭代时检查是否已将值插入到 aux 数组中。如果不是（那么值必须为 -1），则插入。如果您有重复，这是您的解决方案！
在没有 aux 的情况下，您从列表中检索一个元素并检查列表的其余部分是否包含该值。如果它包含，在这里你已经找到了。
private static int findDuplicated(int[] array) {
if (array == null || array.length < 2) {
System.out.println("invalid");
return -1;
}
int[] checker = new int[array.length];
Arrays.fill(checker, -1);
for (int i = 0; i < array.length; i++) {
int value = array[i];
int checked = checker[value];
if (checked == -1) {
checker[value] = value;
} else {
return value;
}
}
return -1;
}
private static int findDuplicatedWithoutAux(int[] array) {
if (array == null || array.length < 2) {
System.out.println("invalid");
return -1;
}
for (int i = 0; i < array.length; i++) {
int value = array[i];
for (int j = i + 1; j < array.length; j++) {
int toCompare = array[j];
if (value == toCompare) {
return array[i];
}
}
}
return -1;
}
【讨论】：