Skip to content
Related Articles

Related Articles

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:
5 is the only such prime below 6. 
2 + 3 = 5.
Input: N = 11 
Output:
 

 

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

 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :