Related Articles

# Bitwise Sieve

Given a number n, print all primes smaller than n.
Examples :

```Input : 30
Output : 2 3 5 7 11 13 17 19 23 29

Input : n = 100
Output : 2 3 5 7 11 13 17 19 23 29 31 37
41 43 47 53 59 61 67 71 73 79 83
89 97 ```

We know how to calculate all primes less than n by the Sieve of Eratosthenes. Below is an implementation of Sieve.
One optimization in the below implementation is, we have skipped all even numbers altogether.
We reduce the size of the prime array to half. We also reduce all iterations to half.

## C++

 `// C++ program to implement normal Sieve``// of Eratosthenes using simple optimization``// to reduce size of prime array to half and``// reducing iterations.``#include ``using` `namespace` `std;` `void` `normalSieve(``int` `n)``{``    ``// prime[i] is going to store true if``    ``// if i*2 + 1 is composite.``    ``bool` `prime[n/2];``    ``memset``(prime, ``false``, ``sizeof``(prime));` `    ``// 2 is the only even prime so we can``    ``// ignore that. Loop starts from 3.``    ``for` `(``int` `i=3 ; i*i < n; i+=2)``    ``{``        ``// If i is prime, mark all its``        ``// multiples as composite``        ``if` `(prime[i/2] == ``false``)``            ``for` `(``int` `j=i*i; j

## Java

 `// Java program to implement normal Sieve``// of Eratosthenes using simple optimization``// to reduce size of prime array to half and``// reducing iterations.``import` `java.util.Arrays;` `class` `GFG``{``    ``static` `void` `normalSieve(``int` `n)``    ``{``        ``// prime[i] is going to store true if``        ``// if i*2 + 1 is composite.``        ``boolean` `prime[]=``new` `boolean``[n / ``2``];``        ``Arrays.fill(prime, ``false``);``    ` `        ``// 2 is the only even prime so we can``        ``// ignore that. Loop starts from 3.``        ``for` `(``int` `i = ``3` `; i * i < n; i += ``2``)``        ``{``            ``// If i is prime, mark all its``            ``// multiples as composite``            ``if` `(prime[i / ``2``] == ``false``)``                ``for` `(``int` `j = i * i; j < n; j += i * ``2``)``                    ``prime[j / ``2``] = ``true``;``        ``}``    ` `        ``// writing 2 separately``        ``System.out.print(``"2 "``);``    ` `        ``// Printing other primes``        ``for` `(``int` `i = ``3``; i < n ; i += ``2``)``            ``if` `(prime[i / ``2``] == ``false``)``                ``System.out.print(i + ``" "``);``    ``}``    ``public` `static` `void` `main (String[] args)``    ``{``        ``int` `n = ``100` `;``        ``normalSieve(n);``    ``}``}` `// This code is contributed by Anant Agarwal.`

## Python3

 `# Sieve of Eratosthenes using``# simple optimization to reduce``# size of prime array to half and``# reducing iterations.``def` `normalSieve(n):` `    ``# prime[i] is going to store``    ``# true if if i*2 + 1 is composite.``    ``prime ``=` `[``0``]``*``int``(n ``/` `2``);` `    ``# 2 is the only even prime so``    ``# we can ignore that. Loop``    ``# starts from 3.``    ``i ``=` `3` `;``    ``while``(i ``*` `i < n):``        ``# If i is prime, mark all its``        ``# multiples as composite``        ``if` `(prime[``int``(i ``/` `2``)] ``=``=` `0``):``            ``j ``=` `i ``*` `i;``            ``while``(j < n):``                ``prime[``int``(j ``/` `2``)] ``=` `1``;``                ``j ``+``=` `i ``*` `2``;``        ``i ``+``=` `2``;` `    ``# writing 2 separately``    ``print``(``2``,end``=``" "``);` `    ``# Printing other primes``    ``i ``=` `3``;``    ``while``(i < n):``        ``if` `(prime[``int``(i ``/` `2``)] ``=``=` `0``):``            ``print``(i,end``=``" "``);``        ``i ``+``=` `2``;`  `# Driver code``if` `__name__``=``=``'__main__'``:``    ``n ``=` `100` `;``    ``normalSieve(n);` `# This code is contributed by mits.`

