Skip to content
Related Articles
Get the best out of our app
GeeksforGeeks App
Open App
geeksforgeeks
Browser
Continue

Related Articles

Prime numbers after prime P with sum S

Improve Article
Save Article
Like Article
author
shubham_rana_77
scholar
62 published articles
Improve Article
Save Article
Like Article

Given three numbers sum S, prime P, and N, find all N prime numbers after prime P such that their sum is equal to S.
Examples : 
 

Input :  N = 2, P = 7, S = 28 
Output : 11 17
Explanation : 11 and 17 are primes after
prime 7 and (11 + 17 = 28) 

Input :  N = 3, P = 2, S = 23 
Output : 3 7 13
         5 7 11
Explanation : 3, 5, 7, 11 and 13 are primes 
after prime 2. And (3 + 7 + 13 = 5 + 7 + 11 
= 23) 

Input :  N = 4, P = 3, S = 54
Output : 5 7 11 31 
         5 7 13 29 
         5 7 19 23 
         5 13 17 19 
         7 11 13 23 
         7 11 17 19 
Explanation : All are prime numbers and 
their sum is 54

 

Approach: The approach used is to produce all the primes less than S and greater than P. And then backtracking to find if such N primes exist whose sum equals S.
For example, S = 10, N = 2, P = 2 
 

 

C++




// CPP Program to print all N primes after
// prime P whose sum equals S
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
 
// vector to store prime and N primes
// whose sum equals given S
vector<int> set;
vector<int> prime;
 
// function to check prime number
bool isPrime(int x)
{
    // square root of x
    int sqroot = sqrt(x);
    bool flag = true;
 
    // since 1 is not prime number
    if (x == 1)
        return false;
 
    // if any factor is found return false
    for (int i = 2; i <= sqroot; i++)
        if (x % i == 0)
            return false;
 
    // no factor found
    return true;
}
 
// function to display N primes whose sum equals S
void display()
{
    int length = set.size();
    for (int i = 0; i < length; i++)
        cout << set[i] << " ";
    cout << "\n";
}
 
// function to evaluate all possible N primes
// whose sum equals S
void primeSum(int total, int N, int S, int index)
{
    // if total equals S And
    // total is reached using N primes
    if (total == S && set.size() == N)
    {
        // display the N primes
        display();
        return;
    }
 
    // if total is greater than S
    // or if index has reached last element
    if (total > S || index == prime.size())
        return;
 
    // add prime[index] to set vector
    set.push_back(prime[index]);
 
    // include the (index)th prime to total
    primeSum(total+prime[index], N, S, index+1);
 
    // remove element from set vector
    set.pop_back();
 
    // exclude (index)th prime
    primeSum(total, N, S, index+1);
}
 
// function to generate all primes
void allPrime(int N, int S, int P)
{
    // all primes less than S itself
    for (int i = P+1; i <=S ; i++)
    {
        // if i is prime add it to prime vector
        if (isPrime(i))
            prime.push_back(i);
    }
 
    // if primes are less than N
    if (prime.size() < N)
        return;
    primeSum(0, N, S, 0);
}
 
// Driver Code
int main()
{
    int S = 54, N = 2, P = 3;
    allPrime(N, S, P);
    return 0;
}

Java



// Java Program to print
// all N primes after prime
// P whose sum equals S
import java.io.*;
import java.util.*;
 
class GFG
{
    // vector to store prime
    // and N primes whose sum
    // equals given S
    static ArrayList<Integer> set =
                     new ArrayList<Integer>();
    static ArrayList<Integer> prime =
                     new ArrayList<Integer>();
     
    // function to check
    // prime number
    static boolean isPrime(int x)
    {
        // square root of x
        int sqroot = (int)Math.sqrt(x);
 
        // since 1 is not
        // prime number
        if (x == 1)
            return false;
     
        // if any factor is
        // found return false
        for (int i = 2;
                 i <= sqroot; i++)
            if (x % i == 0)
                return false;
     
        // no factor found
        return true;
    }
     
