Question

这是我在python中的代码，它检查大数组中较小的子数组是否位于其中一个子数组中。我不知道哪个是最大的子数组的索引，所以我无法与索引进行比较。也许排序很好。但是，如果有不止一个大的子阵列？即我想在最终数组中只包含那些包含较小子数组的大子数组

[[1, 2, 3], [4, 5, 6], [1, 2, 3, 4, 5, 6], [7,8], [9, 10, 11, 12], [7, 8, 9, 10, 11, 12]]

其次，如果元素的顺序可以是随机的，我应该怎么做，例如： [[1, 3, 2], [4, 5, 6], [1, 2, 3, 4, 5, 6], [7,8], [9, 10, 11, 12], [7, 8, 9, 10, 11, 12]]

这是我的代码：

arr1 = [[1, 2, 3], [4, 5, 6], [1, 2, 3, 4, 5, 6], [7,8], [9, 10, 11, 12],  [7, 8, 9, 10, 11, 12]]

arr2 = []
arrInd = 0
arrInd2 = len(arr1)
for k in arr1:
    for n in reversed(arr1):
        if set(n).issubset(set(k)):
            arr2.append(k)

print(arr2)

我希望看到输出：

[[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]]

但我有：

[[4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [7, 8], [9, 10, 11, 12], [7, 8, 9, 10, 11, 12], [7, 8, 9, 10, 11, 12], [7, 8, 9, 10, 11, 12]]

更新

因为有很多好问题我需要添加更多细节。

1）有一个数组数组： arr1 = [[]] 2）它包含一些像这些[1, 2, 3], [4, 5, 6], [4, 6, 5], [7, 8, 9, 10, 11, 12], [11, 12, 13, 14, 15], [1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12, 13, 14, 15], [111, 222, 333], [444, 555], [777, 888], [111, 222, 333, 444, 555], [111, 222, 333, 444, 555, 777, 888], [1000, 2000, 3000]的子数组什么可能？ 1）内部数组顺序可能会有所不同：[4, 5, 6], [4, 6, 5]和[1, 2, 3, 4, 5, 6]，所以它不是数字顺序，实际上在实际数据中（我目前正在测试）可能有偶数字母，如{{1 }，A77; 2）有大的和小的数组，总是有一个最大的（或几个），它永远不会与其他最大的数组相交，所以这里B81和[1, 2, 3, 4, 5, 6] - 它们不能相互交叉，但它们包含一些迷你子阵列; 3）每个大子数组包含一些较小的子数组。但是，并非所有这些和一些小型阵列都可以独立存在。例如：[7, 8, 9, 10, 11, 12, 13, 14, 15]包含[1, 2, 3, 4, 5, 6]，但不包含[1, 2, 3], [4, 5, 6], [4, 6, 5]或[7, 8, 9, 10, 11, 12], [11, 12, 13, 14, 15]; 4）也可能存在中间“大数组”：与[111, 222, 333]相比，[111, 222, 333, 444, 555]更小，因此必须排除第一个[111, 222, 333, 444, 555, 777, 888]。 5 *）我想将大数组添加到[111, 222, 333, 444, 555]（最终数组），不小一次，除了案例*** arr2到[1000, 2000, 3000]（最终数组）

我的代码应该做什么？它应该通过arr1并相互反对不同的元素，以便检测n元素是否包含k元素，反之亦然，因为它从开始到结束arr2和从结束到开始{{1} }

更新2.长度比较！

for k in arr1:

for n in reversed(arr1):

它更接近。实际上它几乎就是这样，但它会重复，从数量来看，似乎秩序问题（1）根本不是问题：

if len(n) < len(k):

当然可以开始删除重复项并再次以这种方式运行arr2来摆脱for k in arr1: for n in reversed(arr1): if len(n) < len(k): if set(n).issubset(set(k)): arr2.append(k)，这实际上是arr2 = [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12, 13, 14, 15], [7, 8, 9, 10, 11, 12, 13, 14, 15], [111, 222, 333, 444, 555], [111, 222, 333, 444, 555], [111, 222, 333, 444, 555, 777, 888], [111, 222, 333, 444, 555, 777, 888], [111, 222, 333, 444, 555, 777, 888], [111, 222, 333, 444, 555, 777, 888]]的一部分，但必须有更多优雅的方式。

Answer 1

所以你试图摆脱那些只包含另一个列表中的元素的列表？

def eachMasterList(allLists):
  allSets = [ set(lst) for lst in allLists ]
  for lst, s in zip(allLists, allSets):
    if not any(s is not otherSet and s < otherSet for otherSet in allSets):
      yield lst

要使用此功能，请尝试以下操作：

print(list(eachMasterList([[1, 2, 3], [4, 5, 6], [1, 2, 3, 4, 5, 6], [7,8], [9, 10, 11, 12], [7, 8, 9, 10, 11, 12]])))

Answer 2

您可以使用递归函数：

>>> l =[(1, 3, 2), (4, 5, 6), (1, 2, 3, 4, 5, 6), (7, 8), (9, 10, 11, 12), (7, 8, 9, 10, 11, 12)]

>>> def find_max_sub(l):
...    for i,j in enumerate(l):
...       for t,k in enumerate(l[i+1:],1):
...             if set(j).intersection(k):
...                 return find_max_sub([set(l.pop(i))|set(l.pop(t))]+l)
...    return l
... 
>>> find_max_sub(l)
[(1, 2, 3, 4, 5, 6), (7, 8, 9, 10, 11, 12)]

您只需循环遍历主列表并将列表中的元素与其他元素进行比较，当您找到具有任何交集的子列表时，您可以弹出这些元素并将新子列表添加到主列表，然后使用新列表调用该函数

Answer 3

你有一个很大的列表列表，你想在其中查找很多列表？就像你在大集合中查找任何其他类型的对象一样：将它们（或确切的合适版本）存储在一个集合中以允许快速查找。

列表不能设置元素，但您可以将小列表转换为元组并存储它们：

myindex = set(tuple(sm) for sm in big_list)

然后检查[1, 3, 4]中是否有big_list，您只需说：

if tuple([1, 3, 4]) in myindex:
    ...

如果您想匹配列表而不考虑订单（以便[1, 3, 4]被视为等于[3, 1, 4]），请将它们转换为集合。但不是常规集（它们也不能设置元素），而是frozenset：

myindex = myindex = set(frozenset(sm) for sm in big_list)

关于它。

Answer 4

你在找这个吗？

def get_subset_list():
    for arr in arrays:
        others = [x for x in arrays if x != arr]
        for other in others:
            for val in arr:
                if val not in other:
                    break
            else:
                break
        else:
            yield arr

import json
x = get_subset_list()
print set([json.dumps(y) for y in x])

如何以优雅的方式检查数组是否包含数组？

4 个答案: