Python:找到所有长度为k的回文序列,总和为n

时间:2018-11-28 16:52:12

标签: python-3.x combinatorics palindrome

我正在尝试找到所有长度为k的回文序列,总和为n。我有一个具体的例子(k = 6):

def brute(n):
J=[]
for a in range(1,n):
    for b in range(1,n):
        for c in range(1,n):
            if (a+b+c)*2==n:
                J.append((a,b,c,c,b,a))
return(J)

输出给我类似的东西

[(1, 1, 6, 6, 1, 1),
 (1, 2, 5, 5, 2, 1),
 (1, 3, 4, 4, 3, 1),
 (1, 4, 3, 3, 4, 1),
 (1, 5, 2, 2, 5, 1),
 (1, 6, 1, 1, 6, 1),
 (2, 1, 5, 5, 1, 2),
 (2, 2, 4, 4, 2, 2),
 (2, 3, 3, 3, 3, 2),
 (2, 4, 2, 2, 4, 2),
 (2, 5, 1, 1, 5, 2),
 (3, 1, 4, 4, 1, 3),
 (3, 2, 3, 3, 2, 3),
 (3, 3, 2, 2, 3, 3),
 (3, 4, 1, 1, 4, 3),
 (4, 1, 3, 3, 1, 4),
 (4, 2, 2, 2, 2, 4),
 (4, 3, 1, 1, 3, 4),
 (5, 1, 2, 2, 1, 5),
 (5, 2, 1, 1, 2, 5),
 (6, 1, 1, 1, 1, 6)]

问题是我不知道如何将其推广为n和k的任何值。我听说字典会有所帮助。我是否提到我是python新手? 我们将不胜感激

谢谢

1 个答案:

答案 0 :(得分:1)

这个想法是,我们只需从010**k进行计数,然后将这些“整数”中的每一个视为回文序列。必要时,我们将0留在pad上。因此,对于k==6,0-> [0, 0, 0, 0, 0, 0],1-> [0, 0, 0, 0, 0, 1]等。这列举了所有可能的组合。如果是回文,我们还要检查它是否加起来n

下面是一些代码(应该)为任意nk提供正确的结果,但是效率不高。我将根据您的需要进行优化(如果有必要),并提供一些有关操作方法的提示。

代码如下:

def find_all_palindromic_sequences(n, k):
    result = []
    for i in range(10**k):
        paly = gen_palindrome(i, k, n)
        if paly is not None:
            result.append(paly)
    return result

def gen_palindrome(i, k, n):
    i_padded = str(i).zfill(k)
    i_digits = [int(digit) for digit in i_padded]
    if i_digits == i_digits[::-1] and sum(i_digits) == n:
        return i_digits

要对其进行测试,我们可以这样做:

for paly in find_all_palindromic_sequences(n=16, k=6):
    print(paly)

此输出:

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

看起来与您的结果相似,加上包含0的结果。

提高速度的想法(随着k变大,速度会大大降低):

  1. 这是一个令人尴尬的并行问题,请考虑使用多线程/多处理。

  2. i_digits == i_digits[::-1]的回文检查效率不高(在内存和CPU方面)。在起点和终点都有一个指针,并逐个遍历字符直到指针交叉会更好。

  3. 您可以对n的某些值执行一些条件优化。例如,如果n0,那么k的大小无关紧要,唯一的回文将是[0, 0, 0, ..., 0, 0]。再举一个例子,如果n8,我们显然不必生成其中包含9的任何排列。或者,如果n20,而k6,那么我们的排列中就不能有3 9了。假设n相当小,将这种模式推广将大有裨益。实际上,它也以另一种方式起作用。如果n大,则每个排列中可以存在的01的数量是有限的。

  4. 可能有比测试每个整数更好的方法来生成回文。例如,如果我们知道整数X是回文序列,那么X + 1就不是。这很容易显示:的第一位和最后一位不能匹配X + 1,因为我们知道它们必须与X匹配。您可能< / em>能够表明X + 2和X + 3也不是回文,等等。如果您可以概括必须在哪里测试新回文,那么这将是关键。数字理论家可以在这方面提供更多帮助。

HTH。