Largest Left-Truncatable Prime in a given base

• Difficulty Level : Easy
• Last Updated : 26 Dec, 2020

Given an integer N representing the base of a number, the task is to find the largest left-truncatable prime in the given base N.

Examples:

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

Input: N = 5
Output: 7817

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: The idea is to generate all left-truncatable prime numbers in the given base N and print the largest left-truncatable prime number based on the following observations:

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.

• Initialize an array, say candidates[], to store the all possible left truncatable prime numbers in the given base N.
• Iterate over the range [0, infinity] using variable i and insert all the left truncatable prime numbers of digits i. If no left truncatable number consisting of i digits is found, then return from the loop.
• Finally, print the maximum element present in the array candidates[].

Below is the implementation of the above approach:

Python3

 # Python program to implement# the above approachimport random  # Function to check if a is# a composite number or not# using Miller-Rabin primality testdef 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 testdef 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 numberdef largest_left_truncatable_prime(base):      # Stores count of digits    # in a number    radix = 0      # Stores left-truncatable prime    candidates =       # 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 Codeif __name__ == "__main__":     N = 3    ans = largest_left_truncatable_prime(N)    print(ans)
Output:
23

Time Complexity: O(k * log3N), where k is the rounds performed in Miller-Rabin primality test
Auxiliary Space: O(X), where X is the total count of left-truncatable prime in base N

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up