Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Count of primes below N which can be expressed as the sum of two primes

  • Last Updated : 16 Apr, 2021

Given an integer N, the task is to find the count of all the primes below N which can be expressed as the sum of two primes.
Examples: 
 

Input: N = 6 
Output: 1 
5 is the only such prime below 6. 
2 + 3 = 5.
Input: N = 11 
Output: 2 
 

 

Approach: Create an array prime[] where prime[i] will store whether i is prime or not using Sieve of Eratosthenes. Now for every prime from the range [1, N – 1], check whether it can be expressed as the sum of two primes using the approach discussed here.
Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
const int MAX = 100005;
bool prime[MAX];
 
// Function for Sieve of Eratosthenes
void SieveOfEratosthenes()
{
    memset(prime, true, sizeof(prime));
 
    // false here indicates
    // that it is not prime
    prime[0] = false;
    prime[1] = false;
 
    for (int p = 2; p * p <= MAX; p++) {
 
        // If prime[p] is not changed,
        // then it is a prime
        if (prime[p]) {
 
            // Update all multiples of p,
            // set them to non-prime
            for (int i = p * 2; i <= MAX; i += p)
                prime[i] = false;
        }
    }
}
 
// Function to return the count of primes
// less than or equal to n which can be
// expressed as the sum of two primes
int countPrimes(int n)
{
    SieveOfEratosthenes();
 
    // To store the required count
    int cnt = 0;
 
    for (int i = 2; i < n; i++) {
 
        // If the integer is prime and it
        // can be expressed as the sum of
        // 2 and a prime number
        if (prime[i] && prime[i - 2])
            cnt++;
    }
 
    return cnt;
}
 
// Driver code
int main()
{
    int n = 11;
 
    cout << countPrimes(n);
 
    return 0;
}
Java



// Java implementation of the approach
class GFG
{
 
static int MAX = 100005;
static boolean []prime = new boolean[MAX];
 
// Function for Sieve of Eratosthenes
static void SieveOfEratosthenes()
{
 
    for (int i = 0; i < MAX; i++)
        prime[i] = true;
 
    // false here indicates
    // that it is not prime
    prime[0] = false;
    prime[1] = false;
 
    for (int p = 2; p * p < MAX; p++)
    {
        // If prime[p] is not changed,
        // then it is a prime
        if (prime[p])
        {
            // Update all multiples of p,
            // set them to non-prime
            for (int i = p * 2; i < MAX; i += p)
                prime[i] = false;
        }
    }
}
 
// Function to return the count of primes
// less than or equal to n which can be
// expressed as the sum of two primes
static int countPrimes(int n)
{
    SieveOfEratosthenes();
 
    // To store the required count
    int cnt = 0;
 
    for (int i = 2; i < n; i++)
    {
        // If the integer is prime and it
        // can be expressed as the sum of
        // 2 and a prime number
        if (prime[i] && prime[i - 2])
            cnt++;
    }
    return cnt;
}
 
// Driver code
public static void main(String[] args)
{
    int n = 11;
 
    System.out.print(countPrimes(n));
}
}
 
// This code is contributed by 29AjayKumar
Python3



# Python3 implementation of the approach
MAX = 100005
prime = [True for i in range(MAX)]
 
# Function for Sieve of Eratosthenes
def SieveOfEratosthenes():
 
    # False here indicates
    # that it is not prime
    prime[0] = False
    prime[1] = False
 
    for p in range(MAX):
 
        if(p * p > MAX):
            break
 
        # If prime[p] is not changed,
        # then it is a prime
        if (prime[p]):
 
            # Update all multiples of p,
            # set them to non-prime
            for i in range(2 * p, MAX, p):
                prime[i] = False
 
# Function to return the count of primes
# less than or equal to n which can be
# expressed as the sum of two primes
def countPrimes(n):
    SieveOfEratosthenes()
 
    # To store the required count
    cnt = 0
 
    for i in range(2, n):
 
        # If the integer is prime and it
        # can be expressed as the sum of
        # 2 and a prime number
        if (prime[i] and prime[i - 2]):
            cnt += 1
 
    return cnt
 
# Driver code
n = 11
 
print(countPrimes(n))
 
# This code is contributed by Mohit Kumar
C#



    // C# implementation of the approach
using System;
 
