Related Articles

# Nth Term of a Fibonacci Series of Primes formed by concatenating pairs of Primes in a given range

• Last Updated : 14 Jun, 2021

Given two integers X and Y, the task is to perform the following operations:

• Find all prime numbers in the range [X, Y].
• Generate all numbers possible by combining every pair of primes in the given range.
• Find the prime numbers among all the possible numbers generated above. Calculate the count of primes among them, say N.
• Print the Nth term of a Fibonacci Series formed by having the smallest and largest primes from the above list as the first two terms of the series.

Examples:

Input: X = 2 Y = 40
Output: 13158006689
Explanation:
All primes in the range [X, Y] = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]

All possible numbers generated by concatenating each pair of prime = [23, 25, 27, 211, 213, 217, 219, 223, 229, 231, 32, 35, 37, 311, 313, 319, 323, 329, 331, 337, 52, 53, 57, 511, 513, 517, 519, 523, 529, 531, 537, 72, 73, 75, 711, 713, 717, 719, 723, 729, 731, 737, 112, 113, 115, 117, 1113, 1117, 1119, 1123, 1129, 1131, 1137, 132, 133, 135, 137, 1311, 1317, 1319, 1323, 1329, 1331, 1337, 172, 173, 175, 177, 1711, 1713, 1719, 1723, 1729, 1731, 1737, 192, 193, 195, 197, 1911, 1913, 1917, 1923, 1929, 1931, 1937, 232, 233, 235, 237, 2311, 2313, 2317, 2319, 2329, 2331, 2337, 292, 293, 295, 297, 2911, 2913, 2917, 2919, 2923, 2931, 2937, 312, 315, 317, 3111, 3113, 3117, 3119, 3123, 3129, 3137, 372, 373, 375, 377, 3711, 3713, 3717, 3719, 3723, 3729, 3731]

All primes among the generated numbers=[193, 3137, 197, 2311, 3719, 73, 137, 331, 523, 1931, 719, 337, 211, 23, 1117, 223, 1123, 229, 37, 293, 2917, 1319, 1129, 233, 173, 3119, 113, 53, 373, 311, 313, 1913, 1723, 317]

Count of the primes = 34
Smallest Prime = 23
Largest Prime = 3719
Therefore, the 34th term of the Fibonacci series, having 23 and 3719 as the first two terms, is 13158006689.

Input: X = 1, Y = 10
Output: 1053

Approach:
Follow the steps below to solve the problem:

