Given a number N, the task is to count the number of unique prime numbers that can be formed by deleting zero or more digits of the given number.
Examples:
Input: N = 132
Output: 3
Explanation:
The total prime numbers formed by deleting zero or more digits of the given number 132 are 3 i.e. [3, 2, 13].Input: N = 2222
Output: 1
Approach: This problem can be solved using recursion as for every digit there are two choices, either including the digit or not including the digit. For each choice, check whether the number formed is a prime number or not. Follow the steps below to solve this problem:
- Initialize a HashSet say Primes to store the unique prime numbers.
- Declare a function say, uniquePrimeNums(number, ans, index), passing number string N, ans as empty string and index 0 as parameters.
- Base Case: If the index reaches the length of the string, then convert the string to an integer and check whether the number formed is prime or not and if prime, then add the number in the HashSet Primes.
- Call uniquePrimeNums function for both the choice either by taking the character i.e. uniquePrimeNums(number, ans + number.charAt(index), index + 1) or by leaving the character i.e. uniquePrimeNums(number, ans, index + 1).
- After completing the above steps, print the size of the HashSet Primes as the required answer.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to check whether the number // is prime or not bool checkprime( int n)
{ // If n is 1
if (n == 1) {
return false ;
}
// If n is 2 or 3
if (n == 2 || n == 3) {
return true ;
}
// If n is multiple of 2, 3 or 6
else if (n % 2 == 0 || n % 3 == 0
|| n % 6 == 0) {
return false ;
}
// Traversing till sqrt(n)
for ( int i = 6; i * i <= n; i += 6) {
if (n % (i - 1) == 0
|| n % (i + 1) == 0) {
return false ;
}
}
return true ;
} // To store the unique prime numbers set< int > Primes;
// Function to Count the total number // of unique prime number formed by // deleting zero or more digits of the // given number void uniquePrimeNums(string number, string ans, int index)
{ // Base Case
if (index == number.length()) {
if (ans.length() != 0)
// Check whether the number is
// prime or not
if (checkprime(stoi(ans))) {
// Adding to the HashSet
Primes.insert(stoi(ans));
}
return ;
}
// Recursive call by taking the character
// at index
uniquePrimeNums(number,
ans + number[index],
index + 1);
// Recursive call by not taking the
// character
uniquePrimeNums(number, ans, index + 1);
} int main()
{ // Given Input
int number = 132;
// Function Call
uniquePrimeNums( "" + to_string(number), "" , 0);
cout << Primes.size();
return 0;
} // This code is contributed by divyeshrabadiya07. |
// Java program for the above approach import java.io.*;
import java.util.*;
public class GFG {
// Function to check whether the number
// is prime or not
static boolean checkprime( int n)
{
// If n is 1
if (n == 1 ) {
return false ;
}
// If n is 2 or 3
if (n == 2 || n == 3 ) {
return true ;
}
// If n is multiple of 2, 3 or 6
else if (n % 2 == 0 || n % 3 == 0
|| n % 6 == 0 ) {
return false ;
}
// Traversing till sqrt(n)
for ( int i = 6 ; i * i <= n; i += 6 ) {
if (n % (i - 1 ) == 0
|| n % (i + 1 ) == 0 ) {
return false ;
}
}
return true ;
}
// To store the unique prime numbers
static HashSet<Integer> Primes
= new HashSet<>();
// Function to Count the total number
// of unique prime number formed by
// deleting zero or more digits of the
// given number
static void uniquePrimeNums(
String number, String ans, int index)
{
// Base Case
if (index == number.length()) {
if (ans.length() != 0 )
// Check whether the number is
// prime or not
if (checkprime(Integer.parseInt(ans))) {
// Adding to the HashSet
Primes.add(Integer.parseInt(ans));
}
return ;
}
// Recursive call by taking the character
// at index
uniquePrimeNums(number,
ans + number.charAt(index),
index + 1 );
// Recursive call by not taking the
// character
uniquePrimeNums(number, ans, index + 1 );
}
// Driver Code
public static void main(String[] args)
{
// Given Input
int number = 132 ;
// Function Call
uniquePrimeNums( "" + number, "" , 0 );
System.out.println(Primes.size());
}
} |
# Python3 program for the above approach import math
# Function to check whether the number # is prime or not def checkprime(n):
# If n is 1
if (n = = 1 ):
return False
# If n is 2 or 3
if (n = = 2 or n = = 3 ):
return True
# If n is multiple of 2, 3 or 6
elif (n % 2 = = 0 or n % 3 = = 0 or
n % 6 = = 0 ):
return False
# Traversing till sqrt(n)
k = int (math.sqrt(n))
for i in range ( 6 , k + 1 , 6 ):
if (n % (i - 1 ) = = 0 or n % (i + 1 ) = = 0 ):
return False
return True
# Function to Count the total number # of unique prime number formed by # deleting zero or more digits of the # given number def uniquePrimeNums(number, ans, index):
# Base Case
length = len ( list (number))
if (index = = length):
if ( len (ans) ! = 0 ):
# Check whether the number is
# prime or not
if (checkprime( int (ans))):
# Adding to the HashSet
Primes.add( int (ans))
return
# Recursive call by taking the character
# at index
uniquePrimeNums(number, ans + number[index],
index + 1 )
# Recursive call by not taking the
# character
uniquePrimeNums(number, ans, index + 1 )
return
# To store the unique prime numbers Primes = set ()
# Driver code if __name__ = = '__main__' :
# Given Input
number = 132
# Function Call
uniquePrimeNums( str (number), "", 0 )
print ( len (Primes))
# This code is contributed by MuskanKalra1 |
using System;
using System.Collections.Generic;
public class GFG {
static bool checkprime( int n)
{
// If n is 1
if (n == 1) {
return false ;
}
// If n is 2 or 3
if (n == 2 || n == 3) {
return true ;
}
// If n is multiple of 2, 3 or 6
else if (n % 2 == 0 || n % 3 == 0 || n % 6 == 0) {
return false ;
}
// Traversing till sqrt(n)
for ( int i = 6; i * i <= n; i += 6) {
if (n % (i - 1) == 0 || n % (i + 1) == 0) {
return false ;
}
}
return true ;
}
// To store the unique prime numbers
static HashSet< int > Primes = new HashSet< int >();
// Function to Count the total number
// of unique prime number formed by
// deleting zero or more digits of the
// given number
static void uniquePrimeNums(String number, String ans,
int index)
{
// Base Case
if (index == number.Length) {
if (ans.Length != 0)
// Check whether the number is
// prime or not
if (checkprime( int .Parse(ans))) {
// Adding to the HashSet
Primes.Add( int .Parse(ans));
}
return ;
}
// Recursive call by taking the character
// at index
uniquePrimeNums(number, ans + number[index],
index + 1);
// Recursive call by not taking the
// character
uniquePrimeNums(number, ans, index + 1);
}
// Driver Code
static public void Main()
{
int number = 132;
// Function Call
uniquePrimeNums( "" + number, "" , 0);
Console.WriteLine(Primes.Count);
}
} // This code is contributed by maddler. |
<script> // JavaScript implementation of // the above approach // Function to check whether the number
// is prime or not
function checkprime(n)
{
// If n is 1
if (n == 1) {
return false ;
}
// If n is 2 or 3
if (n == 2 || n == 3) {
return true ;
}
// If n is multiple of 2, 3 or 6
else if (n % 2 == 0 || n % 3 == 0
|| n % 6 == 0) {
return false ;
}
// Traversing till sqrt(n)
for (let i = 6; i * i <= n; i += 6) {
if (n % (i - 1) == 0
|| n % (i + 1) == 0) {
return false ;
}
}
return true ;
}
// To store the unique prime numbers
var Primes
= new Set();
// Function to Count the total number
// of unique prime number formed by
// deleting zero or more digits of the
// given number
function uniquePrimeNums(
number, ans, index)
{
// Base Case
if (index == number.length) {
if (ans.length != 0)
// Check whether the number is
// prime or not
if (checkprime(parseInt(ans))) {
// Adding to the HashSet
Primes.add(parseInt(ans));
}
return ;
}
// Recursive call by taking the character
// at index
uniquePrimeNums(number,
ans + number[index],
index + 1);
// Recursive call by not taking the
// character
uniquePrimeNums(number, ans, index + 1);
}
// Driver Code // Given Input
let number = 132;
// Function Call
uniquePrimeNums( "" + number, "" , 0);
document.write(Primes.size);
</script> |
3
Time Complexity: O(2N * sqrt(N))
Auxiliary Space: O(2N)