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

给定一个整数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.

• 初始化一个数组，例如候选人[] ，以将所有可能的左可截短素数存储在给定的基N中。
• 使用变量i在[0，infinity]范围内进行迭代，并插入数字i的所有左可截断素数。如果找不到由i位数组成的左可截断数字，则从循环返回。
• 最后，打印出现在数组候选人中的最大元素[]。

下面是上述方法的实现：

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为底的左截尾素数的总数