# Count pairs with sum as a prime number and less than n

Given a positive integer n, count distinct number of pairs (x, y) that satisfy following conditions :

• (x + y) is a prime number.
• (x + y) < n
• x != y
• 1 <= x, y

Examples:

```Input : n = 6
Output : 3
prime pairs whose sum is less than 6 are:
(1,2), (1,4), (2,3)

Input : 12
Output : 11
prime pairs whose sum is less than 12 are:
(1,2),  (1,4), (2,3), (1,6), (2,5), (3,4),
(1,10), (2,9), (3,8), (4,7), (5,6)
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

```1) Find all prime numbers less than n using
Sieve of Sundaram

2) For each prime number p, count distinct
pairs that sum up to p.

For any odd number n, number of distinct pairs
that add upto n are n/2
Since, a prime number is a odd number, the
same applies for it too. ```

Example,
For prime number p = 7
distinct pairs that add upto p: p/2 = 7/2 = 3
The three pairs are (1,6), (2,5), (3,4)

For prime number p = 23
distinct pairs that add upto p: p/2 = 23/2 = 11

## C++

 `// C++ implementation of prime pairs ` `// whose sum is less than n ` `#include ` `using` `namespace` `std; ` ` `  `// Sieve of Sundaram for generating ` `// prime numbers less than n ` `void` `SieveOfSundaram(``bool` `marked[], ``int` `nNew) ` `{ ` `    ``// Main logic of Sundaram.  Mark all numbers ` `    ``// of the form i + j + 2ij as true where ` `    ``// 1 <= i <= j ` `    ``for` `(``int` `i=1; i<=nNew; i++) ` `        ``for` `(``int` `j=i; (i + j + 2*i*j) <= nNew; j++) ` `            ``marked[i + j + 2*i*j] = ``true``; ` `} ` ` `  `// Returns number of pairs with fiven conditions. ` `int` `countPrimePairs(``int` `n) ` `{ ` `    ``// In general Sieve of Sundaram, produces ` `    ``// primes smaller than (2*x + 2) for a number ` `    ``// given number x. Since we want primes smaller ` `    ``// than n, we reduce n to half ` `    ``int` `nNew = (n-2)/2; ` ` `  `    ``// This array is used to separate numbers of ` `    ``// the form i+j+2ij from others where ` `    ``// 1 <= i <= j ` `    ``bool` `marked[nNew + 1]; ` ` `  `    ``// Initialize all elements as not marked ` `    ``memset``(marked, ``false``, ``sizeof``(marked)); ` ` `  `    ``SieveOfSundaram(marked, nNew); ` ` `  `    ``int` `count = 0, prime_num; ` ` `  `    ``// Find primes. Primes are of the form ` `    ``// 2*i + 1 such that marked[i] is false. ` `    ``for` `(``int` `i=1; i<=nNew; i++) ` `    ``{ ` `        ``if` `(marked[i] == ``false``) ` `        ``{ ` `            ``prime_num = 2*i + 1; ` ` `  `            ``// For a given prime number p ` `            ``// number of distinct pairs(i,j) ` `            ``// where (i+j) = p are p/2 ` `            ``count = count + (prime_num / 2); ` `        ``} ` `    ``} ` ` `  `    ``return` `count; ` `} ` ` `  `// Driver program to test above ` `int` `main(``void``) ` `{ ` `    ``int` `n = 12; ` `    ``cout << ``"Number of prime pairs: "` `         ``<< countPrimePairs(n); ` `    ``return` `0; ` `} `

## Java

 `// Java implementation of prime pairs  ` `// whose sum is less than n  ` ` `  `class` `GFG ` `{ ` `     `  `// Sieve of Sundaram for generating  ` `// prime numbers less than n  ` `static` `void` `SieveOfSundaram(``boolean` `marked[], ``int` `nNew)  ` `{  ` `     `  `    ``// Main logic of Sundaram. Mark all numbers  ` `    ``// of the form i + j + 2ij as true where  ` `    ``// 1 <= i <= j  ` `    ``for` `(``int` `i = ``1``; i <= nNew; i++)  ` `        ``for` `(``int` `j = i; (i + j + ``2` `* i * j) <= nNew; j++)  ` `            ``marked[i + j + ``2` `* i * j] = ``true``;  ` `}  ` ` `  `// Returns number of pairs with fiven conditions.  ` `static` `int` `countPrimePairs(``int` `n)  ` `{  ` `    ``// In general Sieve of Sundaram, produces  ` `    ``// primes smaller than (2*x + 2) for a number  ` `    ``// given number x. Since we want primes smaller  ` `    ``// than n, we reduce n to half  ` `    ``int` `nNew = (n - ``2``) / ``2``;  ` ` `  `    ``// This array is used to separate numbers of  ` `    ``// the form i+j+2ij from others where  ` `    ``// 1 <= i <= j  ` `    ``// Initialize all elements as not marked ` `    ``boolean` `marked[]=``new` `boolean``[nNew + ``1``];  ` ` `  `    ``SieveOfSundaram(marked, nNew); ` `    ``int` `count = ``0``, prime_num;  ` ` `  `    ``// Find primes. Primes are of the form  ` `    ``// 2*i + 1 such that marked[i] is false.  ` `    ``for` `(``int` `i = ``1``; i <= nNew; i++)  ` `    ``{  ` `        ``if` `(marked[i] == ``false``)  ` `        ``{  ` `            ``prime_num = ``2` `* i + ``1``;  ` ` `  `            ``// For a given prime number p  ` `            ``// number of distinct pairs(i, j)  ` `            ``// where (i + j) = p are p/2  ` `            ``count = count + (prime_num / ``2``);  ` `        ``}  ` `    ``}  ` `    ``return` `count;  ` `}  ` ` `  `// Driver code ` `public` `static` `void` `main (String[] args)  ` `{ ` `    ``int` `n = ``12``;  ` `    ``System.out.println(``"Number of prime pairs: "` `+ ` `    ``countPrimePairs(n));  ` `}  ` `} ` ` `  `// This code is contributed by mits `

