python中的回文数

Question

试图找到两个三位数乘积的最大回文数。 在我查找效率更高且更重要的是可行的解决方案之前，您能告诉我我的代码有什么问题吗？ 我只是不断得到空集。

def palindrome():
    n = 100
    m = 100
    palind = []
    while n<=999:
        while m<=999:
            prod = n * m
            if str(prod) == str(prod)[::-1] and prod > palind[0]:
                palind.pop(0)
                palind.append(prod)
            return palind
            m = m + 1
        n = n + 1
        return palind

print palindrome()

Answer 1

当无法返回 i*j > 最大记录并正确返回 906609 时，此快捷方式（请注意，如果您使用的是 python 2，以下内容对您有用，但您更愿意使用xrange而不是range以避免在内存中创建不必要的列表）：

def palindrome(floor=0, upto=999):
    '''
    return the largest palindrome product for all number from (but not including)
    floor to (and including) upto 
    '''
    start = upto
    largest = None
    for i in range(start, floor, -1): # decreasing from upto
        if i * upto < largest: # if True, impossible for higher product from combo
            break 
        for j in range(start, i-1, -1): # decrease from upto to not including i-1
            product = i*j
            if str(product) == str(product)[::-1]:
                if product > largest:
                    largest = product
    return largest

用法：

>>> palindrome(99,999)
906609
>>> palindrome(10,13)
121
>>> palindrome(0,10)
9

捷径很重要，因为如果给出一个非常大的数字，它可能需要很长时间才能返回：

>>> palindrome(upto=100000000)
9999000000009999L

我还创建了一个生成器，它命中从 0 到 999 的每个组合，它返回 906609。

def palindrome(upto=1000):
    return max(i*j for i in range(upto) for j in range(upto) 
                if str(i*j) == str(i*j)[::-1])

但是当运行这个回文时：

>>> palindrome(upto=100000000)

完整搜索将搜索所有 100000000^2，并且花费的时间太长。

我最初是这样写的，想法是它会捷径并避免迭代所有可能的组合，但这是不正确的，它返回 888888：

def palindrome():
    start = 999
    largest = 0
    for i in range(start, 0, -1): # decreasing from 999
        if i * 999 < largest:
            return largest
        for j in range(start, i, -1): # decreasing from 999 to i
            if str(i*j) == str(i*j)[::-1]:
                largest = i*j

它首先将 999 乘以 999，然后将 998 乘以 999，然后

998*998
997*999
997*998
997*997
...

但结果并不是单调递减的（也就是说，不能保证每个结果都小于前一个。）

Answer 2

你有3个问题。

问题一：早退。

while n<=999:
    while m<=999:
        prod = n * m
        if str(prod) == str(prod)[::-1] and prod > palind[0]:
            palind.pop(0)
            palind.append(prod)
        # Here
        return palind
        m = m + 1
    n = n + 1
    # And here
    return palind

return语句意味着函数现在结束了。 它停在原地，调用者获得返回值，调用者继续前进。 在函数完全完成其工作之前，您不想这样做。 当函数完成计算时，让我们将return移到循环之后。

问题 2： palind[0]未初始化。

while n<=999:
    while m<=999:
        prod = n * m
        #                                           Here  v
        if str(prod) == str(prod)[::-1] and prod > palind[0]:
            palind.pop(0)
            palind.append(prod)
        m = m + 1
    n = n + 1
return palind

假设你的程序正在运行并且它找到了它的第一个回文。 它试图将它与palind[0]进行比较，但没有palind[0] ！ 您需要取第一个回文而不尝试将其与不存在的回文进行比较。 让我们解决这个问题。

问题 3：不重置m 。

palind = None
while n<=999:
    while m<=999:
        prod = n * m
        if str(prod) == str(prod)[::-1]:
            if palind is None or prod > palind:
                palind = prod
        m = m + 1
    n = n + 1
return palind

在n循环的第一次迭代之后，您需要使用n=101返回所有可能的m值。 你不这样做； 您的代码将m保持在1000 ，因此它不会再次通过内部循环。 您可以显式重置m ，但使用for循环而不是while s 要容易得多。 修复了所有 3 个问题后，您的代码看起来像

palind = None
for n in xrange(100, 1000):
    for m in xrange(100, 1000):
        prod = n * m
        if str(prod) == str(prod)[::-1]:
            if palind is None or prod > palind:
                palind = prod
return palind

Answer 3

1. 在外部 while 循环的每次迭代之后，您不会重新初始化m = 100

2. 你早点回来。 去掉内循环中的return语句

3. 最后return陈述不应被外while循环中。

4. 您从未初始化palind列表（感谢@user2357112）

建议：

1. 不要使用列表来维护最大的数字。 一个简单的变量就足够了。

2. 您不必在同一表达式中将数字两次转换为字符串。 将字符串化的数字存储在变量中。

3. 使用range函数循环数字

如果我要编写这个程序，我会这样做

from itertools import product
def palindrome():
    numbers, result = range(1000, 100, -1), -1
    for num1, num2 in product(numbers, repeat = 2):
        prod  = num1 * num2
        sprod = str(prod)
        if sprod == sprod[::-1] and prod > result:
            result = prod
    return result

print palindrome()   # 906609

Answer 4

def isPalindrome(self, x: int):
    temp = 0
    x1 = x
    while x > 0:
        y = x % 10
        temp = temp * 10 + y
        x = x//10

    if(temp == x1):
        return True
    else:
        return False

Answer 5

这可能无法回答问题，但是如果您想在范围之间获得回文数，您可以这样做

def getPalindrome(lower, upper):
  listPalind = []
  for n in range(lower, upper):
    if str(n) == str(n)[::-1]:
      listPalind.append(n)
  return listPalind

# Usage
print(getPalindrome(100, 300))

# Results
[101, 111, 121, 131, 141, 151, 161, 171, 181, 191, 202, 212, 222, 232, 242, 252, 262, 272, 282, 292]

Answer 6

def is_palindromic(s):
    if s == s[::-1]:
        return True
    else:
        return False

palind = []
    for i in range(100, 1000):
        for j in range(100,1000):
            product = i * j
            if is_palindromic(str(product)):
                palind.append(product)
    return max(palind)

#结果：906609