    // function to display N
    // primes whose sum equals S
    static void display()
    {
        int length = set.size();
        for (int i = 0;
                 i < length; i++)
            System.out.print(
                   set.get(i) + " ");
        System.out.println();
    }
     
    // function to evaluate
    // all possible N primes
    // whose sum equals S
    static void primeSum(int total, int N,
                         int S, int index)
    {
        // if total equals S
        // And total is reached
        // using N primes
        if (total == S &&
            set.size() == N)
        {
            // display the N primes
            display();
            return;
        }
     
        // if total is greater
        // than S or if index
        // has reached last
        // element
        // or if set size reached to maximum or greater than maximum
        if (total > S ||
            index == prime.size() || set.size() >= N)
            return;
     
        // add prime.get(index)
        // to set vector
        set.add(prime.get(index));
     
        // include the (index)th
        // prime to total
        primeSum(total + prime.get(index),
                         N, S, index + 1);
     
        // remove element
        // from set vector
        set.remove(set.size() - 1);
     
        // exclude (index)th prime
        primeSum(total, N,
                 S, index + 1);
    }
     
    // function to generate
    // all primes
    static void allPrime(int N,
                         int S, int P)
    {
        // all primes less
        // than S itself
        for (int i = P + 1;
                 i <= S ; i++)
        {
            // if i is prime add
            // it to prime vector
            if (isPrime(i))
                prime.add(i);
        }
     
        // if primes are
        // less than N
        if (prime.size() < N)
            return;
        primeSum(0, N, S, 0);
    }
     
    // Driver Code
    public static void main(String args[])
    {
        int S = 54, N = 2, P = 3;
        allPrime(N, S, P);
    }
}
 
// This code is contributed by
// Manish Shaw(manishshaw1)
Python3



# Python Program to print
# all N primes after prime
# P whose sum equals S
import math
 
# vector to store prime
# and N primes whose
# sum equals given S
set = []
prime = []
 
# function to
# check prime number
def isPrime(x) :
 
    # square root of x
    sqroot = int(math.sqrt(x))
    flag = True
 
    # since 1 is not
    # prime number
    if (x == 1) :
        return False
 
    # if any factor is
    # found return false
    for i in range(2, sqroot + 1) :
        if (x % i == 0) :
            return False
 
    # no factor found
    return True
 
# function to display N
# primes whose sum equals S
def display() :
 
    global set, prime
    length = len(set)
    for i in range(0, length) :
        print (set[i], end = " ")
    print ()
 
# function to evaluate
# all possible N primes
# whose sum equals S
def primeSum(total, N,
             S, index) :
     
    global set, prime
     
    # if total equals S
    # And total is reached
    # using N primes
    if (total == S and
         len(set) == N) :
     
        # display the N primes
        display()
        return
 
    # if total is greater
    # than S or if index
    # has reached last element
    if (total > S or
        index == len(prime)) :
        return
 
    # add prime[index]
    # to set vector
    set.append(prime[index])
 
    # include the (index)th
    # prime to total
    primeSum(total + prime[index],
                  N, S, index + 1)
 
    # remove element
    # from set vector
    set.pop()
 
    # exclude (index)th prime
    primeSum(total, N,
             S, index + 1)
 
# function to generate
# all primes
def allPrime(N, S, P) :
 
    global set, prime
     
    # all primes less
    # than S itself
    for i in range(P + 1,
                   S + 1) :
     
        # if i is prime add
        # it to prime vector
        if (isPrime(i)) :
            prime.append(i)
     
    # if primes are
    # less than N
    if (len(prime) < N) :
        return
    primeSum(0, N, S, 0)
 
# Driver Code
S = 54
N = 2
P = 3
allPrime(N, S, P)
 
# This code is contributed by
# Manish Shaw(manishshaw1)
C#



// C# Program to print all
// N primes after prime P
// whose sum equals S
using System;
using System.Collections.Generic;
 
class GFG
{
    // vector to store prime
    // and N primes whose sum
    // equals given S
    static List<int> set = new List<int>();
    static List<int> prime = new List<int>();
     
