target_arrays is fixed-很漂亮！
在这种情况下，您可以预先处理目标数组并构建一种“反向索引”（搜索引擎和数据库领域的概念）。对于每个可能的值，创建包含该值的目标数组的索引数组，如下所示：

inverted[] 
val   target_arrays_containing_val
1     2,5,100, 999999  
2     7, 13, 3141592
...
6000  3,111, 222,444,555,888

现在，对于ref_arr中的每个元素，相应数组的递增计数器

for x in ref_arr:
   for a in inverted[x]:
       num_matches[a] += 1

对于较短的目标数组（在示例中为40个），inverted[]的子列表应该很短，这样你会获得显著的收益：从当前主导的O(n*c)复杂度到O(nf*mean_sublist_size)
简单的Python实现。
我在targets中删除了重复的内容，但为了简单起见，不在ref中处理它们。

import random

targ = [[random.randint(1,50) for i in range(6)] for j in range(10)]
ref = [random.randint(1,30) for i in range(15)]

mx = max([max(x) for x in targ])
inverted = [[] for i in range(mx+1)]
num_matches = [0]*len(targ)
for ind, x in enumerate(targ):
    for val in x:
        if not (ind in inverted[val]):
            inverted[val].append(ind)    

for x in ref:
   for a in inverted[x]:
       num_matches[a] += 1

for x in targ:
    print(x)
print()
print(inverted)
print(ref)
print(num_matches)

>>>>
[39, 27, 30, 31, 12, 45]
[45, 45, 36, 16, 33, 10]
[32, 34, 48, 35, 36, 36]
[18, 16, 6, 19, 1, 35]
[32, 13, 1, 2, 30, 34]
[40, 18, 37, 18, 25, 47]
[21, 27, 33, 42, 43, 2]
[22, 47, 2, 34, 25, 26]
[30, 47, 6, 23, 39, 44]
[21, 43, 27, 1, 12, 30]

[[], [3, 4, 9], [4, 6, 7], [], [], [], [3, 8], [], [], [], [1], [],
 [0, 9], [4], [], [], [1, 3], [], [3, 5], [3], [], [6, 9], [7], [8],
 [], [5, 7], [7], [0, 6, 9], [], [], [0, 4, 8, 9], [0], [2, 4], [1, 6], 
 [2, 4, 7], [2, 3], [1, 2], [5], [], [0, 8], [5], [], [6], [6, 9], [8], 
 [0, 1], [], [5, 7, 8], [2]]

[15, 8, 22, 18, 15, 24, 16, 22, 30, 30, 27, 18, 9, 22, 17]

[3, 1, 0, 3, 2, 2, 1, 3, 2, 3]

正如评论中所建议的，将内容计数到dict中，对dict.keys（）使用集合操作，从结果dict中找到具有最小出现次数的公共键/删除唯一键。
你可以避免排序+遍历，在构建字典时只遍历。通过使用一组“seen_keys”，你可以忽略后面列表中还没有被看到的值：

'''This is plain python - working code as guideline - you would have to transform that 
to cpython/numpy yourself'''
# millions of arrays with small amount of unique ints in it
l1 = [1,1,1,1,1,1, 2,2,2,2,2,2, 3,3,3,3,3,3, 4,4,4,4,4,4, 99] 
l2 = [1,1,1,1,1,   2,2,2,2,2,   3,3,3,3,3,   4,4,4,4,4,   98]
l3 = [1,           2,2,         3,3,3]

dicts = []
seen_keys = set(l1) # initial keys from one list, doesn't matter which

# m lists: go once through each list  m times O(n)
for l in [l1,l2,l3]:   # m lists result in m dicts
    curr_d = {} 
    dicts.append(curr_d)

    # o(n) with n=len(list) instead of sorting with O(n*log(n))
    for i in l:
        if i not in seen_keys: continue  # skipable -> missing in ealier list
        # in plain python you can use defaultdict(int) or Counter for speedups
        curr_d.setdefault(i,0) 
        curr_d[i] += 1

# resulting dict for minimal counts of keys that are in ALL lists
total_d = {}
for d in dicts:
    # initial values 
    if not total_d:
        total_d = dict(d.items())
        continue

    # remove all things from total_d that are not in new dict
    # this will reduce runtimes the further you go as the next step has fewer updates
    diffr = total_d.keys() - d.keys()
    for remove in diffr:
        del total_d[remove]

    # reduce count to minial for any key that is in total_d and new dict
    commn =  total_d.keys() & d.keys()
    for c in commn:
        total_d[c] = min(total_d[c],d[c])  # ternary maybe faster

print(total_d) #    total_d.su

输出：

{1: 1, 2: 2, 3: 3}