例如：

第二组（由用户定义）：

x = [3, 1, 6]
y = [2, 1, 6]
z = [3, 4, 6]

第一组（来自实验）：

a = [1， 2 ，3,5， 6 ，7]

b = [ 2 ， 1 ，4,3,1,8， 6 ]

c = [6， 3 ，5,7,8， 4 ，2， 6 ]

d = [1， 2 ， 1 ，3,4]

我们接受b和c，因为x是b的子序列，z是c的子序列。同样，我们拒绝a和d，因为x，y或z都不是其中任何一个的后续序列。

神秘（a）应该返回[2,6]这是不可接受的，因为我们在2之后没有访问节点1

神秘（b）应该返回[2,1,6]，这是可以接受的等等

另一个例子（详细）：

要接受某个集合或列表，我需要一些提供某些服务的元素。

ServiceA served by [ 3 , 2 ] ServiceB served by [ 1 , 4 ] ServiceC served by [ 6 ]

Total nodes available to end user [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ]

我们要求他从总节点中选择一个集合或列表。当提供服务的节点以正确的顺序或顺序出现时，我们只接受任何组合。

因此用户可以选择任何具有无限数量节点的集合，只要： 1.节点是总节点的成员。 2.服务顺序是正确的。

示例[1,4,5，＆＃34;节点服务A＆＃34;，7,1,2，＆＃34;节点服务B＆＃34;，＆＃34;节点服务C＆＃34;]

左右接受列表或集合的一般形式是： [some elements，element serve service A，other elements，element service B，more elements，element service c ...]

并且您可以使用上面对应集中的任何元素替换节点服务元素 *如果不清楚请告诉我并在更多示例中解释。

示例三：

让我们在一家拥有10台机器的工厂中思考。该产品需要三种不同的工艺制造。

每台机器都可以执行其中一些过程，或者它们完全不同。机器1可以处理alpha，gama而不是beta。机器2只能处理alpha

每一个到达的原材料都需要通过机器找到路线，条件是最终它应该完成三个过程。

这些过程必须按顺序进行，所以先做Alpha，测试版，然后再做Gama。我们每次都做路线以避免机器超载。

所以现在我需要一个功能来接受或拒绝某些路线建议，以强制每个原材料以正确的顺序通过这些过程。

我当然无法进行所有可能的组合，然后进行比较，因为这会消耗时间并可以无限运行。

由于

Answer 1

我为longest_subsequence

编写了以下代码

a = [1, 2, 3, 5, 6, 7]
b = [2, 1, 4, 3, 1, 8, 6]
c = [6, 3, 5, 7, 8, 4, 2, 6]
d = [1, 2, 1, 3, 4]

x = [3, 1, 6]
y = [2, 1, 6]
z = [3, 4, 6]

group1 = [a, b, c, d]
group2 = [x, y, z]

def longest_subsequence(experiment):
    longest = [] 
    for accepted_sequence in group2:
        it = iter(experiment)
        subsequence = []
        for element in accepted_sequence:
            if element in it:
                subsequence.append(element)

            else:
                break

        if subsequence == list(accepted_sequence):
            return subsequence

        longest = max(longest, subsequence, key=len)

    return longest

for experiment in group1:
    print(longest_subsequence(experiment))

它的工作原理是使用element in iterator，在扫描下一个匹配元素的同时，丢弃其间的其他元素。

代码在group2中找到第一个最长的子序列。不过，由于x位于y之前且两者都是b的子序列，因此x会打印b：

[3]
[3, 1, 6]
[3, 4, 6]
[2, 1]

Answer 2

您的第一个示例可以通过以下代码处理：

group1 = {
    'x': [3, 1, 6],
    'y': [2, 1, 6],
    'z': [3, 4, 6],
}
group2 = {
    'a': [1, 2, 3, 5, 6, 7],
    'b': [2, 1, 4, 3, 1, 8, 6],
    'c': [6, 3, 5, 7, 8, 4, 2, 6],
    'd': [1, 2, 1, 3, 4],
}

def isSubsequence(sub, seq):
    start = 0
    for i in sub:
        try:
            start = seq[start:].index(i)
        except ValueError:
            return False
    return True

for seqName, seq in group2.items(): # Change items for iteritems in Python2
    for subName, sub in group1.items():  # Same than above
        if isSubsequence(sub, seq):
            print("{} is subsequence of {}".format(subName, seqName))
            #break # Uncomment this line if you only want to find the first

输出：

z is subsequence of c
y is subsequence of b
x is subsequence of b

如果取消注释中断，则不会显示最后一行。

正如您所看到的那样，当它们存储在dict中时，我们不会将这些组的顺序考虑在内，如果重要的话，我们可以使用其他容器来保存订单。

isSubsequence()使用str.index()来避免其中一个循环以便更快，并且一旦知道列表不是子序列，它也会返回。如果只需要一个布尔上下文，那么，如果你只需要任何group1项是group2项的子序列而不是其中哪一项是建议的break。

比较python列表中

例如：

另一个例子（详细）：

示例三：

2 个答案: