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

📅  最后修改于: 2021-04-22 01:36:29             🧑  作者: Mango

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

例子:

方法:想法是在给定的基数N中生成所有可左截断的质数,并根据以下观察结果打印出最大的可左截断的质数:

  • 初始化一个数组,例如候选人[] ,以将所有可能的左可截短素数存储在给定的基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 3 N),其中k是在Miller-Rabin素数测试中执行的回合
辅助空间: O(X) ,其中X是以N为底的左截尾素数的总数