• Generate all possible primes using the Sieve of Eratosthenes.
• Traverse the range [X, Y] and generate all primes in the range with the help of primes[] array generated in the step above.
• Traverse the list of primes and generate all possible pairs from the list.
• For each pair, concatenate the two primes and check if their concatenation is a prime or not.
• Find the maximum and minimum of all such primes and count all such primes obtained.
• Finally, print the countth of a Fibonacci series having minimum and maximum obtained in the above step as the first two terms of the series.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach``#include``using` `namespace` `std;``#define int long long int` `// Stores at each index if it's a``// prime or not``int` `prime;` `// Sieve of Eratosthenes to``// generate all possible primes``void` `SieveOfEratosthenes()``{``    ``for``(``int` `i = 0; i < 100001; i++)``        ``prime[i] = 1;``        ` `    ``int` `p = 2;``    ``while` `(p * p <= 100000)``    ``{``        ` `        ``// If p is a prime``        ``if` `(prime[p] == 1)``        ``{``            ` `            ``// Set all multiples of``            ``// p as non-prime``            ``for``(``int` `i = p * p;``                    ``i < 100001;``                    ``i += p)``                ``prime[i] = 0;``        ``}    ``        ``p += 1;``    ``}    ``}``    ` `int` `join(``int` `a, ``int` `b)``{``    ``int` `mul = 1;``    ``int` `bb = b;``    ` `    ``while``(b != 0)``    ``{``        ``mul *= 10;``        ``b /= 10;``    ``}``    ``a *= mul;``    ``a += bb;``    ``return` `a;``}` `// Function to generate the``// required Fibonacci Series``void` `fibonacciOfPrime(``int` `n1, ``int` `n2)``{``    ``SieveOfEratosthenes();``    ` `    ``// Stores all primes between``    ``// n1 and n2``    ``vector<``int``>initial;``    ` `    ``// Generate all primes between``    ``// n1 and n2``    ``for``(``int` `i = n1; i <= n2; i++)``        ``if` `(prime[i])``            ``initial.push_back(i);``            ` `    ``// Stores all concatenations``    ``// of each pair of primes``    ``vector<``int``>now;``    ` `    ``// Generate all concatenations``    ``// of each pair of primes``    ``for``(``auto` `a:initial)``        ``for``(``auto` `b:initial)``            ``if` `(a != b)``            ``{``                ``int` `c = join(a,b);``                ``now.push_back(c);``            ``}``                ` `                ` `    ``// Stores the primes out of the``    ``// numbers generated above``    ``vector<``int``>current;``    ` `    ``for``(``auto` `x:now)``        ``if` `(prime[x])``            ``current.push_back(x);``            ` `    ``// Store the unique primes``    ``set<``int``>current_set;``    ``for``(``auto` `i:current)``        ``current_set.insert(i);``    ` `    ``// Find the minimum``    ``int` `first = *min_element(current_set.begin(),``                             ``current_set.end());``    ` `    ``// Find the minimum``    ``int` `second = *max_element(current_set.begin(),``                              ``current_set.end());``                              ` `    ``// Find N``    ``int` `count = current_set.size() - 1;``    ``int` `curr = 1;``    ``int` `c;``    ` `    ``while``( curr < count)``    ``{``        ``c = first + second;``        ``first = second;``        ``second = c;``        ``curr += 1;``    ``}``    ` `    ``// Print the N-th term``    ``// of the Fibonacci Series``    ``cout << (c) << endl;``}``    ` `// Driver Code``int32_t main()``{``    ``int` `x = 2;``    ``int` `y = 40;``    ` `    ``fibonacciOfPrime(x, y);``}` `// This code is contributed by Stream_Cipher`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;` `class` `GFG{` `// Stores at each index if it's a ``// prime or not    ``static` `int` `prime[] = ``new` `int` `[``100001``];` `// Sieve of Eratosthenes to``// generate all possible primes``static` `void` `SieveOfEratosthenes()``{``    ``for``(``int` `i = ``0``; i < ``100001``; i++)``        ``prime[i] = ``1``;``        ` `    ``int` `p = ``2``;``    ``while` `(p * p <= ``100000``)``    ``{``        ` `        ``// If p is a prime``        ``if` `(prime[p] == ``1``)``        ``{``            ` `            ``// Set all multiples of``            ``// p as non-prime``            ``for``(``int` `i = p * p;``                    ``i < ``100001``;``                    ``i += p)``                ``prime[i] = ``0``;``        ``}    ``        ``p += ``1``;``    ``}    ``}` `static` `int` `join(``int` `a,``int` `b)``{``    ``int` `mul = ``1``;``    ``int` `bb = b;``    ` `    ``while``(b != ``0``)``    ``{``        ``mul *= ``10``;``        ``b /= ``10``;``    ``}``    ``a *= mul;``    ``a += bb;``    ``return` `a;``}` `// Function to generate the``// required Fibonacci Series``static` `void` `fibonacciOfPrime(``int` `n1, ``int` `n2)``{``    ``SieveOfEratosthenes();``    ` `    ``// Stores all primes between``    ``// n1 and n2``    ``Vector initial = ``new` `Vector<>();``    ` `    ``// Generate all primes between``    ``// n1 and n2``    ``for``(``int` `i = n1; i <= n2; i++)``        ``if` `(prime[i] == ``1``)``            ``initial.add(i);``            ` `    ``// Stores all concatenations``    ``// of each pair of primes``    ``Vector now = ``new` `Vector<>();``    ` `    ``// Generate all concatenations``    ``// of each pair of primes``    ``for``(``int` `i = ``0``; i < initial.size(); i++)``    ``{``        ``for``(``int` `j = ``0``; j < initial.size(); j++)``        ``{``            ``int` `a = (``int``)initial.get(i);``            ``int` `b = (``int``)initial.get(j);``            ` `            ``if` `(a != b)``            ``{``                ``int` `c = join(a, b);``                ``now.add(c);``            ``}``        ``}``    ``}``    ` `    ``// Stores the primes out of the``    ``// numbers generated above``    ``Vector current = ``new` `Vector<>();``    ` `    ``for``(``int` `i = ``0``; i < now.size(); i++)``        ``if` `(prime[(``int``)now.get(i)] == ``1``)``            ``current.add((``int``)now.get(i));``            ` `    ``// Store the unique primes``    ``int` `cnt[] = ``new` `int``[``1000009``];``    ``for``(``int` `i = ``0``; i < ``1000001``; i++)``        ``cnt[i] = ``0``;``        ` `    ``Vector current_set = ``new` `Vector<>();``    ``for``(``int` `i = ``0``; i < current.size(); i++)``    ``{``        ``cnt[(``int``)current.get(i)]++;``        ``if` `(cnt[(``int``)current.get(i)] == ``1``)``            ``current_set.add((``int``)current.get(i));``    ``}``    ` `    ``// Find the minimum``    ``long` `first = ``1000000000``;``    ``for``(``int` `i = ``0``; i < current_set.size(); i++)``        ``first = Math.min(first,``                         ``(``int``)current_set.get(i));``                         ` `    ``// Find the minimum``    ``long` `second = ``0``;``    ``for``(``int` `i = ``0``; i < current_set.size(); i++)``        ``second = Math.max(second,``                         ``(``int``)current_set.get(i));``                         ` `    ``// Find N``    ``int` `count = current_set.size() - ``1``;``    ``long` `curr = ``1``;``    ``long` `c = ``0``;``    ` `    ``while``(curr < count)``    ``{``        ``c = first + second;``        ``first = second;``        ``second = c;``        ``curr += ``1``;``    ``}``    ` `    ``// Print the N-th term``    ``// of the Fibonacci Series``    ``System.out.println(c);``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `x = ``2``;``    ``int` `y = ``40``;``    ` `    ``fibonacciOfPrime(x, y);``}``}` `// This code is contributed by Stream_Cipher`

