How can I quickly tell if a list contains a list?

Question

There are multiple related questions, but I'm looking for a solution specific to my case. There is an array of (usually) 14 integers, each in the range of 1 to 34. How can I quickly tell if each int in a specific, static list appears at least once in this array?

For reference, I'm currently using this code, which was written to resemble the spec as closely as possible, so it can certainly be improved vastly:

if (array.Count < 13) {
    return;
}

var required = new int[] {
    0*9 + 1,
    0*9 + 9,
    1*9 + 1,
    1*9 + 9,
    2*9 + 1,
    2*9 + 9,                
    3*9 + 1,
    3*9 + 2,
    3*9 + 3,
    3*9 + 4,
    3*9 + 5,
    3*9 + 6,
    3*9 + 7,
};

IsThirteenOrphans = !required.Except (array).Any ();

The required list is not dynamic, i.e. it will always be the same during runtime. Using Linq is optional, the main aspect is performance.

Edit:

• The input array is not sorted.
• Input values may appear multiple times.
• The input array will contain at least 14 items, i.e. 1 more than the required array.
• There is only 1 required array and it is static.
• The values in required are distinct.
• You may assume that a histogram is cheap to create.

Update: I am also interested in a solution for a sorted input array.

Answer 1

Idea 1
If you need to compare with several required lists then you might sort the input list and then simply compare it by iterating. But sorting is of course not too fast, but not too slow either. But if you compare with several required lists the overhead of sorting might be amortized quickly.

Once the array is sorted comparing is trivial:

for(int i = 0; i < 14; i++)
  if(arr[i] != required[i]) return false;

return true;

Idea 2
Or if the 14 integers are distinct/unique you can simply make required a HashSet and do

input.Count(i => required.Contains(i)) == 14

But I don't know without actually testing it if that's faster than sorting.

Idea 3
Calculate a quick hash which is invariant under permutations over the 14 ints and compare it to the known value of require. Only if the hash matches do the more expensive comparison.

//Prepare/precalculated
int[] hashes = new int[34];
Random random = new Random();
for(int i = 0; i < 34; i++)
  hashes[i] = random.NextInt();

//On each list
int HashInts(int[] ints)
{
  int result = 0;
  foreach(int i in ints)
    result += hashes[i - 1];

  return result;
}

A wise choice of values for hashes might improve it a bit, but random values should be fine.

Idea 4
Create a Histogram:

int[] CreateHistogram(int[] ints)
{
  int[] counts = new int[34];
  foreach(int i in ints)
  {
    counts[i - 1]++;
  }

  return counts;
}

You can avoid the array creating by reusing an existing array if performance is really important.

Answer 2

If you have a 34+ bit integral type available, and C style bit operations, then you could compute such an integer V from the variable list (if the list is v[0], v[1], ... then V is (1 << v[0]) | (1 << v[1]) ... where 1 is of the same type as V) and have a predefined such integer S for the static list, computed analogously. The test to see if the static list is contained in the variable list is then (S & ~V) == 0.