Program for Goldbach’s Conjecture (Two Primes with given Sum)

Last Updated : 13 Sep, 2023

Goldbach’s conjecture is one of the oldest and best-known unsolved problems in the number theory of mathematics. Every even integer greater than 2 can be expressed as the sum of two primes.

Examples:

```Input :  n = 44
Output :   3 + 41 (both are primes)

Input :  n = 56
Output :  3 + 53  (both are primes) ```

Approach: 1

1. Find the prime numbers using Sieve of Sundaram
2. Check if the entered number is an even number greater than 2 or not, if no return.
3. If yes, then one by one subtract a prime from N and then check if the difference is also a prime. If yes, then express it as a sum.

Below is the implementation of the above approach:

C++

 `// C++ program to implement Goldbach's conjecture ` `#include ` `using` `namespace` `std; ` `const` `int` `MAX = 10000; ` ` `  `// Array to store all prime less than and equal to 10^6 ` `vector <``int``> primes; ` ` `  `// Utility function for Sieve of Sundaram ` `void` `sieveSundaram() ` `{ ` `    ``// In general Sieve of Sundaram, produces primes smaller ` `    ``// than (2*x + 2) for a number given number x. Since ` `    ``// we want primes smaller than MAX, we reduce MAX to half ` `    ``// This array is used to separate numbers of the form ` `    ``// i + j + 2*i*j from others where 1 <= i <= j ` `    ``bool` `marked[MAX/2 + 100] = {0}; ` ` `  `    ``// Main logic of Sundaram. Mark all numbers which ` `    ``// do not generate prime number by doing 2*i+1 ` `    ``for` `(``int` `i=1; i<=(``sqrt``(MAX)-1)/2; i++) ` `        ``for` `(``int` `j=(i*(i+1))<<1; j<=MAX/2; j=j+2*i+1) ` `            ``marked[j] = ``true``; ` ` `  `    ``// Since 2 is a prime number ` `    ``primes.push_back(2); ` ` `  `    ``// Print other primes. Remaining primes are of the ` `    ``// form 2*i + 1 such that marked[i] is false. ` `    ``for` `(``int` `i=1; i<=MAX/2; i++) ` `        ``if` `(marked[i] == ``false``) ` `            ``primes.push_back(2*i + 1); ` `} ` ` `  `// Function to perform Goldbach's conjecture ` `void` `findPrimes(``int` `n) ` `{ ` `    ``// Return if number is not even or less than 3 ` `    ``if` `(n<=2 || n%2 != 0) ` `    ``{ ` `        ``cout << ``"Invalid Input \n"``; ` `        ``return``; ` `    ``} ` ` `  `    ``// Check only upto half of number ` `    ``for` `(``int` `i=0 ; primes[i] <= n/2; i++) ` `    ``{ ` `        ``// find difference by subtracting current prime from n ` `        ``int` `diff = n - primes[i]; ` ` `  `        ``// Search if the difference is also a prime number ` `        ``if` `(binary_search(primes.begin(), primes.end(), diff)) ` `        ``{ ` `            ``// Express as a sum of primes ` `            ``cout << primes[i] << ``" + "` `<< diff << ``" = "` `                 ``<< n << endl; ` `            ``return``; ` `        ``} ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``// Finding all prime numbers before limit ` `    ``sieveSundaram(); ` ` `  `    ``// Express number as a sum of two primes ` `    ``findPrimes(4); ` `    ``findPrimes(38); ` `    ``findPrimes(100); ` ` `  `    ``return` `0; ` `} `

