Open In App

Largest Left-Truncatable Prime in a given base

Improve
Improve
Like Article
Like
Save
Share
Report

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

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:

C++




#include <bits/stdc++.h>
using namespace std;
 
// Function to check if a number
// is even or not
bool is_even(int n) {
    return n % 2 == 0;
}
 
// Function to compute base^exp mod m
int expmod(int base, int exp, int m) {
    if (exp == 0) {
        return 1;
    }
    else if (is_even(exp)) {
        return (int)pow(expmod(base, exp / 2, m), 2) % m;
    }
    else {
        return base * expmod(base, exp - 1, m) % m;
    }
}
 
// Function to check if a is
// a composite number || not
// using Miller-Rabin primality test
bool try_composite(int a, int d, int n, int s) {
    // ((a) ^ d) % n equal to 1
    if (expmod(a, d, n) == 1) {
        return false;
    }
 
    for (int i = 0; i < s; i++) {
        if (expmod(a, pow(2, i) * d, n) == n - 1) {
            return false;
        }
    }
    return true;
}
 
// Function to check if a number
// is prime || not using
// Miller-Rabin primality test
bool is_probable_prime(int n, int k) {
    // Base Case
    if (n == 0 || n == 1) {
        return false;
    }
    if (n == 2) {
        return true;
    }
    if (n % 2 == 0) {
        return false;
    }
 
    int s = 0;
    int d = n - 1;
 
    while (true) {
        int quotient = d / 2;
        int remainder = d % 2;
        if (remainder == 1) {
            break;
        }
        s += 1;
        d = quotient;
    }
 
    // Iterate given number of k times
    for (int i = 0; i < k; i++) {
        int a = rand() % (n - 2) + 2;
 
        // 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
int largest_left_truncatable_prime(int base) {
    // Stores count of digits
    // in a number
    int radix = 0;
 
    // Stores left-truncatable prime
    vector<int> candidates{0};
 
    // Iterate over the range [0, infinity]
    while (true) {
        // Store left-truncatable prime
        // containing i digits
        vector<int> new_candidates;
 
        // Stores base ^ radix
        int multiplier = pow(base, radix);
         
        // Iterate over all possible
        // value of the given base
        for (int i = 1; i < base; i++)
        {
             
            // Append the i in radix-th digit
            // in all (i - 1)-th digit
            // left-truncatable prime
            for (auto x : candidates)
                 
                 
                // If a number with i digits
                // is prime
                if (is_probable_prime(
                    x + i * multiplier, 30))
                    new_candidates.push_back(
                         x + i * multiplier);
        }
                          
        // If no left-truncatable prime found
        // whose digit is radix                
        if (new_candidates.size() == 0)
            return *max_element(candidates.begin(), candidates.end());
             
             
        // Update candidates[] to all
        // left-truncatable prime
        // whose digit is radix
        candidates = new_candidates;
         
         
        // Update radix
        radix += 1;
    }
}
 
 
// Driver Code
int main()
{
    int N = 3;
    int ans = largest_left_truncatable_prime(N);
    cout << ans ;
}
 
// This code is contributed by Phasing17.


Java




import java.util.*;
 
class Main {
 
  // Function to check if a is a composite number || not
  // using Miller-Rabin primality test
  static boolean TryComposite(long a, long d, long n, int s)
  {
 
 
    // ((a) ^ d) % n equal to 1
    long x = ModPow(a, d, n);
    if (x == 1 || x == n - 1) {
      return false;
    }
 
    for (int i = 0; i < s; i++) {
      x = ModPow(x, 2, n);
      if (x == n - 1) {
        return false;
      }
    }
 
    return true;
  }
 
  // Function to compute base^exp mod m
  static long ModPow(long baseNumber, long exponent,
                     long modulus)
  {
    long result = 1;
    while (exponent > 0) {
      if ((exponent & 1) == 1) {
        result = (result * baseNumber) % modulus;
      }
 
 
      baseNumber
        = (baseNumber * baseNumber) % modulus;
      exponent >>= 1;
    }
 
    return result;
  }
 
  // Function to check if a number is prime || not using
  // Miller-Rabin primality test
  static boolean IsProbablePrime(long n, int k)
  {
    // Base Case
    if (n == 0 || n == 1) {
      return false;
    }
    if (n == 2) {
      return true;
    }
    if (n % 2 == 0) {
      return false;
    }
 
 
    long d = n - 1;
    int s = 0;
    while (d % 2 == 0) {
      s++;
      d /= 2;
    }
 
    Random rnd = new Random();
    // Iterate given number of k times
    for (int i = 0; i < k; i++) {
      long a = rnd.nextInt(-2 + (int)n - 1) + 2;
 
      // If a is a composite number
      if (TryComposite(a, d, n, s)) {
        return false;
      }
    }
    // No base tested showed
    // n as composite
    return true;
  }
 
  // Function to find the largest
  // left-truncatable prime number
  static long LargestLeftTruncatablePrime(int baseNumber)
  {
    // Stores count of digits
    // in a number
    int radix = 0;
 
 
    // Stores left-truncatable prime
    long[] candidates = { 0 };
 
    // Iterate over the range [0, infinity]
    while (true) {
      long[] newCandidates = new long[0];
      long multiplier
        = (long)Math.pow(baseNumber, radix);
      for (int i = 1; i < baseNumber; i++) {
        for (int j = 0; j < candidates.length;
             j++) {
          if (IsProbablePrime(
            candidates[j] + i * multiplier,
            30)) {
            long[] temp = new long[newCandidates.length + 1];
            temp[newCandidates.length ] = candidates[j]
              + i * multiplier;
            newCandidates = temp;
          }
        }
      }
 
      if (newCandidates.length == 0) {
        return candidates[0];
      }
 
      candidates = newCandidates;
      radix++;
    }
  }
 
  // Driver code
  public static void main(String[] args)
  {
    System.out.println(LargestLeftTruncatablePrime(3));
  }
}
 
// This code is contributed by phasing17.


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)


C#




using System;
 
class Program
{
 
  // Function to check if a is a composite number || not
  // using Miller-Rabin primality test
  static bool TryComposite(long a, long d, long n, int s)
  {
 
    // ((a) ^ d) % n equal to 1
    long x = ModPow(a, d, n);
    if (x == 1 || x == n - 1) {
      return false;
    }
 
    for (int i = 0; i < s; i++) {
      x = ModPow(x, 2, n);
      if (x == n - 1) {
        return false;
      }
    }
 
    return true;
  }
 
  // Function to compute base^exp mod m
  static long ModPow(long baseNumber, long exponent,
                     long modulus)
  {
    long result = 1;
    while (exponent > 0) {
      if ((exponent & 1) == 1) {
        result = (result * baseNumber) % modulus;
      }
 
      baseNumber
        = (baseNumber * baseNumber) % modulus;
      exponent >>= 1;
    }
 
    return result;
  }
 
  // Function to check if a number is prime || not using
  // Miller-Rabin primality test
  static bool IsProbablePrime(long n, int k)
  {
    // Base Case
    if (n == 0 || n == 1) {
      return false;
    }
    if (n == 2) {
      return true;
    }
    if (n % 2 == 0) {
      return false;
    }
 
    long d = n - 1;
    int s = 0;
    while (d % 2 == 0) {
      s++;
      d /= 2;
    }
 
    Random rnd = new Random();
    // Iterate given number of k times
    for (int i = 0; i < k; i++) {
      long a = rnd.Next(2, (int)n - 1);
 
      // If a is a composite number
      if (TryComposite(a, d, n, s)) {
        return false;
      }
    }
    // No base tested showed
    // n as composite
    return true;
  }
 
  // Function to find the largest
  // left-truncatable prime number
  static long LargestLeftTruncatablePrime(int baseNumber)
  {
    // Stores count of digits
    // in a number
    int radix = 0;
 
    // Stores left-truncatable prime
    long[] candidates = { 0 };
 
    // Iterate over the range [0, infinity]
    while (true) {
      long[] newCandidates = new long[0];
      long multiplier
        = (long)Math.Pow(baseNumber, radix);
      for (int i = 1; i < baseNumber; i++) {
        for (int j = 0; j < candidates.Length;
             j++) {
          if (IsProbablePrime(
            candidates[j] + i * multiplier,
            30)) {
            Array.Resize(ref newCandidates,
                         newCandidates.Length
                         + 1);
            newCandidates[newCandidates.Length
                          - 1]
              = candidates[j]
              + i * multiplier;
          }
        }
      }
 
      if (newCandidates.Length == 0) {
        return candidates[0];
      }
 
      candidates = newCandidates;
      radix++;
    }
  }
 
  // Driver code
  static void Main(string[] args)
  {
    Console.WriteLine(LargestLeftTruncatablePrime(3));
  }
}
 
// This code is contributed by phasing17.


Javascript




// JS program to implement
// the above approach
 
function is_even(n) {
    return n % 2 === 0;
}
 
function expmod(base, exp, m) {
    return exp === 0 ? 1
           : is_even(exp) ? expmod(base, exp / 2, m) ** 2 % m
           : base * expmod(base, exp - 1, m) % m;
}
 
// Function to check if a is
// a composite number || not
// using Miller-Rabin primality test
function try_composite(a, d, n, s)
{
    // ((a) ^ d) % n equal to 1
    if (expmod(a, d, n) == 1)
        return false
 
    for (var i = 0; i < s; i++)
        if (expmod(a, 2**i * d, n) == n-1)
            return false
    return true
}
 
// Function to check if a number
// is prime || not using
// Miller-Rabin primality test
function is_probable_prime(n, k)
{
    // Base Case
    if (n == 0 || n == 1)
        return false
 
    if (n == 2)
        return true
 
    if (n % 2 == 0)
        return false
 
    let s = 0
    let d = n-1
 
    while (true)
    {
 
        var quotient = Math.trunc(d/2)
        var remainder = d % 2;
        if (remainder == 1)
            break
        s += 1
        d = quotient
    }
     
    // Iterate given number of k times
    for (var i = 0; i < k; i++)
    {
        var a = Math.random() * (n - 2)  + 2
 
        // 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
function largest_left_truncatable_prime(base)
{
    // Stores count of digits
    // in a number
    let radix = 0
 
    // Stores left-truncatable prime
    let candidates = [0]
 
    // Iterate over the range [0, infinity]
    while (true)
    {
        // Store left-truncatable prime
        // containing i digits
        let new_candidates = []
 
        // Stores base ^ radix
        let multiplier = base ** radix
         
         
        // Iterate over all possible
        // value of the given base
        for (var i = 1; i < base; i++)
        {
             
            // Append the i in radix-th digit
            // in all (i - 1)-th digit
            // left-truncatable prime
            for (let x of candidates)
                 
                 
                // If a number with i digits
                // is prime
                if (is_probable_prime(
                    x + i * multiplier, 30))
                    new_candidates.push(
                         x + i * multiplier)
        }
                          
        // If no left-truncatable prime found
        // whose digit is radix                
        if (new_candidates.length == 0)
            return Math.max(...candidates)
             
             
        // Update candidates[] to all
        // left-truncatable prime
        // whose digit is radix
        candidates = new_candidates
         
         
        // Update radix
        radix += 1
    }
}
 
 
// Driver Code
let N = 3
let ans = largest_left_truncatable_prime(N)
console.log(ans)
 
// This code is contributed by Phasing17.


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



Last Updated : 10 Jan, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads