Sieve of Sundaram to print all primes smaller than n (original) (raw)

Last Updated : 23 Jul, 2025

Given a number n, print all primes smaller than or equal to n.

**Examples:

Input: n = 10
Output: 2, 3, 5, 7

Input: n = 20
Output: 2, 3, 5, 7, 11, 13, 17, 19

We have discussed Sieve of Eratosthenes algorithm for the above task.

Below is Sieve of Sundaram algorithm.

**printPrimes(n)
[Prints all prime numbers smaller than n]

1. In general Sieve of Sundaram, produces primes smaller than
   (2*x + 2) for given number x. Since we want primes
   smaller than n, we reduce n-1 to half. We call it nNew.
   nNew = (n-1)/2;
   For example, if n = 102, then nNew = 50.
   if n = 103, then nNew = 51

2. Create an array **marked[n] that is going
   to be used to separate numbers of the form i+j+2ij from
   others where 1 <= i <= j

3. Initialize all entries of marked[] as false.

4. // Mark all numbers of the form i + j + 2ij as true
   // where 1 <= i <= j
   Loop for i=1 to nNew
   a) j = i;
   b) Loop While (i + j + 2ij) 2, then print 2 as first prime.

5. Remaining primes are of the form 2i + 1 where i is
   index of NOT marked numbers. So print 2i + 1 for all i
   such that marked[i] is **false.

Below is the implementation of the above algorithm :

C++ `

// C++ program to print primes smaller than n using // Sieve of Sundaram. #include <bits/stdc++.h> using namespace std;

// Prints all prime numbers smaller int SieveOfSundaram(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-1)/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));

// 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;

// Since 2 is a prime number
if (n >= 2)
    cout << 2 << " ";

// Print other primes. Remaining 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)
        cout << 2*i + 1 << " ";

}

// Driver program to test above int main(void) { int n = 20; SieveOfSundaram(n); return 0; }

Java

// Java program to print primes smaller // than n using Sieve of Sundaram. import java.util.Arrays; class GFG {

// Prints all prime numbers smaller static int SieveOfSundaram(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 - 1) / 2;

// This array is used to separate numbers of the 
// form i+j+2ij from others where 1 <= i <= j
boolean marked[] = new boolean[nNew + 1];

// Initialize all elements as not marked
Arrays.fill(marked, false);

// 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;

// Since 2 is a prime number
if (n >= 2)
System.out.print(2 + " ");

// Print other primes. Remaining 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)
    System.out.print(2 * i + 1 + " ");
return -1;

}

// Driver code public static void main(String[] args) { int n = 20; SieveOfSundaram(n); } } // This code is contributed by Anant Agarwal.

Python

Python3 program to print

primes smaller than n using

Sieve of Sundaram.

Prints all prime numbers smaller

def SieveOfSundaram(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 = int((n - 1) / 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
marked = [0] * (nNew + 1);

# 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):
    j = i;
    while((i + j + 2 * i * j) <= nNew):
        marked[i + j + 2 * i * j] = 1;
        j += 1;

# Since 2 is a prime number
if (n >= 2):
    print(2, end = " ");

# Print other primes. Remaining 
# primes are of the form 2*i + 1 
# such that marked[i] is false.
for i in range(1, nNew + 1):
    if (marked[i] == 0):
        print((2 * i + 1), end = " ");

Driver Code

n = 20; SieveOfSundaram(n);

This code is contributed by mits

C#

// C# program to print primes smaller // than n using Sieve of Sundaram. using System;

class GFG {

// Prints all prime numbers smaller static int SieveOfSundaram(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 - 1) / 2;

// This array is used to separate
// numbers of the form i+j+2ij from 
// others where 1 <= i <= j
bool []marked = new bool[nNew + 1];

// Initialize all elements as not marked
for (int i=0;i<nNew+1;i++)
marked[i]=false;


// 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;

// Since 2 is a prime number
if (n >= 2)
Console.Write(2 + " ");

// Print other primes. 
// Remaining 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)
    Console.Write(2 * i + 1 + " ");
return -1;

}

// Driver code public static void Main() { int n = 20; SieveOfSundaram(n); } }

// This code is contributed by nitin mittal

JavaScript

// JavaScript program to print primes smaller // than n using Sieve of Sundaram.

// Prints all prime numbers smaller function SieveOfSundaram(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
let nNew = (n - 1) / 2;

// This array is used to separate
// numbers of the form i+j+2ij from 
// others where 1 <= i <= j
let marked = [];

// Initialize all elements as not marked
for (let i = 0; i < nNew + 1; i++)
marked[i] = false;

// Main logic of Sundaram. 
// Mark all numbers of the
// form i + j + 2ij as true
// where 1 <= i <= j
for (let i = 1; i <= nNew; i++)
for (let j = i; (i + j + 2 * i * j) <= nNew; j++)
    marked[i + j + 2 * i * j] = true;

// Since 2 is a prime number
if (n >= 2)
  console.log(2 + " ");

// Print other primes. 
// Remaining primes are of 
// the form 2*i + 1 such
// that marked[i] is false.
for (let i = 1; i <= nNew; i++)
if (marked[i] == false)
    console.log(2 * i + 1 + " ");
return -1;

}

// Driver program let n = 20; SieveOfSundaram(n);

PHP

`

Output

2 3 5 7 11 13 17 19

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

**Illustration:
All red entries in below illustration are marked entries. For every remaining (or black) entry x, the number 2x+1 is prime.
Lets see how it works for n=102, we will have the sieve for (n-1)/2 as follows:

Mark all the numbers which can be represented as i + j + 2ij

Now for all the unmarked numbers in the list, find 2x+1 and that will be the prime:
Like 2*1+1=3
2*3+1=7
2*5+1=11
2*6+1=13
2*8+1=17 and so on..
**How does this work?
When we produce our final output, we produce all integers of form 2x+1 (i.e., they are odd) except 2 which is handled separately.

Let q be an integer of the form 2x + 1.

q is excluded if and only if x is of the
form i + j + 2ij. That means,

q = 2(i + j + 2ij) + 1
= (2i + 1)(2j + 1)

So, an odd integer is excluded from the final list if
and only if it has a factorization of the form (2i + 1)(2j + 1)
which is to say, if it has a non-trivial odd factor.

Source: Wiki

**Reference:
https://en.wikipedia.org/wiki/Sieve_of_Sundaram