python中的回文数字

您有3个问题。

问题1：提前返回。

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循环而不是whiles要容易得多。解决了所有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

当无法返回一个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
...

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

1. 在每次外部while循环迭代后，您没有重新初始化m = 100

2. 你很早就回来了。删除内部循环中的return语句

3. 最后一个return语句应该NOT在外部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

这可能不能回答问题，但如果你想获得范围之间的回文数，你可以这样做

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]

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