对于这个递归函数，我如何使下面的 python 代码更有效和更简单？

如何解决对于这个递归函数，我如何使下面的 python 代码更有效和更简单？

我需要使用递归函数来查找作为输入提供的两个整数 N、M 之间的所有回文素数。 （包括起点和终点）。

• 回文数是从正面和背面读取相同的数字。 例如：212、44、9009、4567654。
• 要计算一个数字是否为回文数，请将您的答案合并到 问题 1。
• 质数是大于 1 且只能被 1 和它自身整除的数。

例如：3、11、313。

回文素数的一些例子是：11、191、313。

你可以假设 N>1，N≤M。

你不能在你的程序中使用任何形式的循环！

我在下面包含了我的代码，想知道是否可以检查它，如果有可能，你能解释一下我如何使它更简单或有效。（你能包括注释来解释不同的代码行吗？ )

import sys
sys.setrecursionlimit (30000)

def palindromeprimes(M,N,lst):
    def pr_num(point,end = 1):
        if end == point:
            return True
        else:
            if point % end == 0 and end != 1:
                return False
            else:
                return pr_num(point,end + 1)   
            
    def reverse(sub_phrase):
        if sub_phrase == "":
            return sub_phrase
        else:
            return reverse(sub_phrase[1:]) + sub_phrase[0]    
        
    if M >=N:
        if pr_num(M,1):
            if M==int(reverse(str(M))):
                lst.append(M)
        palindromeprimes (M-1,lst)
lst = []
N = eval(input("Enter the starting point N: \n"))
M = eval(input("Enter the ending point M: \n"))
print ("The palindromic primes are:")  

palindromeprimes(M,lst)

array1 = sorted(lst)
def printlst(array1,pos=0):
    if pos<len(array1):
        print(array1[pos])
        return printlst(array1,pos+1)
printlst(array1,0)

样本输入/输出：

Enter the starting point N:
200
Enter the ending point M:
800
The palindromic primes are:
313
353
373
383
727
757
787
797

解决方法

这个怎么样。这个更短。而且更快。

CREATE STREAM IF NOT EXISTS n_plus_o_plus_u AS
    SELECT 
        u_stream.uuid AS uuid 
    FROM n_plus_o
    INNER JOIN u_stream WITHIN 10 MINUTES ON n_plus_o.uuid = u_stream.uuid ;

样品测试

import sys
sys.setrecursionlimit(4000)
def check_prime(num_list,number):
    if num_list==[]:
        print(number)
    else:
        num=num_list[0]
        
        
        if number % num == 0:
            pass
        else:
            num_list.pop(0)
            check_prime(num_list,number)
def check_palindrome(nums):
    nums1=nums[::-1]
    if nums1==nums:
        new_list=list(range(2,int(nums)))
        check_prime(new_list,int(nums))
def check_done(lists):
    if lists!=[]:
        check_palindrome(str(lists[0]))
        lists.pop(0)
        check_done(lists)


start_int=int(input("Enter starting number: "))
ending_int=int(input("Enter ending number: "))
list1=list(range(start_int,ending_int+1))
check_done(list1)

,

真的需要递归吗？

如果不是，则此代码更快更高效。

def isPalindrome(s):
    if (s == s[::-1]) and isPrime(int(s)):
        return True
    return False


def isPrime(number):
    for i in range(2,number):
        if (number % i) == 0:
            return False
    return True


N = eval(input("Enter the starting point N: \n"))
M = eval(input("Enter the ending point M: \n"))
print("The palindromic primes are:")

for N in range(N,M):
    if isPalindrome(str(N)):
        print(N)

,

我相信最好的解决方案是部分独立于整体是可以理解和测试的。此解决方案在大数字上应该更快：

def palindromeprimes(start,end):
    def is_prime(number,divisor=3):
        if number < 2:
            return False

        if number % 2 == 0:
            return number == 2

        if divisor * divisor > number:
            return True

        if number % divisor == 0:
            return False

        return is_prime(number,divisor + 2)

    def is_palindrome(string):
        if len(string) <= 1:
            return True

        if string[0] != string[-1]:
            return False

        return is_palindrome(string[1:-1])

    numbers = []

    if start <= end:
        if is_palindrome(str(start)) and is_prime(start):
            numbers.append(start)

        numbers.extend(palindromeprimes(start + 1,end))

    return numbers

print(palindromeprimes(200,800))

一些特性包括不对偶数进行质数测试（速度和递归次数都少）；在素数测试之前进行回文测试（首先进行更简单/更快的测试）；没有额外的参数，也没有预先计算列表；没有隐式循环（例如 range() 运算符）。

输出

% python3 test.py
[313,353,373,383,727,757,787,797]
%