# Sieve of Sundaram to print all primes smaller than n

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 a number given number x. Since we want primes
smaller than n, we reduce n-2 to half. We call it nNew.
nNew = (n-2)/2;
For example, if n = 102, then nNew = 50.

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 + 2*i*j) <= nNew
(i)  primes[i + j + 2*i*j] = true;
(ii) j++

5) If n > 2, then print 2 as first prime.

6) 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 C++ implementation of above algorithm:

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

// Initalize 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;
}
```
`2 3 5 7 11 13 17 19`

Illustration:
All red entries in below illustration are marked entries. For every remaining (or black) entry x, the number 2x+1 is prime.

How does this work?
When we produce our final output, we produce all integers of the 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
```

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
3.5 Average Difficulty : 3.5/5.0
Based on 8 vote(s)