    // function to check prime number
    static bool isPrime(int x)
    {
        // square root of x
        int sqroot = (int)Math.Sqrt(x);
 
        // since 1 is not prime number
        if (x == 1)
            return false;
     
        // if any factor is
        // found return false
        for (int i = 2; i <= sqroot; i++)
            if (x % i == 0)
                return false;
     
        // no factor found
        return true;
    }
     
    // function to display N
    // primes whose sum equals S
    static void display()
    {
        int length = set.Count;
        for (int i = 0; i < length; i++)
            Console.Write(set[i] + " ");
        Console.WriteLine();
    }
     
    // function to evaluate
    // all possible N primes
    // whose sum equals S
    static void primeSum(int total, int N,
                         int S, int index)
    {
        // if total equals S And
        // total is reached using N primes
        if (total == S && set.Count == N)
        {
            // display the N primes
            display();
            return;
        }
     
        // if total is greater than
        // S or if index has reached
        // last element
        if (total > S || index == prime.Count)
            return;
     
        // add prime[index]
        // to set vector
        set.Add(prime[index]);
     
        // include the (index)th
        // prime to total
        primeSum(total + prime[index],
                         N, S, index + 1);
     
        // remove element
        // from set vector
        set.RemoveAt(set.Count - 1);
     
        // exclude (index)th prime
        primeSum(total, N, S, index + 1);
    }
     
    // function to generate
    // all primes
    static void allPrime(int N,
                         int S, int P)
    {
        // all primes less than S itself
        for (int i = P + 1; i <=S ; i++)
        {
            // if i is prime add
            // it to prime vector
            if (isPrime(i))
                prime.Add(i);
        }
     
        // if primes are
        // less than N
        if (prime.Count < N)
            return;
        primeSum(0, N, S, 0);
    }
     
    // Driver Code
    static void Main()
    {
        int S = 54, N = 2, P = 3;
        allPrime(N, S, P);
    }
}
 
// This code is contributed by
// Manish Shaw(manishshaw1)
PHP



<?php
// PHP Program to print all
// N primes after prime P
// whose sum equals S
 
// vector to store prime
// and N primes whose
// sum equals given S
$set = array();
$prime = array();
 
// function to
// check prime number
function isPrime($x)
{
    // square root of x
    $sqroot = sqrt($x);
    $flag = true;
 
    // since 1 is not
    // prime number
    if ($x == 1)
        return false;
 
    // if any factor is
    // found return false
    for ($i = 2; $i <= $sqroot; $i++)
        if ($x % $i == 0)
            return false;
 
    // no factor found
    return true;
}
 
// function to display N
// primes whose sum equals S
function display()
{
    global $set, $prime;
    $length = count($set);
    for ($i = 0; $i < $length; $i++)
        echo ($set[$i] . " ");
    echo ("\n");
}
 
// function to evaluate
// all possible N primes
// whose sum equals S
function primeSum($total, $N,
                  $S, $index)
{
    global $set, $prime;
     
    // if total equals S
    // And total is reached
    // using N primes
    if ($total == $S &&
        count($set) == $N)
    {
        // display the N primes
        display();
        return;
    }
 
    // if total is greater
    // than S or if index
    // has reached last element
    if ($total > $S ||
        $index == count($prime))
        return;
 
    // add prime[index]
    // to set vector
    array_push($set,
               $prime[$index]);
 
    // include the (index)th
    // prime to total
    primeSum($total + $prime[$index],
             $N, $S, $index + 1);
 
    // remove element
    // from set vector
    array_pop($set);
 
    // exclude (index)th prime
    primeSum($total, $N, $S,
             $index + 1);
}
 
// function to generate
// all primes
function allPrime($N, $S, $P)
{
    global $set, $prime;
     
    // all primes less
    // than S itself
    for ($i = $P + 1;
         $i <= $S ; $i++)
    {
        // if i is prime add
        // it to prime vector
        if (isPrime($i))
            array_push($prime, $i);
    }
 
    // if primes are
    // less than N
    if (count($prime) < $N)
        return;
    primeSum(0, $N, $S, 0);
}
 
// Driver Code
$S = 54; $N = 2; $P = 3;
allPrime($N, $S, $P);
 
// This code is contributed by
// Manish Shaw(manishshaw1)
?>
Javascript



<script>
 
// Javascript Program to print all N primes after
// prime P whose sum equals S
 
// vector to store prime and N primes
// whose sum equals given S
var set = [];
var prime = [];
 
// function to check prime number
function isPrime(x)
{
    // square root of x
    var sqroot = Math.sqrt(x);
    var flag = true;
 
    // since 1 is not prime number
    if (x == 1)
        return false;
 
    // if any factor is found return false
    for (var i = 2; i <= sqroot; i++)
        if (x % i == 0)
            return false;
 
    // no factor found
    return true;
}
 
// function to display N primes whose sum equals S
function display()
{
    var length = set.length;
    for (var i = 0; i < length; i++)
        document.write( set[i] + " ");
    document.write( "<br>");
}
 
// function to evaluate all possible N primes
// whose sum equals S
function primeSum(total, N, S, index)
{
    // if total equals S And
    // total is reached using N primes
    if (total == S && set.length == N)
    {
        // display the N primes
        display();
        return;
    }
 
    // if total is greater than S
    // or if index has reached last element
    if (total > S || index == prime.length)
        return;
 
    // add prime[index] to set vector
    set.push(prime[index]);
 
    // include the (index)th prime to total
    primeSum(total+prime[index], N, S, index+1);
 
    // remove element from set vector
    set.pop();
 
    // exclude (index)th prime
    primeSum(total, N, S, index+1);
}
 
// function to generate all primes
function allPrime(N, S, P)
{
    // all primes less than S itself
    for (var i = P+1; i <=S ; i++)
    {
        // if i is prime add it to prime vector
        if (isPrime(i))
            prime.push(i);
    }
 
    // if primes are less than N
    if (prime.length < N)
        return;
    primeSum(0, N, S, 0);
}
 
// Driver Code
var S = 54, N = 2, P = 3;
allPrime(N, S, P);
 
</script>
Output: 
7 47 
11 43 
13 41 
17 37 
23 31
 
The time complexity of this algorithm is O(n^2) where n is the number of prime numbers between P and S. This is because the nested for loop in the allPrime() function runs for O(n) and the recursive primeSum() function runs for O(n) time as well.
 The space complexity is O(n) because we are using a vector of size n to store prime numbers and another vector of size n to store a possible combination of N primes.
Optimizations : 
The above solution can be optimized by pre-computing all required primes using Sieve of Eratosthenes
 

My Personal Notes
arrow_drop_up
Last Updated :
23 Jan, 2023
Like Article

Save Article

Similar Reads
1.
Count numbers in a given range having prime and non-prime digits at prime and non-prime positions respectively
2.
Print numbers such that no two consecutive numbers are co-prime and every three consecutive numbers are co-prime
3.
Absolute Difference between the Sum of Non-Prime numbers and Prime numbers of an Array
4.
Count prime numbers that can be expressed as sum of consecutive prime numbers
5.
Count prime numbers up to N that can be represented as a sum of two prime numbers
6.
Bitwise AND of the sum of prime numbers and the sum of composite numbers in an array
7.
Absolute difference between the Product of Non-Prime numbers and Prime numbers of an Array
8.
Absolute difference between the XOR of Non-Prime numbers and Prime numbers of an Array
9.
Find prime factors of Z such that Z is product of all even numbers till N that are product of two distinct prime numbers
10.
Check if a prime number can be expressed as sum of two Prime Numbers
Related Tutorials
1.
Learn Data Structures with Javascript | DSA Tutorial
2.
Introduction to Max-Heap – Data Structure and Algorithm Tutorials
3.
Introduction to Set – Data Structure and Algorithm Tutorials
4.
Introduction to Map – Data Structure and Algorithm Tutorials
5.
What is Dijkstra’s Algorithm? | Introduction to Dijkstra's Shortest Path Algorithm
Previous
Find three prime numbers with given sum
Next

Rat in a Maze with multiple steps or jump allowed
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
shubham_rana_77
shubham_rana_77
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue 
We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox