从两个数组中区分额外的元素？

Question

我的一个朋友在一次采访中被问到这个问题 -

• 您已经给出了两个整数数组，每个数组的大小为 10。
• 两者都包含 9 个相等的元素（比如 1 到 9）
• 只有一个元素不同。

你将如何找到不同的元素？您可以采取哪些不同的方法？

一种简单但冗长的方法是 - 对两个数组进行排序，继续比较每个元素，进行错误比较，你会得到你的结果。

那么有什么不同的方法呢？在面试中指定逻辑作为其预期。不期望特定语言的特定代码。伪代码就足够了。

（请为每个答案提交一种方法）

我问这个问题的目的是，当数组很小的时候还可以。但是当数组大小增加时，你必须想一个非常有效的 n 更快的方法。在这种情况下使用比较是不可取的。

Answer 1

如果您需要扩展它，那么我会使用世界上众多 Set 实现之一。比如Java的HashSet。

抛出 Set 中的所有第一个数组。然后，对于第二个数组的每个成员，如果它包含在 Set 中，则将其删除；否则将其标记为唯一#2。在此过程之后，该集合的最后一个剩余成员是唯一的 #1。

我可能会这样做，即使是在面试中，甚至对于简单的十元素数组也是如此。人生苦短，当有一扇非常好的门时，不能花时间去寻找爬墙的聪明方法。

Answer 2

这是一种数学方法，灵感来自 Kevin 的答案及其 cmets。

我们将数组命名为A 和B，并将它们的唯一元素分别设为a 和b。首先，取两个数组的总和，然后从另一个中减去一个；因为其他一切都取消了，sum(A) - sum(B) = a - b = s。然后，将两个数组的元素相乘，然后除以另一个。同样，事情取消了，所以mult(A) / mult(B) = a / b = r。现在，从这些中，我们得到a = rb，所以rb - b = s 或b = s / (r - 1)，然后是a = rs / (r - 1)。

我之所以称之为数学，是因为在实际程序中将事物相乘可能不是一件合理的事情。关键是要有两个不同的操作，它们都分别允许取消行为，并且一个分布在另一个之上。后一个属性在从rb - b = s 到b = s / (r - 1) 时使用，这对于我第一次尝试的加法和 XOR 来说是行不通的。

Answer 3

这可以通过两个序列的sum和平方和快速解决。并且计算这些总和肯定会比建议的哈希更快，并且不涉及序列项之间的任何比较。

操作方法如下：如果这两个集合是 {a_i} 和 {b_i }，则称A和B为和，A2和B2为平方和，即A2 = Sum({a_i²})，为方便起见，D=AB 和 D2=A2-B2。因此，D=ab 和 D2=a²-b²，其中 a和b是不同的两个元素，由此我们看到

a = (D²+D2)/(2*D)
b = a - D

这是因为，根据代数，a²-b²=(a+b)(ab) 或 D2=(a+b)D，所以a+b=D2/D，又因为我们也知道ab，所以可以求出a 和 b。

Python中的例子可能更有说服力

a, b = 5, 22   # the initial unmatched terms
x, y = range(15), range(15)
y[a] = b
print "x =", x  # x = [0, 1, 2, 3, 4,  5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
print "y =", y  # y = [0, 1, 2, 3, 4, 22, 6, 7, 8, 9, 10, 11, 12, 13, 14]

D = sum(x) - sum(y)
D2 = sum([i**2 for i in x]) - sum([i**2 for i in y])  #element-wise squaring
a = (D2+D*D)/(2*D)
b = a - D

print "a=%i, b=%i" % (a, b)
#prints a=5, b=22  which is correct

（当然，这与 jk 的答案有些相似，只是它不需要所有项的乘法以及会产生的巨大数字，但感谢 jk 提出了数学方法的想法。）

Answer 4

从技术上讲，您可以在恒定时间内完成，因为数组（以及其中的值）是有限的。对于泛化问题，我们必须弄清楚一些更棘手的问题。

这是一个线性时间解决方案。

首先，我们应该基于一个数组构建一个散列。哈希表中的值查找需要 O(1 + k/n) 次比较 [1]，其中 k 是哈希表的长度。因此迭代第一个数组（包含 n 个元素）并查找每个值需要 O(n+k)。

