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

Last Updated : 23 Jul, 2025

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<bits/stdc++.h> using namespace std; const int MAX = 10000;

// Array to store all prime less than and equal to 10^6 vector primes;

// Utility function for Sieve of Sundaram void sieveSundaram() { // In general Sieve of Sundaram, produces primes smaller // than (2x + 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 + 2i*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 (2x + 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 + 2i*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 primes = new List();

// Utility function for Sieve of Sundaram static void sieveSundaram() { // In general Sieve of Sundaram, produces // primes smaller than (2x + 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 + 2i*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

MAX,MAX, MAX,primes; // 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=arrayfill(0,(int)(marked = array_fill(0, (int)(marked=arrayf​ill(0,(int)(MAX / 2) + 100, false); // Main logic of Sundaram. Mark all // numbers which do not generate prime // number by doing 2*i+1 for ($i = 1; i<=(sqrt(i <= (sqrt(i<=(sqrt(MAX) - 1) / 2; $i++) for ($j = ($i * ($i + 1)) << 1; j<=j <= j<=MAX / 2; j=j = j=j + 2 * $i + 1) marked[marked[marked[j] = true; // Since 2 is a prime number array_push($primes, 2); // Print other primes. Remaining primes // are of the form 2*i + 1 such that // marked[i] is false. for ($i = 1; i<=i <= i<=MAX / 2; $i++) if ($marked[$i] == false) array_push($primes, 2 * $i + 1); } // Function to perform Goldbach's conjecture function findPrimes($n) { global MAX,MAX, MAX,primes; // Return if number is not even // or less than 3 if ($n <= 2 || $n % 2 != 0) { print("Invalid Input \n"); return; } // Check only upto half of number for ($i = 0; primes[primes[primes[i] <= n/2;n / 2; n/2;i++) { // find difference by subtracting // current prime from n diff=diff = diff=n - primes[primes[primes[i]; // Search if the difference is also a // prime number if (in_array($diff, $primes)) { // Express as a sum of primes print($primes[$i] . " + " . diff."=".diff . " = " . diff."=".n . "\n"); return; } } } // 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 ?>

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.