Question

I have an array of arrays. The inner array is 16 slots, each with a number, 0..15. A simple permutation.

I want to check if any of the arrays contained in the outer array, have the same values as
a test array (a permutation of 16 values).

I can do this easily by something like so:

var containsArray = function (outer, inner) {
    var len = inner.length;
    for (var i=0; i<outer.length;  i++) {
        var n = outer[i];
        var equal = true;
        for (var x=0; x<len; x++) {
            if (n[x] != inner[x]) {
                equal = false;
                break;
            }
        }
        if (equal) return true;
    }
    return false;
}

But is there a faster way?

Can I assign each permutation an integral value – actually a 64-bit integer?

Each value in a slot is 0..15, meaning it can be represented in 4 bits. There are 16 slots, which implies 64 total bits of information.

In C# it would be easy to compute and store a hash of the inner array (or permutation) using this approach, using the Int64 type. Does Javascript have 64-bit integer math that will make this fast?

Answer 1

That’s just about as fast as it gets, comparing arrays in javascript (as in other languages) is quite painful. I assume you can’t get any speed benefits from comparing the lengths before doing the inner loop, as your arrays are of fixed size?

Only “optimizations” I can think of is simplifying the syntax, but it won’t give you any speed benefits. You are already doing all you can by returning as early as possible.

Your suggestion of using 64-bit integers sounds interesting, but as javascript doesn’t have a Int64 type (to my knowledge), that would require something more complicated and might actually be slower in actual use than your current method.