Python 查找序列中最长的算术级数

假设我有一个递增的数字序列，我想找出序列中最长算术级数的长度。最长算术级数是指具有公共差的递增序列，如[2,4,6,8]或[3,6,9,12]

比如说,， 对于

[5,10,14,15,17]

，

[5,10,15]

是最长的算术级数，长度为3

对于

[10,12,13,20,22,23,30]

，

[10,20,30]

是长度为3的最长算术级数

对于

[7,10,12,13,15,20,21]

，

[10,15,20]

或

[7,10,13]

是长度为3的最长算术级数

本网站 提供了一些问题的见解，即围绕J的循环，并考虑 每3个元素。我打算在Python中使用此算法，我的代码如下：

def length_of_AP(L):
n = len(L)
Table = [[0 for _ in range(n)] for _ in range(n)]
length_of_AP = 2

# initialise the last column of the table as all i and (n-1) pairs have lenth 2
for i in range(n):
        Table[i][n-1] =2

# loop around the list and i, k such that L[i] + L[k] = 2 * L[j]
for j in range(n - 2, 0, -1):
        i = j - 1
        k = j + 1
        while i >= 0 and k < n:
                difference = (L[i] + L[k]) - 2 * L[j]
                if difference < 0:
                        k = k + 1
                else:
                        if difference > 0:
                                i = i - 1
                        else:
                                Table[i][j] = Table[j][k] + 1
                                length_of_AP = max(length_of_AP, Table[i][j])
                                k = k + 1
                                i = i - 1
return length_of_AP

def长度（L）：
n=len（L）
表=[[0表示范围内（n）]表示范围内（n）]
_的长度_AP=2
#初始化表格的最后一列，因为所有i和（n-1）对都有长度2
对于范围（n）中的i：
表[i][n-1]=2
#围绕列表和i，k循环，使得L[i]+L[k]=2*L[j]
对于范围（n-2，0，-1）内的j：
i=j-1
k=j+1
当i>=0且k0：
i=i-1
其他：
表[i][j]=表[j][k]+1
_AP的长度=最大值（_AP的长度，表[i][j]）
k=k+1
i=i-1
返回长度

这个函数在[1,3,4,5,7,8,9]中运行良好，但在[5,10,14,15,20,25,26,27,28,30,31]中不起作用，我应该得到6，但我得到了4。我可以看出原因是，列表中的25、26、27、28可能会分散我的注意力。我如何改变我的函数，使它能给我想要的结果

任何帮助都将不胜感激。

您尝试过吗？
下面是一个快速暴力实现，对于小型数据集，它应该运行得足够快：

def gen(seq):
    diff = ((b-a, a) for a, b in it.combinations(sorted(seq), 2))
    for d, n in diff:
        k = []
        while n in seq:
            k.append(n)
            n += d
        yield (d, k)

def arith(seq):
    return max(gen(seq), key=lambda x: len(x[1]))

In [1]: arith([7, 10, 12, 13, 15, 20, 21])
Out[1]: (3, [7, 10, 13])
In [2]: %timeit arith([7, 10, 12, 13, 15, 20, 21])
10000 loops, best of 3: 23.6 µs per loop
In [3]: seq = {random.randrange(1000) for _ in range(100)}
In [4]: arith(seq)
Out[4]: (171, [229, 400, 571, 742, 913])
In [5]: %timeit arith(seq)
100 loops, best of 3: 3.79 ms per loop
In [6]: seq = {random.randrange(1000000) for _ in range(1000)}
In [7]: arith(seq)
Out[7]: (81261, [821349, 902610, 983871])
In [8]: %timeit arith(seq)
1 loop, best of 3: 434 ms per loop

---

按照您的链接并运行第二个示例，看起来代码实际上找到了正确的圈

5，10，15，20，25，30

但是没有找到合适的长度。我没有花太多时间分析代码，而是分析了这篇文章

//任何两个字母的序列都是AP
//这里我们只对查找的最后一列进行初始化，因为
//所有i和（n-1）对形成大小为2的AP
对于（int i=0；idefine算术级数。我假设您希望[5,10,15]也显示您的代码和预期的输出，以便我们可以帮助您。您尝试了吗？立即出现了高效的算法。非常感谢您的朋友！表确实需要初始化为2，因为微不足道的AP是一对。
# initialise whole table with 2 as all (i, j) pairs have length 2    
Table = [[2 for _ in range(n)] for _ in range(n)]

int sortedArr[] = new int[] {3, 4, 5, 7, 8, 9, 11, 13, 14, 15, 16, 17, 18,  112, 113, 114, 115, 116, 117, 118};