Count of distinct Primonacci Numbers in a given range [L, R]
Last Updated :
18 May, 2021
Given two integers [L, R], the task is to count the number of Primonacci Numbers in the range [L, R].
Primonacci Series:
F(1) = F(2) = 1
F(3) = 3 – F(3 – 2) = F(1) = 1
F(4) = F(4 – 2) + F(4 – 3) = F(2) + F(1) = 1 + 1 = 2
F(5) = F(5 – 2) + F(5 – 3) = F(3) + F(2) = 1 + 1 = 2
…
Nth Primonacci Number, F(N) = F(N – 2) + F(N – 3) + F(N – 5) + …. + F(N – K), where K denotes the nearest prime number smaller than N
Examples:
Input: L = 1, R = 10
Output: 5
Explanation:
F(1) = 1
F(2) = 1
F(3) = 1
F(4) = 2
F(5) = 2
F(6) = F(6 – 2) + F(6 – 3) + F(6 – 5) = F(4) + F(3) + F(1) = 2 + 1 + 1 = 4
F(7) = F(7 – 2) + F(7 – 3) + F(7 – 5) = F(5) + F(4) + F(2) = 2 + 2 + 1 = 5
F(8) = F(8 – 2) + F(8 – 3) + F(8 – 5) + F(8 – 7) = F(6) + F(5) + F(3) + F(1) = 4 + 2 + 1 + 1 = 8
Therefore, distinct primonacci numbers are {1, 2, 4, 5, 8}.
Input: L = 6, R = 50
Output: 6
Approach:
The problem can be solved using Dynamic Programming and Sieve of Eratosthenes. Follow the steps below to solve the problem:
- Generate all primes using the Sieve of Eratosthenes.
- Initialize a HashSet to store the distinct Primonacci numbers.
- Initialize an array dp[ ], such that dp[i] stores the ith Primonacci Number.
- Set dp[1] = dp[2] = 1.
- For every i, iterate over all primes p, which is less than i and keep updating dp[i] by adding dp[i – p].
- If dp[i] is within the range [L, R], insert into the HashSet.
- Finally, if dp[i] exceeds R, print the size of the HashSet.
Below is the implementation of the above approach:
C++
#include<bits/stdc++.h>
using namespace std;
static vector< int > primes;
int M = 100005;
void sieve()
{
bool mark[M];
for ( int i = 0; i < M; i++)
mark[i] = false ;
for ( int i = 2; i < M; i++)
mark[i] = true ;
for ( int i = 2; i * i < M; i++)
{
if (mark[i])
{
for ( int j = i * i;
j < M; j += i)
mark[j] = false ;
}
}
for ( int i = 2; i < M; i++)
if (mark[i])
primes.push_back(i);
}
void countPrimonacci( int l, int r)
{
vector< int > dp;
dp.push_back(1);
dp.push_back(1);
int i = 2;
set< int > s;
while ( true )
{
int x = 0;
for ( int j = 0; j < primes.size(); j++)
{
int p = primes[j];
if (p >= i)
break ;
x += dp[i - p];
}
if (x >= l && x <= r)
s.insert(x);
if (x > r)
break ;
dp.push_back(x);
i++;
}
cout << s.size();
}
int main()
{
sieve();
int L = 1, R = 10;
countPrimonacci(L, R);
}
|
Java
import java.util.*;
class GFG {
static ArrayList<Integer> primes;
static int M = 100005 ;
static void sieve()
{
primes = new ArrayList<>();
boolean mark[] = new boolean [M];
for ( int i = 2 ; i < M; i++)
mark[i] = true ;
for ( int i = 2 ; i * i < M; i++) {
if (mark[i]) {
for ( int j = i * i;
j < M; j += i)
mark[j] = false ;
}
}
for ( int i = 2 ; i < M; i++)
if (mark[i])
primes.add(i);
}
static void countPrimonacci( int l, int r)
{
ArrayList<Integer> dp = new ArrayList<>();
dp.add( 1 );
dp.add( 1 );
int i = 2 ;
HashSet<Integer> s = new HashSet<>();
while ( true ) {
int x = 0 ;
for ( int j = 0 ; j < primes.size();
j++) {
int p = primes.get(j);
if (p >= i)
break ;
x += dp.get(i - p);
}
if (x >= l && x <= r)
s.add(x);
if (x > r)
break ;
dp.add(x);
i++;
}
System.out.println(s.size());
}
public static void main(String[] args)
{
sieve();
int L = 1 , R = 10 ;
countPrimonacci(L, R);
}
}
|
Python3
M = 100005
primes = []
def sieve():
mark = [ False ] * M
for i in range ( 2 , M):
mark[i] = True
i = 2
while i * i < M:
if (mark[i]):
j = i * i
while j < M:
mark[j] = False
j + = i
i + = 1
for i in range ( 2 , M):
if (mark[i]):
primes.append(i)
def countPrimonacci(l, r):
dp = []
dp.append( 1 )
dp.append( 1 )
i = 2
s = set ()
while ( True ):
x = 0
for j in range ( len (primes)):
p = primes[j]
if (p > = i):
break
x + = dp[i - p]
if (x > = l and x < = r):
s.add(x)
if (x > r):
break
dp.append(x)
i + = 1
print ( len (s))
if __name__ = = '__main__' :
sieve()
L, R = 1 , 10
countPrimonacci(L, R)
|
C#
using System;
using System.Collections.Generic;
class GFG{
static List< int > primes;
static int M = 100005;
static void sieve()
{
primes = new List< int >();
bool [] mark = new bool [M];
for ( int i = 2; i < M; i++)
mark[i] = true ;
for ( int i = 2; i * i < M; i++)
{
if (mark[i])
{
for ( int j = i * i; j < M; j += i)
mark[j] = false ;
}
}
for ( int i = 2; i < M; i++)
if (mark[i])
primes.Add(i);
}
static void countPrimonacci( int l, int r)
{
List< int > dp = new List< int >();
dp.Add(1);
dp.Add(1);
int i = 2;
HashSet< int > s = new HashSet< int >();
while ( true )
{
int x = 0;
for ( int j = 0; j < primes.Count; j++)
{
int p = primes[j];
if (p >= i)
break ;
x += dp[i - p];
}
if (x >= l && x <= r)
s.Add(x);
if (x > r)
break ;
dp.Add(x);
i++;
}
Console.WriteLine(s.Count);
}
public static void Main(String[] args)
{
sieve();
int L = 1, R = 10;
countPrimonacci(L, R);
}
}
|
Javascript
<script>
let primes = new Array();
let M = 100005;
function sieve()
{
let mark = new Array(M);
for (let i = 0; i < M; i++)
mark[i] = false ;
for (let i = 2; i < M; i++)
mark[i] = true ;
for (let i = 2; i * i < M; i++)
{
if (mark[i])
{
for (let j = i * i;
j < M; j += i)
mark[j] = false ;
}
}
for (let i = 2; i < M; i++)
if (mark[i])
primes.push(i);
}
function countPrimonacci(l, r)
{
let dp = new Array();
dp.push(1);
dp.push(1);
let i = 2;
let s = new Set();
while ( true )
{
let x = 0;
for (let j = 0; j < primes.length; j++)
{
let p = primes[j];
if (p >= i)
break ;
x += dp[i - p];
}
if (x >= l && x <= r)
s.add(x);
if (x > r)
break ;
dp.push(x);
i++;
}
document.write(s.size);
}
sieve();
let L = 1, R = 10;
countPrimonacci(L, R);
</script>
|
Time Complexity: O(N * P), where P is the count of primes up to R
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...