然后我们迭代另一个，查找散列中的每个元素。当没有找到一个元素时——这是另一个数组中唯一的一个。 （再次O（n + k））。然后我们迭代 hash 来寻找第二个唯一元素 (O(k))。

总时间为 O(n+k)。因为让 k 大于 n 没有意义，所以它是线性解。

Perl 代码：

sub unique
{
  my ($arr, $brr) = @_;
  my %hash = map{$_ => 1} @$arr;
  %hash{$_}-- for @$brr;
  return grep {$_} keys %hash;
}

Answer 5

在 LINQ 中：

var unique1 = (from a in arrayA where !arrayB.Contains(a) select a).First();
var unique2 = (from b in arrayB where !arrayA.Contains(b) select b).First();
return new Pair(unique1, unique2);

...

public sealed class Pair<T0, T1>
{
    public T0 Item1 {get;set;}
    public T1 Item2 {get;set;}
    public Pair(T0 item1, T1 item2)
    {
        Item1 = item1;
        Item2 = item2;
    }
    //plus GetHashCode, equality etc.
}

Answer 6

这是另一种可能性。与我的previous answer 不同，它不会修改传入的数组，并且应该具有较低的 big-O 界限（O(n) 而不是 O(n^2) - 假设恒定时间哈希表查找），但会占用大量时间更多内存。

function findUnique(a:Array, b:Array):Array {
  var aHash:Hashtable = buildHash(a);
  var bHash:Hashtable = buildHash(b);

  var uniqueFromA:int;
  var uniqueFromB:int;

  for each(value:int in a) {
    if(!bHash.contains(value)) {
      uniqueFromA = value;
      break;
    } else {
      /* Not necessary, but will speed up the 2nd for-loop by removing
       * values we know are duplicates. */
      bHash.remove(value);
    }
  }

  for each(value:int in b) {
    if(!aHash.contains(value)) {
      uniqueFromB = value;
      break;
    }
  }

  return [uniqueFromA, uniqueFromB];
}

function buildHash(a:Array):Hashtable {
  var h:Hashtable = new Hashtable();
  for each(value:int in a) {
    h[value] = true;
  }

  return h;
}

Answer 7

• 您已经给出了两个大小为 10 的整数数组。
• 两者都包含 9 个相等的元素（比如 1 到 9）
• 只有一个元素不同。

根据约束条件，您可以在线性时间内非常快速地解决这个问题。如果你持有一个 int[10]，那么你可以假设索引 1 处的元素对应于数字 1；元素本身包含两个数组的计数。下面的伪代码可以快速解决问题：

let buckets = new int[10] // init all buckets to zero
for num in arr1 do buckets[num]++ // add numbers from the first array
for num in arr2 do buckets[num]++ // add from the second array
for i in 1 to 9 do                // find odd man out
    if buckets[i] <= 1 then return i

这本质上是一个有界哈希表。这仅在我们给定的元素列表被限制在 1 到 9 之间时才有效。

从技术上讲，您甚至不需要保留每个元素的运行计数。原则上，您可以简单地遍历 arr1，然后遍历 arr2，直到遇到未从第一个数组散列的元素。

Answer 8

之前几乎所有答案背后的逻辑总是相同的：使用数学中的集合运算来解决问题。

数学中的集合只能包含每个元素一次。所以下面的列表不可能是数学意义上的集合，因为它包含一个数字 (3) 两次：

{ 1, 2, 3, 4, 3, 5 }

由于集合操作，特别是检查一个元素是否已经存在于集合中，是常见的操作，大多数语言都有数据结构可以有效地实现这些集合操作。所以我们可以在我们的解决方案中简单地回退到这个：

// Construct set from first list:
Set uniques = Set.from(list1);

// Iterate over second list, check each item’s existence in set.
for each (item in list2)
    if (not uniques.Contains(item))
        return item;

集合的不同实现产生不同的性能，但这种性能总是优于简单的解决方案（对于大型列表）。特别是，存在两种实现：