Java

 `// Java program to implement Goldbach's conjecture ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` `     `  `static` `int` `MAX = ``10000``; ` ` `  `// Array to store all prime less  ` `// than and equal to 10^6 ` `static` `ArrayList primes = ``new` `ArrayList(); ` ` `  `// Utility function for Sieve of Sundaram ` `static` `void` `sieveSundaram() ` `{ ` `    ``// In general Sieve of Sundaram, produces  ` `    ``// primes smaller than (2*x + 2) for  ` `    ``// a number given number x. Since ` `    ``// we want primes smaller than MAX, ` `    ``// we reduce MAX to half This array is  ` `    ``// used to separate numbers of the form ` `    ``// i + j + 2*i*j from others where 1 <= i <= j ` `    ``boolean``[] marked = ``new` `boolean``[MAX / ``2` `+ ``100``]; ` ` `  `    ``// Main logic of Sundaram. Mark all numbers which ` `    ``// do not generate prime number by doing 2*i+1 ` `    ``for` `(``int` `i = ``1``; i <= (Math.sqrt(MAX) - ``1``) / ``2``; i++) ` `        ``for` `(``int` `j = (i * (i + ``1``)) << ``1``; j <= MAX / ``2``; j = j + ``2` `* i + ``1``) ` `            ``marked[j] = ``true``; ` ` `  `    ``// Since 2 is a prime number ` `    ``primes.add(``2``); ` ` `  `    ``// Print other primes. Remaining primes are of the ` `    ``// form 2*i + 1 such that marked[i] is false. ` `    ``for` `(``int` `i = ``1``; i <= MAX / ``2``; i++) ` `        ``if` `(marked[i] == ``false``) ` `            ``primes.add(``2` `* i + ``1``); ` `} ` ` `  `// Function to perform Goldbach's conjecture ` `static` `void` `findPrimes(``int` `n) ` `{ ` `    ``// Return if number is not even or less than 3 ` `    ``if` `(n <= ``2` `|| n % ``2` `!= ``0``) ` `    ``{ ` `        ``System.out.println(``"Invalid Input "``); ` `        ``return``; ` `    ``} ` ` `  `    ``// Check only upto half of number ` `    ``for` `(``int` `i = ``0` `; primes.get(i) <= n / ``2``; i++) ` `    ``{ ` `        ``// find difference by subtracting  ` `        ``// current prime from n ` `        ``int` `diff = n - primes.get(i); ` ` `  `        ``// Search if the difference is  ` `        ``// also a prime number ` `        ``if` `(primes.contains(diff)) ` `        ``{ ` `            ``// Express as a sum of primes ` `            ``System.out.println(primes.get(i) +  ` `                        ``" + "` `+ diff + ``" = "` `+ n); ` `            ``return``; ` `        ``} ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `main (String[] args)  ` `{ ` `    ``// Finding all prime numbers before limit ` `    ``sieveSundaram(); ` ` `  `    ``// Express number as a sum of two primes ` `    ``findPrimes(``4``); ` `    ``findPrimes(``38``); ` `    ``findPrimes(``100``); ` `} ` `} ` ` `  `// This code is contributed by mits `

Python3

 `# Python3 program to implement Goldbach's  ` `# conjecture ` `import` `math ` `MAX` `=` `10000``; ` ` `  `# Array to store all prime less  ` `# than and equal to 10^6 ` `primes ``=` `[]; ` ` `  `# Utility function for Sieve of Sundaram ` `def` `sieveSundaram(): ` `     `  `    ``# In general Sieve of Sundaram, produces  ` `    ``# primes smaller than (2*x + 2) for a  ` `    ``# number given number x. Since we want ` `    ``# primes smaller than MAX, we reduce  ` `    ``# MAX to half. This array is used to  ` `    ``# separate numbers of the form i + j + 2*i*j  ` `    ``# from others where 1 <= i <= j ` `    ``marked ``=` `[``False``] ``*` `(``int``(``MAX` `/` `2``) ``+` `100``); ` ` `  `    ``# Main logic of Sundaram. Mark all  ` `    ``# numbers which do not generate prime ` `    ``# number by doing 2*i+1 ` `    ``for` `i ``in` `range``(``1``, ``int``((math.sqrt(``MAX``) ``-` `1``) ``/` `2``) ``+` `1``): ` `        ``for` `j ``in` `range``((i ``*` `(i ``+` `1``)) << ``1``,  ` `                        ``int``(``MAX` `/` `2``) ``+` `1``, ``2` `*` `i ``+` `1``): ` `            ``marked[j] ``=` `True``; ` ` `  `    ``# Since 2 is a prime number ` `    ``primes.append(``2``); ` ` `  `    ``# Print other primes. Remaining primes  ` `    ``# are of the form 2*i + 1 such that  ` `    ``# marked[i] is false. ` `    ``for` `i ``in` `range``(``1``, ``int``(``MAX` `/` `2``) ``+` `1``): ` `        ``if` `(marked[i] ``=``=` `False``): ` `            ``primes.append(``2` `*` `i ``+` `1``); ` ` `  `# Function to perform Goldbach's conjecture ` `def` `findPrimes(n): ` `     `  `    ``# Return if number is not even  ` `    ``# or less than 3 ` `    ``if` `(n <``=` `2` `or` `n ``%` `2` `!``=` `0``): ` `        ``print``(``"Invalid Input"``); ` `        ``return``; ` ` `  `    ``# Check only upto half of number ` `    ``i ``=` `0``; ` `    ``while` `(primes[i] <``=` `n ``/``/` `2``): ` `         `  `        ``# find difference by subtracting  ` `        ``# current prime from n ` `        ``diff ``=` `n ``-` `primes[i]; ` ` `  `        ``# Search if the difference is also ` `        ``# a prime number ` `        ``if` `diff ``in` `primes: ` `             `  `            ``# Express as a sum of primes ` `            ``print``(primes[i], ``"+"``, diff, ``"="``, n); ` `            ``return``; ` `        ``i ``+``=` `1``; ` ` `  `# Driver code ` ` `  `# Finding all prime numbers before limit ` `sieveSundaram(); ` ` `  `# Express number as a sum of two primes ` `findPrimes(``4``); ` `findPrimes(``38``); ` `findPrimes(``100``); ` ` `  `# This code is contributed ` `# by chandan_jnu `

C#

 `// C# program to implement Goldbach's conjecture ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG ` `{ ` `     `  `static` `int` `MAX = 10000; ` ` `  `// Array to store all prime less  ` `// than and equal to 10^6 ` `static` `List<``int``> primes = ``new` `List<``int``>(); ` ` `  `// Utility function for Sieve of Sundaram ` `static` `void` `sieveSundaram() ` `{ ` `    ``// In general Sieve of Sundaram, produces  ` `    ``// primes smaller than (2*x + 2) for  ` `    ``// a number given number x. Since ` `    ``// we want primes smaller than MAX, ` `    ``// we reduce MAX to half This array is  ` `    ``// used to separate numbers of the form ` `    ``// i + j + 2*i*j from others where 1 <= i <= j ` `    ``Boolean[] marked = ``new` `Boolean[MAX / 2 + 100]; ` ` `  `    ``// Main logic of Sundaram. Mark all numbers which ` `    ``// do not generate prime number by doing 2*i+1 ` `    ``for` `(``int` `i = 1; i <= (Math.Sqrt(MAX) - 1) / 2; i++) ` `        ``for` `(``int` `j = (i * (i + 1)) << 1; j <= MAX / 2; j = j + 2 * i + 1) ` `            ``marked[j] = ``true``; ` ` `  `    ``// Since 2 is a prime number ` `    ``primes.Add(2); ` ` `  `    ``// Print other primes. Remaining primes are of the ` `    ``// form 2*i + 1 such that marked[i] is false. ` `    ``for` `(``int` `i = 1; i <= MAX / 2; i++) ` `        ``if` `(marked[i] == ``false``) ` `            ``primes.Add(2 * i + 1); ` `} ` ` `  `// Function to perform Goldbach's conjecture ` `static` `void` `findPrimes(``int` `n) ` `{ ` `    ``// Return if number is not even or less than 3 ` `    ``if` `(n <= 2 || n % 2 != 0) ` `    ``{ ` `        ``Console.WriteLine(``"Invalid Input "``); ` `        ``return``; ` `    ``} ` ` `  `    ``// Check only upto half of number ` `    ``for` `(``int` `i = 0 ; primes[i] <= n / 2; i++) ` `    ``{ ` `        ``// find difference by subtracting  ` `        ``// current prime from n ` `        ``int` `diff = n - primes[i]; ` ` `  `        ``// Search if the difference is  ` `        ``// also a prime number ` `        ``if` `(primes.Contains(diff)) ` `        ``{ ` `            ``// Express as a sum of primes ` `            ``Console.WriteLine(primes[i] +  ` `                        ``" + "` `+ diff + ``" = "` `+ n); ` `            ``return``; ` `        ``} ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main (String[] args)  ` `{ ` `    ``// Finding all prime numbers before limit ` `    ``sieveSundaram(); ` ` `  `    ``// Express number as a sum of two primes ` `    ``findPrimes(4); ` `    ``findPrimes(38); ` `    ``findPrimes(100); ` `} ` `} ` ` `  `/* This code contributed by PrinciRaj1992 */`

PHP

 ` `

Javascript

 ``

Output

```2 + 2 = 4
7 + 31 = 38
3 + 97 = 100
```

Time Complexity: O(n log n)
Auxiliary Space: O(MAX)

A Goldbach number is a positive integer that can be expressed as the sum of two odd primes. Since four is the only even number greater than two that requires the even prime 2 in order to be written as the sum of two primes, another form of the statement of Goldbach’s conjecture is that all even integers greater than 4 are Goldbach numbers.

Previous
Next