## C#

 `// C# program to implement normal Sieve``// of Eratosthenes using simple optimization``// to reduce size of prime array to half and``// reducing iterations.``using` `System;` `namespace` `prime``{``    ``public` `class` `GFG``    ``{    ``                ` `        ``public` `static` `void` `normalSieve(``int` `n)``        ``{``            ` `        ``// prime[i] is going to store true if``        ``// if i*2 + 1 is composite.``        ``bool``[] prime = ``new` `bool``[n/2];``        ` `        ``for``(``int` `i = 0; i < n/2; i++)``            ``prime[i] = ``false``;``        ` `        ``// 2 is the only even prime so we can``        ``// ignore that. Loop starts from 3.``        ``for``(``int` `i = 3; i*i < n; i = i+2)``        ``{``            ``// If i is prime, mark all its``            ``// multiples as composite``            ``if` `(prime[i / 2] == ``false``)``            ` `                ``for` `(``int` `j = i * i; j < n; j += i * 2)``                    ``prime[j / 2] = ``true``;``        ``}``        ` `        ``// writing 2 separately``        ``Console.Write(``"2 "``);``    ` `        ``// Printing other primes``        ``for` `(``int` `i = 3; i < n ; i += 2)``        ` `            ``if` `(prime[i / 2] == ``false``)``                ``Console.Write(i + ``" "``);``            ` `        ``}``        ` `        ``// Driver Code``        ``public` `static` `void` `Main()``        ``{``        ``int` `n = 100;``        ``normalSieve(n);``        ``}``    ``}``}` `// This code is contributed by Sam007.`

## PHP

 ``

## Javascript

 ``

Output :

`2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 `

Further optimization using bitwise operators.
The above implementation uses bool data type which takes 1 byte. We can optimize space to n/8 by using individual bits of an integer to represent individual primes. We create an integer array of size n/64. Note that the size of the array is reduced to n/64 from n/2 (Assuming that integers take 32 bits).

## C++

 `// C++ program to implement bitwise Sieve``// of Eratosthenes.``#include ``using` `namespace` `std;` `// Checks whether x is prime or composite``bool` `ifnotPrime(``int` `prime[], ``int` `x)``{``    ``// checking whether the value of element``    ``// is set or not. Using prime[x/64], we find``    ``// the slot in prime array. To find the bit``    ``// number, we divide x by 2 and take its mod``    ``// with 32.``    ``return` `(prime[x/64] & (1 << ((x >> 1) & 31)));``}` `// Marks x composite in prime[]``bool` `makeComposite(``int` `prime[], ``int` `x)``{``    ``// Set a bit corresponding to given element.``    ``// Using prime[x/64], we find the slot in prime``    ``// array. To find the bit number, we divide x``    ``// by 2 and take its mod with 32.``    ``prime[x/64] |= (1 << ((x >> 1) & 31));``}` `// Prints all prime numbers smaller than n.``void` `bitWiseSieve(``int` `n)``{``    ``// Assuming that n takes 32 bits, we reduce``    ``// size to n/64 from n/2.``    ``int` `prime[n/64];` `    ``// Initializing values to 0 .``    ``memset``(prime, 0, ``sizeof``(prime));` `    ``// 2 is the only even prime so we can ignore that``    ``// loop starts from 3 as we have used in sieve of``    ``// Eratosthenes .``    ``for` `(``int` `i = 3; i * i <= n; i += 2) {` `        ``// If i is prime, mark all its multiples as``        ``// composite``        ``if` `(!ifnotPrime(prime, i))``            ``for` `(``int` `j = i * i, k = i << 1; j < n; j += k)``                ``makeComposite(prime, j);``    ``}` `    ``// writing 2 separately``    ``printf``(``"2 "``);` `    ``// Printing other primes``    ``for` `(``int` `i = 3; i <= n; i += 2)``        ``if` `(!ifnotPrime(prime, i))``            ``printf``(``"%d "``, i);``}` `// Driver code``int` `main()``{``    ``int` `n = 30;``    ``bitWiseSieve(n);``    ``return` `0;``}`

