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