Sieve of Eratosthenes in 0(n) time complexity
Last Updated :
14 Jul, 2022
The classical Sieve of Eratosthenes algorithm takes O(N log (log N)) time to find all prime numbers less than N. In this article, a modified Sieve is discussed that works in O(N) time.
Example :
Given a number N, print all prime
numbers smaller than N
Input : int N = 15
Output : 2 3 5 7 11 13
Input : int N = 20
Output : 2 3 5 7 11 13 17 19
Manipulated Sieve of Eratosthenes algorithm works as follows:
For every number i where i varies from 2 to N-1:
Check if the number is prime. If the number
is prime, store it in prime array.
For every prime numbers j less than or equal to the smallest
prime factor p of i:
Mark all numbers i*p as non_prime.
Mark smallest prime factor of i*p as j
Below is the implementation of the above idea.
C++
// C++ program to generate all prime numbers
// less than N in O(N)
#include<bits/stdc++.h>
using namespace std;
const long long MAX_SIZE = 1000001;
// isPrime[] : isPrime[i] is true if number is prime
// prime[] : stores all prime number less than N
// SPF[] that store smallest prime factor of number
// [for Exp : smallest prime factor of '8' and '16'
// is '2' so we put SPF[8] = 2 , SPF[16] = 2 ]
vector<long long >isprime(MAX_SIZE , true);
vector<long long >prime;
vector<long long >SPF(MAX_SIZE);
// function generate all prime number less than N in O(n)
void manipulated_seive(int N)
{
// 0 and 1 are not prime
isprime[0] = isprime[1] = false ;
// Fill rest of the entries
for (long long int i=2; i<N ; i++)
{
// If isPrime[i] == True then i is
// prime number
if (isprime[i])
{
// put i into prime[] vector
prime.push_back(i);
// A prime number is its own smallest
// prime factor
SPF[i] = i;
}
// Remove all multiples of i*prime[j] which are
// not prime by making isPrime[i*prime[j]] = false
// and put smallest prime factor of i*Prime[j] as prime[j]
// [ for exp :let i = 5 , j = 0 , prime[j] = 2 [ i*prime[j] = 10 ]
// so smallest prime factor of '10' is '2' that is prime[j] ]
// this loop run only one time for number which are not prime
for (long long int j=0;
j < (int)prime.size() &&
i*prime[j] < N && prime[j] <= SPF[i];
j++)
{
isprime[i*prime[j]]=false;
// put smallest prime factor of i*prime[j]
SPF[i*prime[j]] = prime[j] ;
}
}
}
// driver program to test above function
int main()
{
int N = 13 ; // Must be less than MAX_SIZE
manipulated_seive(N);
// print all prime number less than N
for (int i=0; i<prime.size() && prime[i] <= N ; i++)
cout << prime[i] << " ";
return 0;
}
// Java program to generate all prime numbers
// less than N in O(N)
import java.util.Vector;
class Test
{
static final int MAX_SIZE = 1000001;
// isPrime[] : isPrime[i] is true if number is prime
// prime[] : stores all prime number less than N
// SPF[] that store smallest prime factor of number
// [for Exp : smallest prime factor of '8' and '16'
// is '2' so we put SPF[8] = 2 , SPF[16] = 2 ]
static Vector<Boolean>isprime = new Vector<>(MAX_SIZE);
static Vector<Integer>prime = new Vector<>();
static Vector<Integer>SPF = new Vector<>(MAX_SIZE);
// method generate all prime number less than N in O(n)
static void manipulated_seive(int N)
{
// 0 and 1 are not prime
isprime.set(0, false);
isprime.set(1, false);
// Fill rest of the entries
for (int i=2; i<N ; i++)
{
// If isPrime[i] == True then i is
// prime number
if (isprime.get(i))
{
// put i into prime[] vector
prime.add(i);
// A prime number is its own smallest
// prime factor
SPF.set(i,i);
}
// Remove all multiples of i*prime[j] which are
// not prime by making isPrime[i*prime[j]] = false
// and put smallest prime factor of i*Prime[j] as prime[j]
// [for exp :let i = 5, j = 0, prime[j] = 2 [ i*prime[j] = 10]
// so smallest prime factor of '10' is '2' that is prime[j] ]
// this loop run only one time for number which are not prime
for (int j=0;
j < prime.size() &&
i*prime.get(j) < N && prime.get(j) <= SPF.get(i);
j++)
{
isprime.set(i*prime.get(j),false);
// put smallest prime factor of i*prime[j]
SPF.set(i*prime.get(j),prime.get(j)) ;
}
}
}
// Driver method
public static void main(String args[])
{
int N = 13 ; // Must be less than MAX_SIZE
// initializing isprime and spf
for (int i = 0; i < MAX_SIZE; i++){
isprime.add(true);
SPF.add(2);
}
manipulated_seive(N);
// print all prime number less than N
for (int i=0; i<prime.size() && prime.get(i) <= N ; i++)
System.out.print(prime.get(i) + " ");
}
}
# Python3 program to generate all
# prime numbers less than N in O(N)
MAX_SIZE = 1000001
# isPrime[] : isPrime[i] is true if
# number is prime
# prime[] : stores all prime number
# less than N
# SPF[] that store smallest prime
# factor of number [for ex : smallest
# prime factor of '8' and '16'
# is '2' so we put SPF[8] = 2 ,
# SPF[16] = 2 ]
isprime = [True] * MAX_SIZE
prime = []
SPF = [None] * (MAX_SIZE)
# function generate all prime number
# less than N in O(n)
def manipulated_seive(N):
# 0 and 1 are not prime
isprime[0] = isprime[1] = False
# Fill rest of the entries
for i in range(2, N):
# If isPrime[i] == True then i is
# prime number
if isprime[i] == True:
# put i into prime[] vector
prime.append(i)
# A prime number is its own smallest
# prime factor
SPF[i] = i
# Remove all multiples of i*prime[j]
# which are not prime by making is
# Prime[i * prime[j]] = false and put
# smallest prime factor of i*Prime[j]
# as prime[j] [ for exp :let i = 5 , j = 0 ,
# prime[j] = 2 [ i*prime[j] = 10 ]
# so smallest prime factor of '10' is '2'
# that is prime[j] ] this loop run only one
# time for number which are not prime
j = 0
while (j < len(prime) and
i * prime[j] < N and
prime[j] <= SPF[i]):
isprime[i * prime[j]] = False
# put smallest prime factor of i*prime[j]
SPF[i * prime[j]] = prime[j]
j += 1
# Driver Code
if __name__ == "__main__":
N = 13 # Must be less than MAX_SIZE
manipulated_seive(N)
# print all prime number less than N
i = 0
while i < len(prime) and prime[i] <= N:
print(prime[i], end = " ")
i += 1
# This code is contributed by Rituraj Jain
// C# program to generate all prime numbers
// less than N in O(N)
using System;
using System.Collections.Generic;
class Test {
static int MAX_SIZE = 1000001;
// isPrime[] : isPrime[i] is true if number is prime
// prime[] : stores all prime number less than N
// SPF[] that store smallest prime factor of number
// [for Exp : smallest prime factor of '8' and '16'
// is '2' so we put SPF[8] = 2 , SPF[16] = 2 ]
static List<bool> isprime = new List<bool>(MAX_SIZE);
static List<int> prime = new List<int>();
static List<int> SPF = new List<int>(MAX_SIZE);
// method generate all prime number less than N in O(n)
static void manipulated_seive(int N)
{
// 0 and 1 are not prime
isprime[0] = false;
isprime[1] = false;
// Fill rest of the entries
for (int i = 2; i < N; i++)
{
// If isPrime[i] == True then i is
// prime number
if (isprime[i])
{
// put i into prime[] vector
prime.Add(i);
// A prime number is its own smallest
// prime factor
SPF[i] = i;
}
// Remove all multiples of i*prime[j] which are
// not prime by making isPrime[i*prime[j]] =
// false and put smallest prime factor of
// i*Prime[j] as prime[j] [for exp :let i = 5,
// j = 0, prime[j] = 2 [ i*prime[j] = 10] so
// smallest prime factor of '10' is '2' that is
// prime[j] ] this loop run only one time for
// number which are not prime
for (int j = 0;
j < prime.Count && i * prime[j] < N
&& prime[j] <= SPF[i];
j++) {
isprime[i * prime[j]] = false;
// put smallest prime factor of i*prime[j]
SPF[i * prime[j]] = prime[j];
}
}
}
// Driver method
public static void Main(string[] args)
{
int N = 13; // Must be less than MAX_SIZE
// initializing isprime and spf
for (int i = 0; i < MAX_SIZE; i++) {
isprime.Add(true);
SPF.Add(2);
}
manipulated_seive(N);
// print all prime number less than N
for (int i = 0; i < prime.Count && prime[i] <= N;
i++)
Console.Write(prime[i] + " ");
}
}
// This code is contributed by phasing17
<?php
// PHP program to generate all
// prime numbers less than N in O(N)
$MAX_SIZE = 10001;
// isPrime[] : isPrime[i] is true if
// number is prime
// prime[] : stores all prime number
// less than N
// SPF[] that store smallest prime
// factor of number [for ex : smallest
// prime factor of '8' and '16'
// is '2' so we put SPF[8] = 2 ,
// SPF[16] = 2 ]
$isprime = array_fill(0, $MAX_SIZE, true);
$prime = array();
$SPF = array_fill(0, $MAX_SIZE, 0);
// function generate all prime number
// less than N in O(n)
function manipulated_seive($N)
{
global $isprime, $MAX_SIZE,
$SPF, $prime;
// 0 and 1 are not prime
$isprime[0] = $isprime[1] = false;
// Fill rest of the entries
for ($i = 2; $i < $N; $i++)
{
// If isPrime[i] == True then
// i is prime number
if ($isprime[$i])
{
// put i into prime[] vector
array_push($prime, $i);
// A prime number is its own
// smallest prime factor
$SPF[$i] = $i;
}
// Remove all multiples of i*prime[j]
// which are not prime by making is
// Prime[i * prime[j]] = false and put
// smallest prime factor of i*Prime[j]
// as prime[j] [ for exp :let i = 5 , j = 0 ,
// prime[j] = 2 [ i*prime[j] = 10 ]
// so smallest prime factor of '10' is '2'
// that is prime[j] ] this loop run only
// one time for number which are not prime
$j = 0;
while ($j < count($prime) &&
$i * $prime[$j] < $N &&
$prime[$j] <= $SPF[$i])
{
$isprime[$i * $prime[$j]] = false;
// put smallest prime factor of i*prime[j]
$SPF[$i * $prime[$j]] = $prime[$j];
$j += 1;
}
}
}
// Driver Code
$N = 13; // Must be less than MAX_SIZE
manipulated_seive($N);
// print all prime number less than N
$i = 0;
while ($i < count($prime) &&
$prime[$i] <= $N)
{
print($prime[$i] . " ");
$i += 1;
}
// This code is contributed by mits
?>
<script>
// Javascript program to generate all
// prime numbers smaller than N in O(N)
const MAX_SIZE = 1000001;
// isPrime[] : isPrime[i] is true if the number is prime
// prime[] : stores all prime numbers less than N
// SPF[] that store smallest prime factor of number
// [for Exp : smallest prime factor of '8' and '16'
// is '2' so we put SPF[8] = 2 , SPF[16] = 2 ]
var isPrime = Array.from({ length: MAX_SIZE }, (_, i) => true);
var prime = [];
var SPF = Array.from({ length: MAX_SIZE });
// function that generates all prime number
// less than N in O(N)
function manipulated_sieve(N) {
// 0 and 1 are not prime
isPrime[0] = isPrime[1] = true;
// Fill rest of the entries
for (let i = 2; i < N; i++)
{
// If isPrime[i] === true,
// then i is a prime number
if (isPrime[i])
{
// put i into prime[] array
prime.push(i);
// A prime number is its own smallest
// prime factor
SPF[i] = i;
}
// Remove all multiples of i*prime[j] which are
// not prime by making isPrime[i*prime[j]] = false
// and put smallest prime factor of i*Prime[j] as prime[j]
// [ for exp :let i = 5 , j = 0 , prime[j] = 2 [ i*prime[j] = 10 ]
// so smallest prime factor of '10' is '2' that is prime[j] ]
// this loop run only one time for number which are not prime
for (
let j = 0;
j < prime.length && i * prime[j] < N && prime[j] <= SPF[i];
j++
) {
isPrime[i * prime[j]] = false;
// put smallest prime factor of i*prime[j]
SPF[i * prime[j]] = prime[j];
}
}
}
// Driver Code
var N = 13; // Must be less than MAX_SIZE
manipulated_sieve(N);
// print all prime numbers less than N
for (let i = 0; i < prime.length && prime[i] <= N; i++) {
document.write(prime[i] + " ");
}
</script>
Output :
2 3 5 7 11
Auxiliary Space: O(1)
Illustration:
isPrime[0] = isPrime[1] = 0
After i = 2 iteration :
isPrime[] [F, F, T, T, F, T, T, T]
SPF[] [0, 0, 2, 0, 2, 0, 0, 0]
index 0 1 2 3 4 5 6 7
After i = 3 iteration :
isPrime[] [F, F, T, T, F, T, F, T, T, F ]
SPF[] [0, 0, 2, 3, 2, 0, 2, 0, 0, 3 ]
index 0 1 2 3 4 5 6 7 8 9
After i = 4 iteration :
isPrime[] [F, F, T, T, F, T, F, T, F, F]
SPF[] [0, 0, 2, 3, 2, 0, 2, 0, 2, 3]
index 0 1 2 3 4 5 6 7 8 9
Similar Reads
Check for Prime Number
In this problem, you are given a number n and you have to check whether it is a Prime number or not.Input: n = 10Output: falseExplanation: 10 is divisible by 2 and 5 Input: n = 11Output: trueExplanation: 11 is divisible by 1 and 11 onlyInput: n = 1Output: falseExplanation: 1 is neither composite nor
11 min read
Primality Test Algorithms
Introduction to Primality Test and School Method
Given a positive integer, check if the number is prime or not. A prime is a natural number greater than 1 that has no positive divisors other than 1 and itself. Examples of the first few prime numbers are {2, 3, 5, ...}Examples : Input: n = 11Output: trueInput: n = 15Output: falseInput: n = 1Output:
10 min read
Fermat Method of Primality Test
Given a number n, check if it is prime or not. We have introduced and discussed the School method for primality testing in Set 1.Introduction to Primality Test and School MethodIn this post, Fermat's method is discussed. This method is a probabilistic method and is based on Fermat's Little Theorem.
10 min read
Primality Test | Set 3 (Miller–Rabin)
Given a number n, check if it is prime or not. We have introduced and discussed School and Fermat methods for primality testing.Primality Test | Set 1 (Introduction and School Method) Primality Test | Set 2 (Fermat Method)In this post, the Miller-Rabin method is discussed. This method is a probabili
15+ min read
Solovay-Strassen method of Primality Test
We have already been introduced to primality testing in the previous articles in this series. Introduction to Primality Test and School MethodFermat Method of Primality TestPrimality Test | Set 3 (Miller–Rabin)The Solovay–Strassen test is a probabilistic algorithm used to check if a number is prime
13 min read
Lucas Primality Test
A number p greater than one is prime if and only if the only divisors of p are 1 and p. First few prime numbers are 2, 3, 5, 7, 11, 13, ...The Lucas test is a primality test for a natural number n, it can test primality of any kind of number.It follows from Fermat’s Little Theorem: If p is prime and
12 min read
Sieve of Eratosthenes
Given a number n, print all primes smaller than or equal to n. It is also given that n is a small number. Examples:Input: n = 10Output: 2 3 5 7Explanation: The prime numbers up to 10 obtained by Sieve of Eratosthenes are 2 3 5 7 .Input: n = 20Output: 2 3 5 7 11 13 17 19Explanation: The prime numbers
6 min read
How is the time complexity of Sieve of Eratosthenes is n*log(log(n))?
Pre-requisite: Sieve of Eratosthenes What is Sieve of Eratosthenes algorithm? In order to analyze it, let's take a number n and the task is to print the prime numbers less than n. Therefore, by definition of Sieve of Eratosthenes, for every prime number, it has to check the multiples of the prime an
3 min read
Sieve of Eratosthenes in 0(n) time complexity
The classical Sieve of Eratosthenes algorithm takes O(N log (log N)) time to find all prime numbers less than N. In this article, a modified Sieve is discussed that works in O(N) time.Example : Given a number N, print all prime numbers smaller than N Input : int N = 15 Output : 2 3 5 7 11 13 Input :
12 min read
Programs and Problems based on Sieve of Eratosthenes
C++ Program for Sieve of Eratosthenes
Given a number n, print all primes smaller than or equal to n. It is also given that n is a small number. For example, if n is 10, the output should be "2, 3, 5, 7". If n is 20, the output should be "2, 3, 5, 7, 11, 13, 17, 19".CPP// C++ program to print all primes smaller than or equal to // n usin
2 min read
Java Program for Sieve of Eratosthenes
Given a number n, print all primes smaller than or equal to n. It is also given that n is a small number. For example, if n is 10, the output should be "2, 3, 5, 7". If n is 20, the output should be "2, 3, 5, 7, 11, 13, 17, 19". Java // Java program to print all primes smaller than or equal to // n
2 min read
Scala | Sieve of Eratosthenes
Eratosthenes of Cyrene was a Greek mathematician, who discovered an amazing algorithm to find prime numbers. This article performs this algorithm in Scala. Step 1 : Creating an Int Stream Scala 1== def numberStream(n: Int): Stream[Int] = Stream.from(n) println(numberStream(10)) Output of above step
4 min read
Check if a number is Primorial Prime or not
Given a positive number N, the task is to check if N is a primorial prime number or not. Print 'YES' if N is a primorial prime number otherwise print 'NO.Primorial Prime: In Mathematics, A Primorial prime is a prime number of the form pn# + 1 or pn# - 1 , where pn# is the primorial of pn i.e the pro
10 min read
Sum of all Primes in a given range using Sieve of Eratosthenes
Given a range [l, r], the task is to find the sum of all the prime numbers in the given range from l to r both inclusive.Examples: Input : l = 10, r = 20Output : 60Explanation: Prime numbers between [10, 20] are: 11, 13, 17, 19Therefore, sum = 11 + 13 + 17 + 19 = 60Input : l = 15, r = 25Output : 59E
1 min read
Prime Factorization using Sieve O(log n) for multiple queries
We can calculate the prime factorization of a number "n" in O(sqrt(n)) as discussed here. But O(sqrt n) method times out when we need to answer multiple queries regarding prime factorization.In this article, we study an efficient method to calculate the prime factorization using O(n) space and O(log
11 min read
Java Program to Implement Sieve of Eratosthenes to Generate Prime Numbers Between Given Range
A number which is divisible by 1 and itself or a number which has factors as 1 and the number itself is called a prime number. The sieve of Eratosthenes is one of the most efficient ways to find all primes smaller than n when n is smaller than 10 million or so. Example: Input : from = 1, to = 20 Out
3 min read
Segmented Sieve
Given a number n, print all primes smaller than n. Input: N = 10Output: 2, 3, 5, 7Explanation : The output “2, 3, 5, 7†for input N = 10 represents the list of the prime numbers less than or equal to 10. Input: N = 5Output: 2, 3, 5 Explanation : The output “2, 3, 5†for input N = 5 represents the li
15+ min read
Segmented Sieve (Print Primes in a Range)
Given a range [low, high], print all primes in this range? For example, if the given range is [10, 20], then output is 11, 13, 17, 19. A Naive approach is to run a loop from low to high and check each number for primeness. A Better Approach is to precalculate primes up to the maximum limit using Sie
15 min read
Longest sub-array of Prime Numbers using Segmented Sieve
Given an array arr[] of N integers, the task is to find the longest subarray where all numbers in that subarray are prime. Examples: Input: arr[] = {3, 5, 2, 66, 7, 11, 8} Output: 3 Explanation: Maximum contiguous prime number sequence is {2, 3, 5} Input: arr[] = {1, 2, 11, 32, 8, 9} Output: 2 Expla
13 min read
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 = 10Output: 2, 3, 5, 7Input: n = 20Output: 2, 3, 5, 7, 11, 13, 17, 19We have discussed Sieve of Eratosthenes algorithm for the above task. Below is Sieve of Sundaram algorithm.printPrimes(n)[Prints all prime numbers sma
10 min read