Skip to content
Related Articles

Related Articles

Find a sequence of N prime numbers whose sum is a composite number

View Discussion
Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 31 May, 2022
View Discussion
Improve Article
Save Article

Given an integer N and the task is to find a sequence of N prime numbers whose sum is a composite number.
Examples: 
 

Input: N = 5 
Output: 2 3 5 7 11 
2 + 3 + 5 + 7 + 11 = 28 which is composite.
Input: N = 6 
Output: 3 5 7 11 13 17 
 

 

Approach: The sum of two prime numbers is always even which is composite as they are odd numbers except 2. There are two cases now, 
 

  1. When N is even then we can print any N prime numbers except 2 and their sum will always be even i.e. odd numbers when added even a number of times will give an even sum.
  2. When N is odd then we can print 2 and any other N – 1 prime to make sure that the sum is even. Since, N – 1 is even so the sum will be even for any primes except 2 then we add 2 as the Nth number to make sure that the sum remains even.

Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
#define MAXN 100000
 
// To store prime numbers
vector<int> v;
 
// Function to find and store
// all the primes <= n
void SieveOfEratosthenes(int n)
{
    // Create a boolean array "prime[0..n]" and initialize
    // all entries it as true. A value in prime[i] will
    // finally be false if i is Not a prime, else true.
    bool prime[n + 1];
    memset(prime, true, sizeof(prime));
 
    for (int p = 2; p * p <= n; p++) {
 
        // If prime[p] is not changed, then it is a prime
        if (prime[p] == true) {
 
            // Update all multiples of p greater than or
            // equal to the square of it
            // numbers which are multiple of p and are
            // less than p^2 are already been marked.
            for (int i = p * p; i <= n; i += p)
                prime[i] = false;
        }
    }
 
    // Store all the prime numbers
    for (int p = 2; p <= n; p++)
        if (prime[p])
            v.push_back(p);
}
 
// Function to print the required sequence
void GetSequence(int n)
{
 
    // If n is even then we do not include 2
    // and start the sequence from the 2nd
    // smallest prime else we include 2
    int i = (n % 2 == 0) ? 1 : 0;
 
    int cnt = 0;
    // Print the sequence
    while (cnt < n) {
        cout << v[i] << " ";
        i++;
        cnt++;
    }
}
 
// Driver code
int main()
{
    int n = 6;
    SieveOfEratosthenes(MAXN);
 
    GetSequence(n);
 
    return 0;
}

Java




// Java implementation of the above approach
import java.util.*;
 
class GFG
{
     
static int MAXN = 100000;
 
// To store prime numbers
static Vector<Integer> v = new Vector<Integer>();
 
// Function to find and store
// all the primes <= n
static void SieveOfEratosthenes(int n)
{
    // Create a boolean array "prime[0..n]" and initialize
    // all entries it as true. A value in prime[i] will
    // finally be false if i is Not a prime, else true.
    boolean[] prime = new boolean[n + 1];
    Arrays.fill(prime,true);
 
    for (int p = 2; p * p <= n; p++)
    {
 
        // If prime[p] is not changed, then it is a prime
        if (prime[p] == true)
        {
 
            // Update all multiples of p greater than or
            // equal to the square of it
            // numbers which are multiple of p and are
            // less than p^2 are already been marked.
            for (int i = p * p; i <= n; i += p)
                prime[i] = false;
        }
    }
 
    // Store all the prime numbers
    for (int p = 2; p <= n; p++)
        if (prime[p])
            v.add(p);
}
 
// Function to print the required sequence
static void GetSequence(int n)
{
 
    // If n is even then we do not include 2
    // and start the sequence from the 2nd
    // smallest prime else we include 2
    int i = (n % 2 == 0) ? 1 : 0;
 
    int cnt = 0;
     
    // Print the sequence
    while (cnt < n)
    {
        System.out.print(v.get(i) + " ");
        i++;
        cnt++;
    }
}
 
// Driver code
public static void main(String[] args)
{
    int n = 6;
    SieveOfEratosthenes(MAXN);
 
    GetSequence(n);
}
}
 
// This code is contributed by Princi Singh

python




# Python3 implementation of the approach
 
MAXN=100000
 
# To store prime numbers
v=[]
 
# Function to find and store
# all the primes <= n
def SieveOfEratosthenes(n):
 
    # Create a boolean array "prime[0..n]" and initialize
    # all entries it as true. A value in prime[i] will
    # finally be false if i is Not a prime, else true.
    prime=[True for i in range(n + 1)]
 
    for p in range(2,n+1):
 
        # If prime[p] is not changed, then it is a prime
        if (prime[p] == True):
 
            # Update all multiples of p greater than or
            # equal to the square of it
            # numbers which are multiple of p and are
            # less than p^2 are already been marked.
            for i in range(2 * p, n + 1, p):
                prime[i] = False
 
    # Store all the prime numbers
    for p in range(2, n + 1):
        if (prime[p]):
            v.append(p)
 
# Function to print the required sequence
def GetSequence(n):
 
    # If n is even then we do not include 2
    # and start the sequence from the 2nd
    # smallest prime else we include 2
    if n % 2 == 0:
        i = 1
    else:
        i = 0
 
    cnt = 0
    # Print the sequence
    while (cnt < n):
        print(v[i],end=" ")
        i += 1
        cnt += 1
 
 
# Driver code
n = 6
SieveOfEratosthenes(MAXN)
 
GetSequence(n)
 
# This code is contributed by mohit kumar 29

C#




// C# implementation of the approach
using System;
using System.Collections.Generic;
 
class GFG
{
     
static int MAXN = 100000;
 
// To store prime numbers
static List<int> v = new List<int>();
 
// Function to find and store
// all the primes <= n
static void SieveOfEratosthenes(int n)
{
    // Create a boolean array "prime[0..n]" and initialize
    // all entries it as true. A value in prime[i] will
    // finally be false if i is Not a prime, else true.
    Boolean[] prime = new Boolean[n + 1];
    for(int i = 0; i < n + 1; i++)
        prime[i] = true;
 
    for (int p = 2; p * p <= n; p++)
    {
 
        // If prime[p] is not changed, then it is a prime
        if (prime[p] == true)
        {
 
            // Update all multiples of p greater than or
            // equal to the square of it
            // numbers which are multiple of p and are
            // less than p^2 are already been marked.
            for (int i = p * p; i <= n; i += p)
                prime[i] = false;
        }
    }
 
    // Store all the prime numbers
    for (int p = 2; p <= n; p++)
        if (prime[p])
            v.Add(p);
}
 
// Function to print the required sequence
static void GetSequence(int n)
{
 
    // If n is even then we do not include 2
    // and start the sequence from the 2nd
    // smallest prime else we include 2
    int i = (n % 2 == 0) ? 1 : 0;
 
    int cnt = 0;
     
    // Print the sequence
    while (cnt < n)
    {
        Console.Write(v[i] + " ");
        i++;
        cnt++;
    }
}
 
// Driver code
public static void Main(String[] args)
{
    int n = 6;
    SieveOfEratosthenes(MAXN);
 
    GetSequence(n);
}
}
 
/* This code is contributed by PrinciRaj1992 */

Javascript




<script>
 
// Javascript implementation
// of the approach
 
var MAXN = 100000;
 
// To store prime numbers
var v = [];
 
// Function to find and store
// all the primes <= n
function SieveOfEratosthenes(n)
{
    // Create a boolean array
    // "prime[0..n]" and initialize
    // all entries it as true.
    // A value in prime[i] will
    // finally be false if i is Not a prime,
    // else true.
    var prime = Array(n + 1).fill(true);
    var p;
    for (p = 2; p * p <= n; p++) {
 
        // If prime[p] is not changed,
        // then it is a prime
        if (prime[p] == true) {
             var i;
            // Update all multiples
            // of p greater than or
            // equal to the square of it
            // numbers which are multiple
            // of p and are
            // less than p^2 are
            // already been marked.
            for (i = p * p; i <= n; i += p)
                prime[i] = false;
        }
    }
 
    // Store all the prime numbers
    for (p = 2; p <= n; p++)
        if (prime[p])
            v.push(p);
}
 
// Function to print
// the required sequence
function GetSequence(n)
{
 
    // If n is even then we do not include 2
    // and start the sequence from the 2nd
    // smallest prime else we include 2
    var i = (n % 2 == 0) ? 1 : 0;
 
    var cnt = 0;
    // Print the sequence
    while (cnt < n) {
        document.write(v[i] + " ");
        i++;
        cnt++;
    }
}
 
// Driver code
    n = 6;
    SieveOfEratosthenes(MAXN);
    GetSequence(n);
 
</script>

Output: 

3 5 7 11 13 17

 

Auxiliary Space: O(n)


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!