- Data Structure
- Networking
- RDBMS
- Operating System
- Java
- MS Excel
- iOS
- HTML
- CSS
- Android
- Python
- C Programming
- C++
- C#
- MongoDB
- MySQL
- Javascript
- PHP
- Physics
- Chemistry
- Biology
- Mathematics
- English
- Economics
- Psychology
- Social Studies
- Fashion Studies
- Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Find n-th Fortunate Number
Fortunate Numbers − It is the smallest integer m > 1 such that, for a given positive integer n, pn# + m is a prime number, where pn# is the product of the first n prime numbers.
For example, for calculating the third fortunate number, first calculate the product of the first 3 prime numbers (2, 3, 5) i.e. 30. Upon adding 2 we get 32 which is an even number, adding 3 gives 33 which is a multiple of 3. One would similarly rule out integers up to 6. Adding 7 gives, 37 which is a prime number. Thus, 7 is the third fortunate number.
Fortunate numbers for the first primorials are −
3, 5, 7, 13, 23, 17, 19, 23, 37, 61, 67, 61, 71, 47, 107, 59, 61, 109 ….
Problem Statement
Given a number n. Find the nth fortunate number.
Sample Example 1
Input: n = 3
Output: 7
Explanation − Product of first 3 price numbers −
2 3 5 = 30 30 + 7 = 37, a prime number.
Sample Example 2
Input: n = 7
Output: 19
Explanation − Product of first 7 prime numbers −
2 3 5 7 11 13 17 = 510510 510510 + 19 = 510529, a prime number.
Approach 1: Primorial Method
A simple solution to the problem is first to calculate pn# i.e. product of the first n prime numbers and then find the difference between the pn# and the next prime number. The difference obtained will be a fortunate number.
Pseudocode
procedure prime (num) if num <= 1 ans = TRUE end if for i = 2 to sqrt(num) if i is a factor of num ans = false end if ans = true end procedure procedure nthFortunate (n) prod = 1 count = 0 for i = 2 to count < n if i is prime prod = prod * i count = count + 1 end if nextPrime = prod + 2 while nextPrime is not prime nextPrime = next Prime + 1 ans = nextPrime - prod end procedure
Example: C++ Implementation
In the following program, the fortunate number is calculated by calculating the primordial of the first n prime numbers and the next prime number after primorial is found. The fortunate number is the difference between the next prime and the primorial.
#include <bits/stdc++.h> using namespace std; // Function to find if a number is prime or not bool prime(unsigned long long int num){ if (num <= 1) return true; for (int i = 2; i <= sqrt(num); i++){ if (num % i == 0) return false; } return true; } // Function to find the nth Fortunate number unsigned long long int nthFortunate(int n){ long long int prod = 1, count = 0; // Calculating product/primorial of first n prime numbers for (int i = 2; count < n; i++){ if (prime(i)){ prod *= i; count++; } } // Find the next prime greater than the product of n prime numbers unsigned long long int nextPrime = prod + 2; while (!prime(nextPrime)){ nextPrime++; } // Fortunate number is the difference between prime and primorial unsigned long long int ans = nextPrime - prod; return ans; } int main(){ int n = 15; cout << n << "th Fortunate number : " << nthFortunate(n); return 0; }
Output
15th Fortunate number : 107
Time Complexity − O(nsqrt(n)), where prime() function has complexity O(sqrt(n)), for loop in nthFortunate() has the complexity of O(nsqrt(n)).
Space Complexity − O(1)
Approach 2: Sieve of Eratosthenes
The sieve of Eratosthenes is used to get all the prime numbers up to a limit which we will give a value MAX. In this approach, we create a boolean array with all true entries and mark all non-prime indexes as false. Then multiplying the first n prime numbers from the array to get the product of the first n prime numbers. Then similar to the previous approach increment product by 1 starting with 2 to get the next prime number. The difference between the next prime number and the product will be the fortunate number required.
Pseudocode
procedure nthFortunate (n) MAX is set prime[MAX] = {true} prime[0] = false prime[1] = false for i = 1 to i*i <= MAX if prime[i] for j = i*i to MAX with j = j + i in each iteration prime [j] = false end if prod = 1 count = 0 for i = 2 to count < n if prime[i] prod = prod * i count = count + 1 end if nextPrime = prod + 2 while nextPrime is not prime nextPrime = nextPrime + 1 ans = nextPrime - prod end procedure
Example: C++ Implementation
In the following program, the boolean prime array of the size MAX keeps a record of all the prime numbers up to MAX. Then the primorial is found by multiplying the first n prime numbers. Then similar to the previous approach, nextPrime is found. The difference between nextPrime and product is the fortunate number.
#include <bits/stdc++.h> using namespace std; // Function to find the nth Fortunate number unsigned long long int nthFortunate(int n){ // Setting upper limit for Sieve of Eratosthenes const unsigned long long int MAX = 1000000000; vector<bool> prime(MAX, true); prime[0] = prime[1] = false; // Sieve of Eratosthenes to find all primes up to MAX for (unsigned long long int i = 2; i * i <= MAX; i++){ if (prime[i]){ // Setting all the multiples of i to false for (int j = i * i; j <= MAX; j += i){ prime[j] = false; } } } // Find the first n primes and calculate their product unsigned long long int prod = 1, count = 0; for (unsigned long long int i = 2; count < n; i++){ if (prime[i]){ prod *= i; count++; } } // Find next prime greater than product unsigned long long int nextPrime = prod + 2; while (!prime[nextPrime]) nextPrime++; // Fortunate number is difference between prime and product return nextPrime - prod; } int main(){ int n = 25; cout << n << "th Fortunate number : " << nthFortunate(n); return 0; }
Output
15th Fortunate number : 107
Time Complexity − O(n log(log(n)))
Space Complexity − O(MAX)
Conclusion
In conclusion, nth Fortunate number can be found by the following two approaches.
The primorial method: Find the product of the first n prime numbers and calculate the next prime number from the product. The difference between the prime and the product is the nth Fortunate number.
The sieve of Eratosthenes: Finding all prime numbers up to a limit and then calculating the product and next prime number to find the fortunate number.
Both methods are efficient for small values of n only due to constraints on the size of variables. For larger values, a more efficient and optimized solution is required.