• 作为（自平衡）search tree。树的元素已排序，因此通过使用二分搜索（或其变体）查找特定元素是有效的。查找因此具有 O(log n) 的性能。从输入创建树集的性能为 O(n · log n)。这也是整体表现。
• Hash tables 可以实现为具有 O(1) 的平均查找性能（并且通过一些技巧，这也可以成为最坏情况的性能）。创建哈希表可以在 O(n) 中完成。因此，哈希表可以实现 O(n) 的整体运行时间。
• Bloom filters 提供了一个很好的概率解决方案 - 即解决方案可能实际上是错误的，但我们可以控制（不）发生这种情况的可能性。它特别有趣，因为它非常节省空间。
• ……还有许多其他实现。

在每种情况下，用法都保持不变，上面的伪代码为您的问题提供了教科书式的解决方案。 Java 实现可能如下所示：

// Construct set from first list:
Set<Integer> uniques = new HashSet<Integer>(list1);

// Iterate over second list, check each item’s existence in set.
for (int item : list2)
    if (! uniques.Contains(item))
        return item;

请注意，这看起来几乎与伪代码一模一样。 C#、C++ 或其他语言的解决方案不会有太大的不同。

EDIT 糟糕，我刚刚注意到请求的返回值是不匹配元素的 pair。但是，这个要求不会改变推理，几乎不会改变伪代码（做同样的事情，使用互换列表）。

Answer 9

这可以使用 Xor 来完成。

首先异或两个数组中的所有元素。让 x 和 y 成为每个数组的额外元素。 剩下的是 x^y。

现在在异或中，如果设置了一个位，则意味着它被设置在两个数字之一中，而不是另一个。

我们可以使用它来查找丢失的个人号码。所以找到一个在 a^b 中设置的位。获得最右边的位很容易。可以通过

n& ~(n-1)

(1110) & ~(1101) = 0010

为了得到每个单独的数字，我们将两个数组的数字分成两部分，数字有检查位设置，哪些没有。我们对每个集合进行异或，所以我们得到值 a 和 b。这会抵消掉所有重复的元素，并分离出 x 和 y。

这可能会让人很困惑。现在取 x=3, y = 2

x=110

y=010

x^y=100

所以当我们设置位时，我们得到的数字是 bitset = 100。第三位被设置。假设数组元素为 5,1（都重复两次）

5=101

6=001

现在，5 有第三位，所以我们用 x 异或它

我们得到 x^5^5 = x

同样，6 没有设置第 3 位，因此与 y 异或。

我们得到 y^1^1 = y

代码

for(i=0;i<n;i++)
xor = xor^a[i]^b[i];

set_bit = xor & ~(xor-1) ;
for(i = 0; i < n; i++)
{
if(a[i] & set_bit_no)
 x = x ^ a[i]; /*XOR of first set */
else
 y = y ^ a[i]; /*XOR of second set*/

if(b[i] & set_bit_no)
 x = x ^ b[i]; /*XOR of first set */
else
 y = y ^ b[i]; /*XOR of second set*/
 }

这类似于这里发布的方法 http://www.geeksforgeeks.org/find-two-non-repeating-elements-in-an-array-of-repeating-elements/

Answer 10

根据您使用的语言，它可能有一个内置的方法来处理数组差异。 PHP 做http://ca3.php.net/array_diff

Answer 11

这里有一些简单的伪代码来解决问题。我假设修改数组是可以的，并且数组有一个 remove(value) 方法（或者你可以简单地写一个）。它接受 2 个数组并返回一个包含 2 个值的数组，第一个是第一个数组的唯一值，第二个是第二个数组的唯一值。

function findUnique(a:Array, b:Array):Array {
  var uniqueFromA:int;
  var uniqueFromB:int;

  for each(value:int in a) {
    var len:int = b.length;
    b.remove(value);
    /* b's length didn't change, so nothing was removed, so the value doesn't
     * exist in it. */
    if(b.length == len) {
      uniqueFromA = value;
    }
  }

  /* Only the unique value in b still exists in b */
  uniqueFromB = b[0];

  return [uniqueFromA, uniqueFromB];
}

Answer 12

如果不进行比较，就不可能解决这个问题。一些现代语言确实有设置差异和其他聚合运算符，但它们通过内部进行比较来工作。如果总数组大小是奇数（这里不是这种情况），那么它确实可以将元素 xor 在一起。我认为 ALU 的 xor 运算是否应该被视为比较的问题是值得商榷的。

如果不指定语言，就无法引用库，因此唯一可能的解决方案是基于比较的伪代码说明。

