Python 如何找到输入中缺少的4字节数？

我有这样的任务，实际上不知道如何开始。

---

在输入端，我有一个巨大的4字节正数数组。数字可以重复。我知道其中一个数字不包含在输入数组中。如何使用最少的资源找到这个数字？

最简单的代码可能是（在伪代码中）：

上述函数应返回缺失值或零（如果由于整数的环绕而没有缺失值）。如果缺少的值为零，则会有一点混乱，但解决方法很简单，留给读者

---

注意：这不是最快的方法。更快的方法将使用多个过程将输入拆分为子集，并使用最大可用内存分析这些子集。

这样做的最简单代码可能是（伪代码）：

上述函数应返回缺失值或零（如果由于整数的环绕而没有缺失值）。如果缺少的值为零，则会有一点混乱，但解决方法很简单，留给读者

---

注意：这不是最快的方法。更快的方法将使用多个过程将输入拆分为子集，并使用最大可用内存分析这些子集。

我不确定是否完全理解您的问题。然而，据我所知，您有一个整数数组和一个输入（也是整数）

---

在这种方法中，输入是不排序的，这具有O（n logn）的时间复杂性，而且您不存储整个输入（假设输入来自外部文件）。唯一的内存需求是保存整数集。如果原始数字列表中有许多冗余项，则集合的大小将显著减小。设置查找为O（1）。因此，所提供的解决方案具有O（n）时间复杂度，其中n是输入项的数目

我不确定我是否完全理解你的问题。然而，据我所知，您有一个整数数组和一个输入（也是整数）

---

在这种方法中，输入是不排序的，这具有O（n logn）的时间复杂性，而且您不存储整个输入（假设输入来自外部文件）。唯一的内存需求是保存整数集。如果原始数字列表中有许多冗余项，则集合的大小将显著减小。设置查找为O（1）。因此，所提供的解决方案具有O（n）时间复杂度，其中n是输入项的数目

您还没有指定如何知道原始值集是什么，因此我将继续，假设您有两个值列表，

set1

和

set2

，它们可能包含或不包含重复项，可能顺序相同，也可能不相同，并且不同于您希望识别的单个元素。我不会担心布景是如何产生的

通过这种设置，您可以对所有数据进行异或运算。结果将是缺少的值。为了说明这一点，我有一个小演示，它创建了两个相同的列表，从第二个列表中随机删除一个元素（并保留值以供检查），将列表洗牌，然后执行XOR

import random as r
from functools import reduce

def xor_all(lst):
    return reduce(lambda x,y: x ^ y, lst)

set1 = [1,2,3,3,4,5,6,7,8,8,9]
r.shuffle(set1)
set2 = [1,2,3,3,4,5,6,7,8,8,9]
rv = set2.pop(r.randrange(len(set2)))
r.shuffle(set2)

print("deleted value was: ", rv)
print("xor_all identified: ", xor_all(set1) ^ xor_all(set2))

---

您还没有指定如何知道原始值集是什么，因此我将继续，假设您有两个值列表，

set1

和

set2

，它们可能包含或不包含重复项，可能顺序相同，也可能不相同，并且不同于您希望识别的单个元素。我不会担心布景是如何产生的

通过这种设置，您可以对所有数据进行异或运算。结果将是缺少的值。为了说明这一点，我有一个小演示，它创建了两个相同的列表，从第二个列表中随机删除一个元素（并保留值以供检查），将列表洗牌，然后执行XOR

import random as r
from functools import reduce

def xor_all(lst):
    return reduce(lambda x,y: x ^ y, lst)

set1 = [1,2,3,3,4,5,6,7,8,8,9]
r.shuffle(set1)
set2 = [1,2,3,3,4,5,6,7,8,8,9]
rv = set2.pop(r.randrange(len(set2)))
r.shuffle(set2)

print("deleted value was: ", rv)
print("xor_all identified: ", xor_all(set1) ^ xor_all(set2))

---

我同意丹·盖兹对这个问题的假设。Dan的解决方案在最坏的情况下为您提供O（n log n）运行时

现在有一个疯狂的想法： 跳过开销最大的排序部分O（n log n）怎么样？不要从排序开始，只需维护所有4字节正整数的

Hashmap

，整数本身作为键，而

false

作为默认值。 一些伪代码：

function find_missing(input)
    sort!(input)   # in-place sort, should take most of the time
    val = 0
    for d in input    # go over sorted input
        if d == val
            val += 1
        end
        if d > val
            break
        end
    end
    return val
end

开始

foreach number in the input:
   if the number is in the valid range:
      if the corresponding hashmap entry has the value set to `false`, toggle it to `true`
      otherwise, do nothing and skip to the next input
foreach Hashmap entry
      if the value is `false` return the key of that entry

结束

Hashmap的大小小于或等于输入的大小（n）。 最坏情况下的运行时复杂性O（n）

---

内存方面，您将需要额外的O（n）内存。很可能比Dan Gretz的解决方案更糟糕（取决于他使用的排序算法，如果我假设是正常的合并排序，那么我的解决方案可能会在大部分时间浪费更多内存，并且只在合并排序的最后一步浪费相同或更少的内存）

我同意Dan Getz的问题假设。Dan的解决方案在最坏的情况下为您提供O（n log n）运行时

现在有一个疯狂的想法： 跳过开销最大的排序部分O（n log n）怎么样？不要从排序开始，只需维护所有4字节正整数的

Hashmap

，整数本身作为键，而

false

作为默认值。 一些伪代码：

function find_missing(input)
    sort!(input)   # in-place sort, should take most of the time
    val = 0
    for d in input    # go over sorted input
        if d == val
            val += 1
        end
        if d > val
            break
        end
    end
    return val
end

开始

foreach number in the input:
   if the number is in the valid range:
      if the corresponding hashmap entry has the value set to `false`, toggle it to `true`
      otherwise, do nothing and skip to the next input
foreach Hashmap entry
      if the value is `false` return the key of that entry

结束

Hashmap的大小小于或等于输入的大小（n）。 最坏情况下的运行时复杂性O（n）

---

内存方面，您将需要额外的O（n）内存。很可能比Dan Gretz解决方案更糟糕（取决于他使用的排序算法，如果我假设是正常的合并排序，那么我的解决方案可能会在大部分时间浪费更多内存，并且只在合并排序的最后一步浪费相同或更少的内存）

您必须有一个，如果不包括一个四字节的数字，那么这个数组真的很大——远远超过4