## Python3

 `# Python3 Program to implement``# the above approach` `# Stores at each index if it's a``# prime or not``prime ``=` `[``True` `for` `i ``in` `range``(``100001``)]` `# Sieve of Eratosthenes to``# generate all possible primes``def` `SieveOfEratosthenes():``    ` `    ``p ``=` `2``    ``while` `(p ``*` `p <``=` `100000``):``        ` `        ``# If p is a prime``        ``if` `(prime[p] ``=``=` `True``):``            ` `            ``# Set all multiples of p as non-prime``            ``for` `i ``in` `range``(p ``*` `p, ``100001``, p):``                ``prime[i] ``=` `False``                ` `        ``p ``+``=` `1` `# Function to generate the``# required Fibonacci Series``def` `fibonacciOfPrime(n1, n2):``    ` `    ``SieveOfEratosthenes()``    ` `    ``# Stores all primes between``    ``# n1 and n2``    ``initial ``=` `[]``    ` `    ``# Generate all primes between``    ``# n1 and n2``    ``for` `i ``in` `range``(n1, n2):``        ``if` `prime[i]:``            ``initial.append(i)``            ` `    ``# Stores all concatenations``    ``# of each pair of primes``    ``now ``=` `[]``    ` `    ``# Generate all concatenations``    ``# of each pair of primes``    ``for` `a ``in` `initial:``        ``for` `b ``in` `initial:``            ``if` `a !``=` `b:``                ``c ``=` `str``(a) ``+` `str``(b)``                ``now.append(``int``(c))``                ` `    ``# Stores the primes out of the``    ``# numbers generated above``    ``current ``=` `[]``    ` `    ``for` `x ``in` `now:``        ``if` `prime[x]:``            ``current.append(x)``            ` `    ``# Store the unique primes``    ``current ``=` `set``(current)``    ` `    ``# Find the minimum``    ``first ``=` `min``(current)``    ` `    ``# Find the minimum``    ``second ``=` `max``(current)``    ` `    ``# Find N``    ``count ``=` `len``(current) ``-` `1``    ``curr ``=` `1``    ` `    ``while` `curr < count:``        ``c ``=` `first ``+` `second``        ``first ``=` `second``        ``second ``=` `c``        ``curr ``+``=` `1``    ` `    ``# Print the N-th term``    ``# of the Fibonacci Series``    ``print``(c)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``x ``=` `2``    ``y ``=` `40``    ``fibonacciOfPrime(x, y)`

