Prime sieves¹⁾ are common devices for generating prime numbers in a given range. These lists can be used for quick verification of relatively small prime numbers (typically no larger than 10⁸) when many such verifications may be necessary.

sieve.py

from math import *
 
def sieve(n):
    primes = [True] * (n+1)                             # true for each primes
    primes[0] = primes[1] = False
    for i in range(2, int(sqrt(n))+1):                  # filter out non-primes
        if primes[i]:
            for j in range(i**2, n+1, i):
                primes[j] = False
    return [i for i in range(len(primes)) if primes[i]] # generate primes from True values
 
primes = sieve(1000000)

sieve.cpp

#include <bitset>
#include <cmath>
#include <vector>
 
using namespace std;
 
const int MAX_PRIMES=100000000;
 
bitset<MAX_PRIMES+1> nums;        // true for each prime
vector<int> primes;               // list of primes
 
void sieve(int n) {
  nums.set();                     // set all values to true
  nums[0] = nums[1] = false;
  for(int i=2; i<=sqrt(n)+1; i++) // filter out non-primes
    if(nums[i])
      for(int j=i*i; j<n+2; j+=i)	
	nums[j] = false;
 
  for(int i=0; i<nums.size(); i++)
    if(nums[i] == true)	
      primes.push_back(i);
}  
 
int main() {
  sieve(MAX_PRIMES);
 
  return 0;
}

A C++ bitset²⁾ is used for additional time/space efficiency to store true/false values. A vector would also work, but at an increased cost of time and space.

Operation Sieve of Eratosthenes is quite simple. The sieve starts by assuming all numbers in a given range (2..n) are prime (True values in our list). Then for each number, i, from (2..sqrt(n)) we eliminate any multiples of i by setting them to False.³⁾ After completion, the True values indicate indices that are prime (the list of which is generated by the final list comprehension in the return statement).

The Sieve of Eratosthenes is not the fastest prime sieve available, but it is quick to code, easy to understand and modify, and sufficiently fast for some practical applications.

Time Complexity: O((n log n)(log log n))⁴⁾
Space Complexity: O(n)

This sieve should work reliably for primes up to 10⁶ (Python3) or 10⁷ (C++) in traditional contest settings.⁵⁾

Implementations are from the pseudocode provided in the Wikipedia article on the Sieve of Eratosthenes⁹⁾.