## Java

 `// JAVA Code to implement Bitwise``// Sieve of Eratosthenes.``import` `java.util.*;` `class` `GFG {``    ` `    ``// Checks whether x is prime or composite``    ``static` `int` `ifnotPrime(``int` `prime[], ``int` `x)``    ``{``        ``// checking whether the value of element``        ``// is set or not. Using prime[x/64],``        ``// we find the slot in prime array.``        ``// To find the bit number, we divide x``        ``// by 2 and take its mod with 32.``        ``return` `(prime[x/``64``] & (``1` `<< ((x >> ``1``) & ``31``)));``    ``}``     ` `    ``// Marks x composite in prime[]``    ``static` `void` `makeComposite(``int` `prime[], ``int` `x)``    ``{``        ``// Set a bit corresponding to given element.``        ``// Using prime[x/64], we find the slot``        ``// in prime array. To find the bit number,``        ``// we divide x by 2 and take its mod with 32.``        ``prime[x/``64``] |= (``1` `<< ((x >> ``1``) & ``31``));``    ``}``     ` `    ``// Prints all prime numbers smaller than n.``    ``static` `void` `bitWiseSieve(``int` `n)``    ``{``        ``// Assuming that n takes 32 bits,``        ``// we reduce size to n/64 from n/2.``        ``int` `prime[] = ``new` `int``[n/``64` `+ ``1``];``     ` `     ` `        ``// 2 is the only even prime so we``        ``// can ignore that loop starts from``        ``// 3 as we have used in sieve of``        ``// Eratosthenes .``        ``for` `(``int` `i = ``3``; i * i <= n; i += ``2``) {``     ` `            ``// If i is prime, mark all its``            ``// multiples as composite``            ``if` `(ifnotPrime(prime, i)==``0``)``                ``for` `(``int` `j = i * i, k = i << ``1``;``                                  ``j < n; j += k)``                    ``makeComposite(prime, j);``        ``}``     ` `        ``// writing 2 separately``        ``System.out.printf(``"2 "``);``     ` `        ``// Printing other primes``        ``for` `(``int` `i = ``3``; i <= n; i += ``2``)``            ``if` `(ifnotPrime(prime, i) == ``0``)``                ``System.out.printf(``"%d "``, i);``    ``}``    ` `    ``/* Driver program to test above function */``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``30``;``        ``bitWiseSieve(n);``    ``}``}` `// This code is contributed by Arnav Kr. Mandal.   `

## Python3

 `# Python3 program to implement``# bitwise Sieve of Eratosthenes.` `# Checks whether x is``# prime or composite``def` `ifnotPrime(prime, x):` `    ``# Checking whether the value``    ``# of element is set or not.``    ``# Using prime[x/64], we find``    ``# the slot in prime array.``    ``# To find the bit we divide``    ``# x by 2 and take its mod``    ``# with 32.``    ``return` `(prime[``int``(x ``/` `64``)] &``           ``(``1` `<< ((x >> ``1``) & ``31``)))` `# Marks x composite in prime[]``def` `makeComposite(prime, x):``  ` `    ``# Set a bit corresponding to``    ``# given element. Using prime[x/64],``    ``# we find the slot in prime array. ``    ``# To find the bit number, we divide x``    ``# by 2 and take its mod with 32.``    ``prime[``int``(x ``/` `64``)] |``=``    ``(``1` `<< ((x >> ``1``) & ``31``))` `# Prints all prime numbers``# smaller than n.``def` `bitWiseSieve(n):` `    ``# Assuming that n takes 32 bits,``    ``# we reduce size to n/64 from n/2.``    ``# Initializing values to 0.``    ``prime ``=` `[``0` `for` `i ``in` `range``(``int``(n ``/` `64``) ``+` `1``)]` `    ``# 2 is the only even prime so``    ``# we can ignore that loop``    ``# starts from 3 as we have used ``    ``# in sieve of Eratosthenes``    ``for` `i ``in` `range``(``3``, n ``+` `1``, ``2``):``        ``if``(i ``*` `i <``=` `n):` `            ``# If i is prime, mark all``            ``# its multiples as composite``            ``if``(ifnotPrime(prime, i)):``                ``continue``            ``else``:``                ``k ``=` `i << ``1`               `                ``for` `j ``in` `range``(i ``*` `i, n, k):``                    ``k ``=` `i << ``1``                    ``makeComposite(prime, j)``                    ` `    ``# Writing 2 separately``    ``print``(``"2 "``, end ``=` `"")` `    ``# Printing other primes``    ``for` `i ``in` `range``(``3``, n ``+` `1``, ``2``):``        ``if``(ifnotPrime(prime, i)):``            ``continue``        ``else``:``            ``print``(i, end ``=` `" "``)``            ` `# Driver code``n ``=` `30``bitWiseSieve(n)` `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# Code to implement Bitwise``// Sieve of Eratosthenes.``using` `System;` `class` `GFG``{` `// Checks whether x is``// prime or composite``static` `int` `ifnotPrime(``int``[] prime, ``int` `x)``{``    ``// checking whether the value``    ``// of element is set or not.``    ``// Using prime[x/64], we find``    ``// the slot in prime array.``    ``// To find the bit number, we``    ``// divide x by 2 and take its``    ``// mod with 32.``    ``return` `(prime[x / 64] &``           ``(1 << ((x >> 1) & 31)));``}` `// Marks x composite in prime[]``static` `void` `makeComposite(``int``[] prime,``                          ``int` `x)``{``    ``// Set a bit corresponding to``    ``// given element. Using prime[x/64],``    ``// we find the slot in prime array.``    ``// To find the bit number, we divide``    ``// x by 2 and take its mod with 32.``    ``prime[x / 64] |= (1 << ((x >> 1) & 31));``}` `// Prints all prime numbers``// smaller than n.``static` `void` `bitWiseSieve(``int` `n)``{``    ``// Assuming that n takes 32 bits,``    ``// we reduce size to n/64 from n/2.``    ``int``[] prime = ``new` `int``[(``int``)(n / 64) + 1];`  `    ``// 2 is the only even prime so we``    ``// can ignore that loop starts from``    ``// 3 as we have used in sieve of``    ``// Eratosthenes .``    ``for` `(``int` `i = 3; i * i <= n; i += 2)``    ``{` `        ``// If i is prime, mark all its``        ``// multiples as composite``        ``if` `(ifnotPrime(prime, i) == 0)``            ``for` `(``int` `j = i * i, k = i << 1;``                             ``j < n; j += k)``                ``makeComposite(prime, j);``    ``}` `    ``// writing 2 separately``    ``Console.Write(``"2 "``);` `    ``// Printing other primes``    ``for` `(``int` `i = 3; i <= n; i += 2)``        ``if` `(ifnotPrime(prime, i) == 0)``            ``Console.Write(i + ``" "``);``}` `// Driver Code``static` `void` `Main()``{``    ``int` `n = 30;``    ``bitWiseSieve(n);``}``}` `// This code is contributed by mits`

