在python中为嵌套循环创建递归函数

Question

我已经发布了这个问题： Non overlapping pattern matching with gap constraint in python ;两个月前。我只有一个回应。但是解决方案很长，并且对于模式中的每个单词，都会形成一个嵌套循环。有什么方法可以递归形成以下函数？

i=0
while i < len(pt_dic[pt_split[0]]):
    match=False
    ii = pt_dic[pt_split[0]][i]
    #print "ii=" + str(ii)

    # Start loop at next index after ii
    j = next(x[0] for x in enumerate(pt_dic[pt_split[1]]) if x[1] > ii)
    while j < len(pt_dic[pt_split[1]]) and not match:
        jj = pt_dic[pt_split[1]][j]
        #print "jj=" + str(jj)
        if jj > ii and jj <= ii + 2:

            # Start loop at next index after ii
            k = next(x[0] for x in enumerate(pt_dic[pt_split[2]]) if x[1] > jj)
            while k < len(pt_dic[pt_split[2]]) and not match:
                kk = pt_dic[pt_split[2]][k]
                #print "kk=" + str(kk)
                if kk > jj and kk <= jj + 2:

                    # Start loop at next index after kk
                    l = next(x[0] for x in enumerate(pt_dic[pt_split[3]]) if x[1] > kk)
                    while l < len(pt_dic[pt_split[2]]) and not match:
                        ll = pt_dic[pt_split[3]][l]
                        #print "ll=" + str(ll)
                        if ll > kk and ll <= kk + 2:
                            print "Match: (" + str(ii) + "," + str(jj) + "," + str(kk) + "," + str(ll) + ")"
                            # Now that we've found a match, skip indices within that match.
                            i = next(x[0] for x in enumerate(pt_dic[pt_split[0]]) if x[1] > ll)
                            i -= 1
                            match=True
                        l += 1
            k += 1
        j += 1
    i += 1

编辑：对于那些不了解上下文的人：

我想找到总数。出现在序列中的模式的非重叠匹配，间隙约束为 2。

例如。 A B C 是使用某种算法找到的模式。我必须找到出现在诸如 A A B B C D E A B C … 之类的序列中的此模式的总数，其中最大间隙约束为 2。

最大。跨序列看不到间隙，但在属于序列子字符串的模式的两个单词之间可以看到间隙。例如。 Pat: A B C 和 seq: A B D E C B A B A B C D E。

在这种情况下，A B D E C ... 是一个匹配，因为 A、B 和 B、C 之间最多允许两个间隙。接下来我们找到 A B A B C 作为另一个匹配。有趣的是。有两个匹配项， (2 chars b/w A, B and 2 chars b/w B,C) 。但是，我们只会将其视为一个，因为它是重叠匹配。 A B X X X C 无效。

Answer 1

我只是简要地阅读了原始问题。我不确定我是否正确计算了间隙计算部分。我认为您有 L 排序的唯一索引序列，并且代码搜索具有 L 元素的所有列表，其中第 N 个元素来自第 N 个序列并且两个相邻项满足条件prev < next < prev + GAP + 1

无论如何，这个问题是关于嵌套循环的。

下面代码的基本思想是将一个序列列表传递给递归函数。此函数从中获取第一个序列并对其进行迭代。剩余的序列被传递给同一函数的其他实例，每个实例都执行相同的操作，即迭代第一个序列并传递其余序列，直到没有要迭代的序列。

在此过程中，正在逐步构建部分解决方案。只有当这个部分解决方案满足条件时，递归才会继续。当所有序列都用尽时，部分解决方案成为最终解决方案。

list_of_seqs= [
    [0, 1, 7, 11, 22, 29],
    [2, 3, 8, 14, 25, 33],
    [4, 9, 15, 16, 27, 34],
]


def found_match(m):
    print(m)

GAP = 2 
def recloop(part, ls):
    if not ls: 
        found_match(part)
        return
    seq, *ls = ls   # this is Python3 syntax
    last = part[-1] if part else None
    # this is not optimized:
    for i in seq:
        if last is None or last < i <= last + GAP + 1:
            recloop(part + [i], ls) 

recloop([], list_of_seqs)

对于 Python2，将标记的行替换为 seq, ls = ls[0], ls[1:]