## C#

 `// C# program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG{``    ` `// Stores at each index if it's a  ``// prime or not     ``static` `int``[] prime = ``new` `int``;``      ` `// Sieve of Eratosthenes to ``// generate all possible primes``static` `void` `SieveOfEratosthenes()``{``  ``for``(``int` `i = 0; i < 100001; i++)``    ``prime[i] = 1;` `  ``int` `p = 2;``  ``while` `(p * p <= 100000)``  ``{``    ``// If p is a prime``    ``if` `(prime[p] == 1)``    ``{``      ``// Set all multiples of``      ``// p as non-prime``      ``for``(``int` `i = p * p;``              ``i < 100001; i += p)``        ``prime[i] = 0;``    ``}``    ` `    ``p += 1;``  ``}     ``}``      ` `static` `int` `join``(``int` `a,``                ``int` `b)``{``  ``int` `mul = 1;``  ``int` `bb = b;` `  ``while``(b != 0)``  ``{``    ``mul *= 10;``    ``b /= 10;``  ``}``  ` `  ``a *= mul;``  ``a += bb;``  ``return` `a;``}``      ` `// Function to generate the ``// required Fibonacci Series``static` `void` `fibonacciOfPrime(``int` `n1,``                             ``int` `n2)``{``  ``SieveOfEratosthenes();` `  ``// Stores all primes``  ``// between n1 and n2``  ``List<``int``> initial =``            ``new` `List<``int``>();` `  ``// Generate all primes``  ``// between n1 and n2``  ``for``(``int` `i = n1; i <= n2; i++)``    ``if` `(prime[i] == 1)``      ``initial.Add(i);` `  ``// Stores all concatenations``  ``// of each pair of primes``  ``List<``int``> now =``            ``new` `List<``int``>();` `  ``// Generate all concatenations``  ``// of each pair of primes``  ``for``(``int` `i = 0; i < initial.Count; i++)``  ``{``    ``for``(``int` `j = 0; j < initial.Count; j++)``    ``{``      ``int` `a = initial[i];``      ``int` `b = initial[j];` `      ``if` `(a != b)``      ``{``        ``int` `C = ``join``(a, b);``        ``now.Add(C);``      ``}``    ``}``  ``}` `  ``// Stores the primes out of the``  ``// numbers generated above``  ``List<``int``> current =``            ``new` `List<``int``>();` `  ``for``(``int` `i = 0; i < now.Count; i++)``    ``if` `(prime[now[i]] == 1)``      ``current.Add(now[i]);` `  ``// Store the unique primes``  ``int``[] cnt = ``new` `int``;``  ` `  ``for``(``int` `i = 0; i < 1000001; i++)``    ``cnt[i] = 0;` `  ``List<``int``> current_set =``            ``new` `List<``int``>();``  ` `  ``for``(``int` `i = 0; i < current.Count; i++)``  ``{``    ``cnt[current[i]]++;``    ` `    ``if` `(cnt[current[i]] == 1)``      ``current_set.Add(current[i]);``  ``}` `  ``// Find the minimum``  ``long` `first = 1000000000;``  ` `  ``for``(``int` `i = 0;``          ``i < current_set.Count; i++)``    ``first = Math.Min(first,``                     ``current_set[i]);` `  ``// Find the minimum``  ``long` `second = 0;``  ` `  ``for``(``int` `i = 0;``          ``i < current_set.Count; i++)``    ``second = Math.Max(second,``                      ``current_set[i]);``  ` `  ``// Find N``  ``int` `count = current_set.Count - 1;``  ``long` `curr = 1;``  ``long` `c = 0;` `  ``while``(curr < count)``  ``{``    ``c = first + second;``    ``first = second;``    ``second = c;``    ``curr += 1;``  ``}` `  ``// Print the N-th term``  ``// of the Fibonacci Series``  ``Console.WriteLine(c);``}` `// Driver code``static` `void` `Main()``{``  ``int` `x = 2;``  ``int` `y = 40;``  ``fibonacciOfPrime(x, y);``}``}` `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``
Output:
`13158006689`

Time Complexity: O(N2 + log(log(maxm))), where it takes O(N2) to generate all pairs and O(1) to check if a number is prime or not and maxm is the size of prime[]
Auxiliary Space: O(maxm)

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