给定基数中最大的左截断素数

给定一个整数N表示一个数的基数，任务是在给定的基数N 中找到最大的左截断素数。

例子：

Input: N = 3
Output: 23
Explanation:
Left-truncatable prime in base N(= 3) are given below:
(12)₃ = (5)₁₀
(212)₃ = (23)₁₀
Therefore, the largest left-truncatable prime in base N(= 3) is (23)₁₀.

Input: N = 5
Output: 7817

方法：想法是在给定的基数N 中生成所有左截断素数，并根据以下观察打印最大的左截断素数：

If a number containing (i) digits is a left-truncatable prime number, then the numbers formed from the last (i – 1) digits must be a left-truncatable prime number.

Therefore, to make a left-truncatable prime number of digits i, first find all the left-truncatable prime numbers of (i – 1) digits.

• 初始化一个数组，比如Candidate[] ，以在给定的基数 N 中存储所有可能的左截断素数。
• 使用变量i迭代范围[0, infinity]并插入数字 i 的所有左截断素数。如果没有找到由 i 个数字组成的左截断数，则从循环返回。
• 最后，打印数组Candidate[] 中存在的最大元素。

下面是上述方法的实现：

Python3

# Python program to implement
# the above approach
import random
  
# Function to check if a is
# a composite number or not
# using Miller-Rabin primality test
def try_composite(a, d, n, s):
      
    # ((a) ^ d) % n equal to 1
    if pow(a, d, n) == 1:
        return False
  
    for i in range(s):
        if pow(a, 2**i * d, n) == n-1:
            return False
    return True
  
# Function to check if a number
# is prime or not using
# Miller-Rabin primality test
def is_probable_prime(n, k):
  
    # Base Case
    if n == 0 or n == 1:
        return False
  
    if n == 2:
        return True
  
    if n % 2 == 0:
        return False
  
    s = 0
    d = n-1
  
    while True:
        quotient, remainder = divmod(d, 2)
        if remainder == 1:
            break
        s += 1
        d = quotient
      
      
    # Iterate given number of k times 
    for i in range(k):
        a = random.randrange(2, n)
  
        # If a is a composite number
        if try_composite(a, d, n, s):
            return False
  
    # No base tested showed
    # n as composite
    return True
  
  
# Function to find the largest
# left-truncatable prime number
def largest_left_truncatable_prime(base):
  
    # Stores count of digits
    # in a number
    radix = 0
  
    # Stores left-truncatable prime
    candidates = [0]
  
    # Iterate over the range [0, infinity]
    while True:
  
        # Store left-truncatable prime
        # containing i digits
        new_candidates = []
  
        # Stores base ^ radix
        multiplier = base ** radix
          
          
        # Iterate over all possible 
        # value of the given base
        for i in range(1, base):
              
              
            # Append the i in radix-th digit
            # in all (i - 1)-th digit 
            # left-truncatable prime
            for x in candidates:
                  
                  
                # If a number with i digits
                # is prime
                if is_probable_prime(
                    x + i * multiplier, 30):
                    new_candidates.append(
                         x + i * multiplier)
                          
                           
        # If no left-truncatable prime found
        # whose digit is radix                 
        if len(new_candidates) == 0:
            return max(candidates)
              
              
        # Update candidates[] to all 
        # left-truncatable prime
        # whose digit is radix 
        candidates = new_candidates
          
          
        # Update radix
        radix += 1
  
  
# Driver Code
if __name__ == "__main__": 
    N = 3
    ans = largest_left_truncatable_prime(N)
    print(ans)

输出：

23

时间复杂度： O(k * log ³ N)，其中 k 是在 Miller-Rabin 素性测试中执行的轮次
辅助空间： O(X) ，其中X是基数 N 中左截断素数的总数