## PHP

 `> 1) & 31)));``}` `// Marks x composite in prime[]``function` `makeComposite(``\$x``)``{``    ``global` `\$prime``;``    ` `    ``// Set a bit corresponding to``    ``// given element. Using prime[x/64],``    ``// we find the slot in prime``    ``// array. To find the bit number,``    ``// we divide x by 2 and take its``    ``// mod with 32.``    ``\$prime``[(int)(``\$x` `/ 64)] |=``                ``(1 << ((``\$x` `>> 1) & 31));``}` `// Prints all prime``// numbers smaller than n.``function` `bitWiseSieve(``\$n``)``{``    ``global` `\$prime``;``    ` `    ``// Assuming that n takes``    ``// 32 bits, we reduce``    ``// size to n/64 from n/2.``    ``// Initializing values to 0 .``    ``\$prime` `= ``array_fill``(0,``                   ``(int)``ceil``(``\$n` `/ 64), 0);``                   ` `    ``// 2 is the only even prime``    ``// so we can ignore that``    ``// loop starts from 3 as we``    ``// have used in sieve of``    ``// Eratosthenes .``    ``for` `(``\$i` `= 3; ``\$i` `* ``\$i` `<= ``\$n``; ``\$i` `+= 2)``    ``{` `        ``// If i is prime, mark``        ``// all its multiples as``        ``// composite``        ``if` `(!ifnotPrime(``\$i``))``            ``for` `(``\$j` `= ``\$i` `* ``\$i``,``                 ``\$k` `= ``\$i` `<< 1;``                 ``\$j` `< ``\$n``; ``\$j` `+= ``\$k``)``                ``makeComposite(``\$j``);``    ``}` `    ``// writing 2 separately``    ``echo` `"2 "``;` `    ``// Printing other primes``    ``for` `(``\$i` `= 3; ``\$i` `<= ``\$n``; ``\$i` `+= 2)``        ``if` `(!ifnotPrime(``\$i``))``            ``echo` `\$i``.``" "``;``}` `// Driver code``\$n` `= 30;``bitWiseSieve(``\$n``);` `// This code is contributed``// by mits.``?>`

## Javascript

 ``

Output:

`2 3 5 7 11 13 17 19 23 29`

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up