Question

Given two integer arrays of size N, design an algorithm to determine whether one is a permutation of the other. That is, do they contain exactly the same entries but, possibly, in a different order.

I can think of two ways:
Sort them and compare : O(N.log N + N)

Check if the array have same number of integers and the sum of these integers is same, then XOR both the arrays and see if the result is 0. This is O(N). I am not sure if this method will eliminate false positives completely. Thoughts. Better algorithms?

Answer 1

Check if the array have same number of integers and the sum of these integers is same, then XOR both the arrays and see if the result is 0.

This doesn’t work. Example:

a = [1,6]  length(a) = 2, sum(a) = 7, xor(a) = 7
b = [3,4]  length(b) = 2, sum(b) = 7, xor(b) = 7

Others have already suggested HashMap for an O(n) solution.

Here’s an O(n) solution in C# using a Dictionary<T, int>:

bool IsPermutation<T>(IList<T> values1, IList<T> values2)
{
    if (values1.Count != values2.Count)
    {
        return false;
    }

    Dictionary<T, int> counts = new Dictionary<T, int>();
    foreach (T t in values1)
    {
        int count;
        counts.TryGetValue(t, out count);
        counts[t] = count + 1;
    }

    foreach (T t in values2)
    {
        int count;
        if (!counts.TryGetValue(t, out count) || count == 0)
        {
            return false;
        }
        counts[t] = count - 1;
    }

    return true;
}

In Python you could use the Counter class:

>>> a = [1, 4, 9, 4, 6]
>>> b = [4, 6, 1, 4, 9]
>>> c = [4, 1, 9, 1, 6]
>>> d = [1, 4, 6, 9, 4]
>>> from collections import Counter
>>> Counter(a) == Counter(b)
True
>>> Counter(c) == Counter(d)
False