Given two integers D and K. The task is to find the smallest number N which has at least K prime divisors and the difference between each pair of divisors is at least D.
Examples
Input: D = 3, K = 2
Output: 55
Explanation: It is smallest number which has 4 divisors 1 and 2 prime divisors 5, 11 and their difference between any of the pair is D.Input: D = 1, K = 4
Output: 210
Explanation: It is the smallest number which has 5 divisors 1 and 4 prime divisors 2, 3, 5, 7, and their difference between any of the pair is D.
Approach: This problem can be solved by using the Sieve of Eratosthenes Follow the steps below to solve the given problem.
- Make a sieve of Eratosthenes.
- Initialize a variable firstDivisor and store D + 1.
- Iterate firstDivisor by 1 until it becomes prime.
- Initialize SmallestNumber = FirstDivisor + D.
- Now iterate the loop and increment SmallestNumber until we get K -1 primes.
- And, the product with all divisors and return the product.
Below is the implementation of the above approach.
// C++ program for above approach #include <bits/stdc++.h> using namespace std;
const int N = 1000000;
// Function of Sieve of Eratosthenes void SieveOfEratosthenes(vector< bool >& prime)
{ for ( int p = 2; p * p <= N; p++) {
if (prime[p] == true ) {
for ( int i = p * p; i <= N; i += p)
prime[i] = false ;
}
}
} // Function to find smallest // number with given conditions int SmallestNumber(vector< bool > prime,
int D, int K)
{ // Initialize first with D + 1
// because 1 is also a divisor
int FirstDivisor = D + 1;
while (FirstDivisor < N
and !prime[FirstDivisor]) {
++FirstDivisor;
}
// Now value of K is decrement by 1
K--;
// Initialize Divisor with First + D
// to maintain a difference D
// We get Remaining divisor
int SmallestNumber = FirstDivisor;
int Divisor = FirstDivisor + D;
// Maintain previous divisor
// to maintain difference
int prevDivisor = FirstDivisor;
while (K > 0 and SmallestNumber < N) {
if (prime[Divisor]
and Divisor - D >= prevDivisor) {
SmallestNumber *= Divisor;
prevDivisor = Divisor;
K--;
}
Divisor++;
}
// Return the final answer
return SmallestNumber;
} // Driver Code int main()
{ vector< bool > prime(N, true );
SieveOfEratosthenes(prime);
int D = 1;
int K = 4;
// Function Call
cout << SmallestNumber(prime, D, K);
return 0;
} |
// Java program to implement // the above approach import java.util.*;
class GFG
{ static int N = 1000000 ;
// Function of Sieve of Eratosthenes static void SieveOfEratosthenes( boolean [] prime)
{ for ( int p = 2 ; p * p < N; p++) {
if (prime[p] == true ) {
for ( int i = p * p; i < N; i += p)
prime[i] = false ;
}
}
} // Function to find smallest // number with given conditions static int SmallestNumber( boolean [] prime,
int D, int K)
{ // Initialize first with D + 1
// because 1 is also a divisor
int FirstDivisor = D + 1 ;
while (FirstDivisor < N
&& !prime[FirstDivisor]) {
++FirstDivisor;
}
// Now value of K is decrement by 1
K--;
// Initialize Divisor with First + D
// to maintain a difference D
// We get Remaining divisor
int SmallestNumber = FirstDivisor;
int Divisor = FirstDivisor + D;
// Maintain previous divisor
// to maintain difference
int prevDivisor = FirstDivisor;
while (K > 0 && SmallestNumber < N) {
if (prime[Divisor]
&& Divisor - D >= prevDivisor) {
SmallestNumber *= Divisor;
prevDivisor = Divisor;
K--;
}
Divisor++;
}
// Return the final answer
return SmallestNumber;
} // Driver Code public static void main(String args[])
{ boolean [] prime = new boolean [N];
Arrays.fill(prime, true );
SieveOfEratosthenes(prime);
int D = 1 ;
int K = 4 ;
// Function Call
System.out.println(SmallestNumber(prime, D, K));
} } // This code is contributed by sanjoy_62. |
# Python program to implement # the above approach N = 1000000 ;
# Function of Sieve of Eratosthenes def SieveOfEratosthenes(prime):
for p in range ( 2 , N / / 2 ):
if (prime[p] = = True ):
for i in range (p * p,N,p):
prime[i] = False ;
# Function to find smallest # number with given conditions def SmallestNumber(prime, D, K):
# Initialize first with D + 1
# because 1 is also a divisor
FirstDivisor = D + 1 ;
while (FirstDivisor < N and prime[FirstDivisor]! = True ):
FirstDivisor + = 1 ;
# Now value of K is decrement by 1
K - = 1 ;
# Initialize Divisor with First + D
# to maintain a difference D
# We get Remaining divisor
SmallestNumber = FirstDivisor;
Divisor = FirstDivisor + D;
# Maintain previous divisor
# to maintain difference
prevDivisor = FirstDivisor;
while (K > 0 and SmallestNumber < N):
if (prime[Divisor] and Divisor - D > = prevDivisor):
SmallestNumber * = Divisor;
prevDivisor = Divisor;
K - = 1 ;
Divisor + = 1 ;
# Return the final answer
return SmallestNumber;
# Driver Code if __name__ = = '__main__' :
prime = [ True for i in range (N)];
SieveOfEratosthenes(prime);
D = 1 ;
K = 4 ;
# Function Call
print (SmallestNumber(prime, D, K));
# This code is contributed by Rajput-Ji |
// C# program to implement // the above approach using System;
public class GFG
{ static int N = 1000000;
// Function of Sieve of Eratosthenes
static void SieveOfEratosthenes( bool [] prime)
{
for ( int p = 2; p * p < N; p++) {
if (prime[p] == true ) {
for ( int i = p * p; i < N; i += p)
prime[i] = false ;
}
}
}
// Function to find smallest
// number with given conditions
static int SmallestNumber( bool [] prime,
int D, int K)
{
// Initialize first with D + 1
// because 1 is also a divisor
int FirstDivisor = D + 1;
while (FirstDivisor < N
&& !prime[FirstDivisor]) {
++FirstDivisor;
}
// Now value of K is decrement by 1
K--;
// Initialize Divisor with First + D
// to maintain a difference D
// We get Remaining divisor
int SmallestNumber = FirstDivisor;
int Divisor = FirstDivisor + D;
// Maintain previous divisor
// to maintain difference
int prevDivisor = FirstDivisor;
while (K > 0 && SmallestNumber < N) {
if (prime[Divisor]
&& Divisor - D >= prevDivisor) {
SmallestNumber *= Divisor;
prevDivisor = Divisor;
K--;
}
Divisor++;
}
// Return the readonly answer
return SmallestNumber;
}
// Driver Code
public static void Main(String []args)
{
bool [] prime = new bool [N];
for ( int i = 0;i<N;i++)
prime[i] = true ;
SieveOfEratosthenes(prime);
int D = 1;
int K = 4;
// Function Call
Console.WriteLine(SmallestNumber(prime, D, K));
}
} // This code is contributed by Rajput-Ji |
<script> // JavaScript code for the above approach
let N = 1000000;
// Function of Sieve of Eratosthenes
function SieveOfEratosthenes(prime) {
for (let p = 2; p * p <= N; p++) {
if (prime[p] == true ) {
for (let i = p * p; i <= N; i += p)
prime[i] = false ;
}
}
}
// Function to find smallest
// number with given conditions
function SmallestNumber(prime,
D, K) {
// Initialize first with D + 1
// because 1 is also a divisor
let FirstDivisor = D + 1;
while (FirstDivisor < N
&& !prime[FirstDivisor]) {
++FirstDivisor;
}
// Now value of K is decrement by 1
K--;
// Initialize Divisor with First + D
// to maintain a difference D
// We get Remaining divisor
let SmallestNumber = FirstDivisor;
let Divisor = FirstDivisor + D;
// Maintain previous divisor
// to maintain difference
let prevDivisor = FirstDivisor;
while (K > 0 && SmallestNumber < N) {
if (prime[Divisor]
&& Divisor - D >= prevDivisor) {
SmallestNumber *= Divisor;
prevDivisor = Divisor;
K--;
}
Divisor++;
}
// Return the final answer
return SmallestNumber;
}
// Driver Code
let prime = new Array(N).fill( true );
SieveOfEratosthenes(prime);
let D = 1;
let K = 4;
// Function Call
document.write(SmallestNumber(prime, D, K))
// This code is contributed by Potta Lokesh
</script>
|
210
Time Complexity: O(N*log(log(N)))
Auxiliary Space: O(N)