Is there a nested function I can use to fetch occurrences of pairs in a 2-D array?

Here is what I am trying to do:

I have 2 million records and each record is an array of 4 elements consisting of codes from 1 to 9. so the input looks like

arr = [
  [1, 2, 0, 3],
  [3, 1, 4, 0],
];

I want my function to return a table that find the number of occurance of each pair,

result [0,1] = 2 , since 0 and 1 both occurs together in each of the two record

similarly,
result [1,3] = 2, and result [1,4] = 1 (since it only occurs together in 1 row)

Here is what I have tried so far,

for (i = 0; i <= 9; i++) {
  for (j = 0; j <= 9; j++) {
    count = 0;
    for (k = 0; k <= 3; k++) {
      for (l = 0; l <= 3; l++) {
        if (arr[j][k].includes(i, j)) {
          count++;
        }
      }
    }
    result[i][j] = count;
  }
}

This seems awefully inefficient with n^4 complexity and I was wondering I could seek some guidance on how to pursue this. Thanks in advance.

Sample solution in Python:

def func(nums: List[int], data: List[List[int]]) -> int:
    num_1, num_2 = nums
    count = 0
    for slice in data:
        if num_1 in slice and num_2 in slice:
            count += 1
    return count

Usage:

arr = [[1, 2, 0, 3],
       [3, 1, 4, 0]]

print(func([0, 1], arr))

2

First off, you do not have any n^4 complexity in there. In fact, as your code seems to have hard-coded loop boundaries (9, and 3), yours is a fixed-time block, O(1). Presumably you want to run something over your two million records, and want something that will be reasonably fast for each.

Well, first of all, you need a way to test each of the 45 pairs,[0, 1], [0, 2], [0, 3], ..., [8, 8], [8, 9] against every one of your records, accumulating a result as you go. This we can do with a double reduce, like this:

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

const pairs = ([n, ...ns]) =>
  n == undefined || ns .length == 0
    ? []
    : [...ns .map (m => [n, m]), ...pairs (ns)]

const countPairs = (arr, ps = pairs ([...'0123456789']) .map (([a, b]) => `${a}${b}`)) => 
  Object .entries (arr .map (ar => new Set (ar .map (String))) .reduce (
    (a, s) => ps .reduce ((a, p) => ((a
 += s .has (p [0]) && s .has (p [1]) ? 1 : 0), a), a),
    Object .fromEntries (ps .map ((p) => 
))
  )) /*.filter (([k, v]) => v !== 0)*/ .map (
    ([k, count]) => ({pair: k .split ('') .map (Number), count})
  )

const arr = [[1, 2, 0, 3], [3, 1, 4, 0]]

console .log (countPairs (arr))

<!-- language: lang-css -->

.as-console-wrapper {max-height: 100% !important; top: 0}

<!-- end snippet -->

If you only want the pairs with positive counts (this might not be particularly relevant for two million records, depending upon your data), then uncomment the call to .filter.

We start with a simple recursive helper, pairs, which should be clear enough with an example:

pairs (['a', 'b', 'c', 'd'])
//=> [["a", "b"], ["a", "c"], ["a", "d"], ["b", "c"], ["b", "d"], ["c", "d"]]

Our main function first calls pairs on [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], combines the resulting pairs into strings ([2, 7] //=> '27'). Then it converts each of your two million records into Sets of numbers (which should have faster lookup than Array .includes, although I didn't test, and it's possibly not helpful for arrays only four elements long.)

Then we reduce over these new Sets, for each one reducing over the stringified pairs, and accumulating at both levels to an object that initially looks like {'01': 0, '02': 0, '03': 0, /*...*/, '88': 0, '89': 0}, adding 1 to every pair where both digits are in the current set.

I'm not sure how you wanted your results formatted. I chose to use Object.entries, an optional filter call, and a map to turn this into something like this:

[
  {pair: [1, 2], count: 1}
  {pair: [1, 3], count: 2}
  {pair: [1, 4], count: 1}
  {pair: [2, 3], count: 1}
  {pair: [3, 4], count: 1}
  {pair: [0, 1], count: 2}
  {pair: [0, 2], count: 1}
  {pair: [0, 3], count: 2}
  {pair: [0, 4], count: 1}
]

(with the .filter call uncommented) but you could reformat how you like.