所以你去：

a <- first element
a_count = 1
b_count = 0
loop over remaining elements
   if element != a
     b <- element
     ++b_count
   else
     ++a_count
   if found_result
      break loop
end loop

found_result
   if a_count > 1 and b_count > 0
     the unique one is b
     return true
   if b_count > 1 and a_count > 0 # a_acount actually always > 0
     the unique one is a
     return true
   return false

Answer 13

将第一个数组的每个元素放入一个哈希中。对于第二个数组中的每个项目，如果它已经在哈希中，则删除它，否则添加它。最后，您有一个带有两个键的哈希，它们是您的唯一元素。

Ruby 中的简单版本

def unique(a,b)
  h={}
  a.each do |ax|
    h[ax]=true
  end
  b.each do |bx|
    if h[bx]
      h.delete(bx)
    else
      h[bx]=true
    end
  end
  h.keys
end

有了更多的 Ruby 个性，但仍然在我们不能简单地做 (a | b) - (a & b) 或 a.to_set ^ b.to_set 的宇宙中：

def unique(a,b)
  h = {}
  a.each do |ax|
    h[ax] = true
  end
  b.each do |bx|
    h.delete(bx) or h[bx] = true
  end
  h.keys
end

Answer 14

分别对数组 a、b 进行集合 A、B。 A \ B 为您提供 A 中的附加整数。B \ A 为您提供 B 中的附加整数。

如果这些操作中的任何一个返回一个空集，那么额外的整数会在数组中出现两次。您在构造集合时会发现：向集合添加重复整数不会增加集合的大小。

Answer 15

如何获取每个数组的总和并从另一个数组中减去一个？不同之处在于额外的元素。

例如：A = 1,2,3,4,5 B = 1,2,3,4

总和（A）= 15，总和（B）= 10； 15 - 10 = 5 这是额外的元素。

Answer 16

这是一个不需要散列或集合、O(1) 空间和 O(n) 时间的解决方案。它不是发布的最佳解决方案，但它是一个很好的解决方案。您所做的就是将 list1 中的值相加，然后将 list2 中的值相加，然后找出差异。

Javascript

var findExtra= function (l1, l2) {
    var l1_sum = l1.reduce(function(prev, curr) {
        return prev + curr;
    });
    var l2_sum = l2.reduce(function(prev, curr) {
        return prev + curr;
    });

    console.log(l1_sum, l2_sum);

    if (l1.length < l2.length) return l2_sum - l1_sum;
    return l1_sum - l2_sum;
}

console.log(findExtra([1,2,3,4,-1], [1,2,3,4]));

Answer 17

两次通过数组就足够了。

第一遍：将较短列表中的每个项目添加到哈希图（python 中的 dict）。 第二遍：对于较长列表中的每个项目，检查哈希图中是否存在键（O（1）搜索时间）。如果不是，则该键是唯一条目。

总时间复杂度：O(2n) = O(n)

Answer 18

给定两个数组，大小为“n”的 A1 和大小为“n-1”的 A2，这两个数组具有相同的 除了我们必须找到的元素。

注意：A1 中的元素可以重复。

例子：

A1：{2,5,5,3}

A2：{2,5,3}

输出：5

A1：{1,2,3,3,3}

A2：{2,3,1,3}

输出：3

public static void main(String args[])
{
    int[] a ={1,2,3,3,3};
    int[] b ={2,3,1,3};
    int flag=1;
    int num=0;
    List<Integer> lst = new ArrayList<>(b.length);
    for(int i : b)
        lst.add(Integer.valueOf(i));


    for(int i=0;i<a.length;i++)
    {
        flag=1;
        for(int j=0;j<lst.size();j++)
        {
            if(a[i] == lst.get(j)){
                lst.remove(j);
                flag=0;
                break;
            }

        }
        if(flag == 1)
            num=a[i];
    }

    System.out.println(num);

}

Answer 19

 int[] a = {1, 2, 3, 5};
 int[] b = {1, 2, 3, 5, 6};

      HashSet set = new HashSet();
        for (int o : b) {
            set.add(o);
        }

        for (int p : a) {
            if (set.contains(p)) {
                set.remove(p);
            }
        }

        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Log.d("TAG", " " + iterator.next());
        }