python - 返回最长连续的测距整数序列

Question

问题
下面的代码显示了一种我希望通过尝试某种不同的方法来改进的算法。
现在是漫长的解释。
给定一个整数列表，我希望找到与序列的原始起点相同或更高的每个连续整数序列序列也应该比排名较高的连续序列长。
你可能很困惑。让我来解释一下我的意思。
当我有一个整数列表时，我可以将它展开来表示它的范围例子：

2,1,1,3,3,1

变成

-,-,-,3,3,-
2,-,-,2,2,-
1,1,1,1,1,1

如您所见，每个整数值都在其相应的行中，递减的值填充其下的列。注意，上述过程不必在算法中执行。
现在我想返回一个级别/行上的每个序列，这些序列没有被另一个序列完全覆盖。
例如，这里没有列表中的0个，这意味着它们的基线具有最大长度。现在返回的值之一是[1，6，5]：1表示序列包含的数字，6表示序列的长度，5表示序列的最终索引。
中间一排，我们只有两个。我们来分析一下。这里的第一个序列是开头的两个它的返回值为[2,1,0]然后是两个空格，之后是另外两个空格。但是等等！还没加呢！上面的三个完全覆盖了两个序列。所以实际上，我们已经排完了。
在最上面一行，我们可以添加三个序列：[3,2,4]
最后的结果是

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

再举几个例子
为了澄清，这里有几个例子它们是100%完整和正确的，我已经检查了多次。

[3,3,3,2,1] -> [[1,5,4],[2,4,3],[3,3,2]] 

[7,7,3,0,1,2,3] -> [[1,3,6],[2,2,6],[3,3,2],[3,1,6],[7,2,1]]

[0,0,0] -> []

[0,1,0,4,0,1,0] -> [[1,1,1],[4,1,3],[1,1,5]]

到目前为止我的方法
我想到了一个相当复杂的方法，它是在列表中的值从最高的匹配项迭代到1。每当我遇到一个序列，我都会保存它，然后将它的所有元素都减一。不过，在执行后一个操作之前，我会检查序列的起始索引和结束索引的左边或右边的值是否分别低于序列中的数字。例如，在以下情况下是这样的：

[2,4,4,4,1], looking at 3*4
[1,8,8], looking at 2*8
[9,9,9,8], looking at 3*9
[9,7,4], looking at 2*7 (sequence doesn't formally exist as [7,7], 
                         but would be in the results, as described above)

如果是这样的话，那么我将序列的所有值递减以适应它们的环境。
让我们用一个简单的列表来运行这个过程：

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

我们先检查四人组。一开始就有两个，多方便啊！没有左边的值，右边的值是2…所以一比二小。所以…我们可以高兴地减少列表中的所有元素。不过，在这之前，我们将序列的值（[4,2,1]）传递给一个变量。之后，我们读取最高的周围整数值，将其分配给序列的所有元素，并得到：

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

啊哈！现在它与右边的2平了我们现在要做的就是检查是否有值为3的整数。嗯，赫扎，有个小家伙坐在角落里。同样，我们保存序列的值（[3,1,5]），并为每个元素分配最高的环绕整数，这恰好是1:

[2,2,2,1,1,1]

一次又一次我们返回[2,3,2]。

[1,1,1,1,1,1]

为什么，看起来不熟悉。我们只要返回[1,6,5]就可以了。
最终输出为[[4,2,1]，[3,1,5]，[2,3,2]，[1,6,5]]。
懒得再举更多的例子…不管怎么说，这篇文章太长了。
代码
是的，我已经有一些代码了。这里是：

def ListProcessing(listL, length, freq):

    #to detect end of array and not miss out on last sequences
    listL.extend([0])

    #Iterating over all unique elements that appear in the list from top to
    #bottom, leaving out elements under or equal to _length_
    for checkNum in reversed(list(set(sorted(listL))-set(range(length)))):
        seqLen = 0
        #Iterate over list
        for index, val in enumerate(listL):
            #current element higher than checkNum?
            #Yes -> increase counter of the sequence length
            if val >= checkNum:
                seqLen += 1
            #No -> Reset seqLen. If seqLen is high enough, replace sequence with
            #      sequence of highest neighbouring elements and yield the seq.
            else:
                if seqLen > freq-1:
                    newVal = max(val, listL[index-seqLen-1])
                    listL[index-seqLen:index] = [newVal] * seqLen
                    yield(checkNum, seqLen, index-1)
                seqLen = 0

但它做的正是我想要它做的。
那么-问题是什么？
如上所述，我的算法已经可以工作了。但这种方法似乎有点复杂，我相信有更好的方法我很想听听另一种方法。
当前正在使用array.array模块实现此功能，以使其更快如果有人想尝试用它来实现自己的方法，我会非常激动。
即使是未实现的概念/想法也受欢迎！

Answer 1

这是一个有趣的问题，这里有另一种解决方法举个例子，seq = [4, 4, 2, 1, 1, 3, 2]请注意，我们可以首先返回与遵循您的问题中列出的规则的最长可能序列相关联的结果结果的形式为[min(seq), len(seq), len(seq) - 1]或[1, 7, 6]。
现在您知道，所有其他有效结果只能包含大于min(seq)的值，因此我们可以将seq拆分为两个子序列[4, 4, 2]和[3, 2]并在这些子序列中查找有效结果我们可以递归地对每个子序列重复这个分裂过程，直到我们没有子序列为止。
在如下代码中：

def recListProcessing(seq, threshold=0, min_len=1):
    len_seq = len(seq)
    if len_seq < min_len:
        return

    min_value = min(seq)
    if min_value > threshold:
        yield (min_value, len_seq, len_seq - 1)

    start = 0
    while start < len_seq:
        try:
            end = seq.index(min_value, start)
        except ValueError:
            end = len_seq
        sub_seq = seq[start:end]
        for item in recListProcessing(sub_seq, threshold, min_len):
            yield (item[0], item[1], item[2] + start)
        start = end + 1