## Python3

 `# Python3 implementation of prime pairs ` `# whose sum is less than n ` ` `  `# Sieve of Sundaram for generating ` `# prime numbers less than n ` `def` `SieveOfSundaram(marked, nNew): ` `     `  `    ``# Main logic of Sundaram. Mark all numbers ` `    ``# of the form i + j + 2ij as true where ` `    ``# 1 <= i <= j ` `    ``for` `i ``in` `range``(``1``, nNew ``+` `1``): ` `        ``for` `j ``in` `range``(i, nNew): ` `            ``if` `i ``+` `j ``+` `2` `*` `i ``*` `j > nNew: ` `                ``break` `            ``marked[i ``+` `j ``+` `2` `*` `i ``*` `j] ``=` `True` ` `  `# Returns number of pairs with fiven conditions. ` `def` `countPrimePairs(n): ` `     `  `    ``# In general Sieve of Sundaram, produces ` `    ``# primes smaller than (2*x + 2) for a number ` `    ``# given number x. Since we want primes smaller ` `    ``# than n, we reduce n to half ` `    ``nNew ``=` `(n ``-` `2``) ``/``/` `2` ` `  `    ``# This array is used to separate numbers  ` `    ``# of the form i+j+2ij from others where ` `    ``# 1 <= i <= j ` `    ``marked ``=` `[ ``False` `for` `i ``in` `range``(nNew ``+` `1``)] ` ` `  `    ``SieveOfSundaram(marked, nNew) ` ` `  `    ``count, prime_num ``=` `0``, ``0` ` `  `    ``# Find primes. Primes are of the form ` `    ``# 2*i + 1 such that marked[i] is false. ` `    ``for` `i ``in` `range``(``1``, nNew ``+` `1``): ` `        ``if` `(marked[i] ``=``=` `False``): ` ` `  `            ``prime_num ``=` `2` `*` `i ``+` `1` ` `  `            ``# For a given prime number p ` `            ``# number of distinct pairs(i,j) ` `            ``# where (i+j) = p are p/2 ` `            ``count ``=` `count ``+` `(prime_num ``/``/` `2``) ` ` `  `    ``return` `count ` ` `  `# Driver Code ` `n ``=` `12` `print``(``"Number of prime pairs: "``,  ` `             ``countPrimePairs(n)) ` ` `  `# This code is contributed by Mohit kumar 29 `

## C#

 `// C# implementation of prime pairs  ` `// whose sum is less than n  ` `using` `System; ` ` `  `class` `GFG ` `{ ` `     `  `// Sieve of Sundaram for generating  ` `// prime numbers less than n  ` `static` `void` `SieveOfSundaram(``bool``[] marked,  ` `                            ``int` `nNew)  ` `{  ` `     `  `    ``// Main logic of Sundaram. Mark all numbers  ` `    ``// of the form i + j + 2ij as true where  ` `    ``// 1 <= i <= j  ` `    ``for` `(``int` `i = 1; i <= nNew; i++)  ` `        ``for` `(``int` `j = i;  ` `            ``(i + j + 2 * i * j) <= nNew; j++)  ` `            ``marked[i + j + 2 * i * j] = ``true``;  ` `}  ` ` `  `// Returns number of pairs with fiven conditions.  ` `static` `int` `countPrimePairs(``int` `n)  ` `{  ` `    ``// In general Sieve of Sundaram, produces  ` `    ``// primes smaller than (2*x + 2) for a   ` `    ``// number given number x. Since we want  ` `    ``// primes smaller than n, we reduce n to half  ` `    ``int` `nNew = (n - 2) / 2;  ` ` `  `    ``// This array is used to separate numbers  ` `    ``// of the form i+j+2ij from others where  ` `    ``// 1 <= i <= j  ` `    ``// Initialize all elements as not marked ` `    ``bool``[] marked = ``new` `bool``[nNew + 1];  ` ` `  `    ``SieveOfSundaram(marked, nNew); ` `    ``int` `count = 0, prime_num;  ` ` `  `    ``// Find primes. Primes are of the form  ` `    ``// 2*i + 1 such that marked[i] is false.  ` `    ``for` `(``int` `i = 1; i <= nNew; i++)  ` `    ``{  ` `        ``if` `(marked[i] == ``false``)  ` `        ``{  ` `            ``prime_num = 2 * i + 1;  ` ` `  `            ``// For a given prime number p  ` `            ``// number of distinct pairs(i, j)  ` `            ``// where (i + j) = p are p/2  ` `            ``count = count + (prime_num / 2);  ` `        ``}  ` `    ``}  ` `    ``return` `count;  ` `}  ` ` `  `// Driver code ` `public` `static` `void` `Main ()  ` `{ ` `    ``int` `n = 12;  ` `    ``Console.WriteLine(``"Number of prime pairs: "` `+  ` `                             ``countPrimePairs(n));  ` `}  ` `} ` ` `  `// This Code is Contribute by Mukul Singh. `

## PHP

 ` `

Output:

```Number of prime pairs: 11
```

This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes arrow_drop_up

Article Tags :

2

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.