Prime numbers after prime P with sum S

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# 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:

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

Article Tags :

Backtracking

DSA

Prime Number

sieve