class GFG
{
static int MAX = 100005;
static bool []prime = new bool[MAX];
 
// Function for Sieve of Eratosthenes
static void SieveOfEratosthenes()
{
    for (int i = 0; i < MAX; i++)
        prime[i] = true;
 
    // false here indicates
    // that it is not prime
    prime[0] = false;
    prime[1] = false;
 
    for (int p = 2; p * p < MAX; p++)
    {
        // If prime[p] is not changed,
        // then it is a prime
        if (prime[p])
        {
            // Update all multiples of p,
            // set them to non-prime
            for (int i = p * 2; i < MAX; i += p)
                prime[i] = false;
        }
    }
}
 
// Function to return the count of primes
// less than or equal to n which can be
// expressed as the sum of two primes
static int countPrimes(int n)
{
    SieveOfEratosthenes();
 
    // To store the required count
    int cnt = 0;
 
    for (int i = 2; i < n; i++)
    {
        // If the integer is prime and it
        // can be expressed as the sum of
        // 2 and a prime number
        if (prime[i] && prime[i - 2])
            cnt++;
    }
    return cnt;
}
 
// Driver code
public static void Main(String[] args)
{
    int n = 11;
 
    Console.Write(countPrimes(n));
}
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
// javascript implementation of the approach   
var MAX = 100005;
var prime = new Array(MAX).fill(false);
 
    // Function for Sieve of Eratosthenes
    function SieveOfEratosthenes()
    {
        for (i = 0; i < MAX; i++)
            prime[i] = true;
 
        // false here indicates
        // that it is not prime
        prime[0] = false;
        prime[1] = false;
 
        for (p = 2; p * p < MAX; p++)
        {
         
            // If prime[p] is not changed,
            // then it is a prime
            if (prime[p])
            {
             
                // Update all multiples of p,
                // set them to non-prime
                for (i = p * 2; i < MAX; i += p)
                    prime[i] = false;
            }
        }
    }
 
    // Function to return the count of primes
    // less than or equal to n which can be
    // expressed as the sum of two primes
    function countPrimes(n)
    {
        SieveOfEratosthenes();
 
        // To store the required count
        var cnt = 0;
        for (i = 2; i < n; i++)
        {
         
            // If the integer is prime and it
            // can be expressed as the sum of
            // 2 and a prime number
            if (prime[i] && prime[i - 2])
                cnt++;
        }
        return cnt;
    }
 
    // Driver code
        var n = 11;
        document.write(countPrimes(n));
 
// This code is contributed by todaysgaurav
</script>
Output: 
2
 

My Personal Notes
arrow_drop_up
Previous
Count of primes in a given range that can be expressed as sum of perfect squares
Next

Program to check whether 4 points in a 3-D plane are Coplanar
Recommended Articles
Page :
Count primes that can be expressed as sum of two consecutive primes and 1
12, Feb 19
Check if an integer can be expressed as a sum of two semi-primes
22, Oct 18
Count of primes in a given range that can be expressed as sum of perfect squares
15, Jul 20
Find the sum of all Truncatable primes below N
12, Mar 19
Print all safe primes below N
14, Jan 19
Largest palindrome not exceeding N which can be expressed as product of two 3-digit numbers
14, Dec 20
Count numbers from a given range that can be expressed as sum of digits raised to the power of count of digits
02, Mar 21
Sum of the multiples of two numbers below N
13, Dec 18
Elements of Array which can be expressed as power of prime numbers
22, Apr 20
Elements of Array which can be expressed as power of some integer to given exponent K
22, Apr 20
Check if a prime number can be expressed as sum of two Prime Numbers
22, Nov 18
Check if a number can be expressed as sum two abundant numbers
10, Jan 19
Check if a number can be expressed as sum of two Perfect powers
18, Aug 20
Count of numbers below N whose sum of prime divisors is K
11, Sep 19
Count prime numbers that can be expressed as sum of consecutive prime numbers
10, Sep 20
Check if a given number can be expressed as pair-sum of sum of first X natural numbers
12, Sep 20
Count numbers which can be represented as sum of same parity primes
09, Sep 18
Count numbers up to N that cannot be expressed as sum of at least two consecutive positive integers
03, May 21
Count numbers up to N that can be expressed as powers of Prime Numbers
15, Mar 21
Find the sum of all multiples of 2 and 5 below N
14, Nov 18
Sum of all the multiples of 3 and 7 below N
19, Nov 18
Minimum numbers needed to express every integer below N as a sum
09, Nov 18
Check if a number N can be expressed as the sum of powers of X or not
25, May 21
Find ways an Integer can be expressed as sum of n-th power of unique natural numbers
23, Mar 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
KunalGupta
@KunalGupta
Vote for difficulty





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

Start Your Coding Journey Now!