It is a known fact that all primes > 5 are of the form `6*k+1` and `6*k+5` (i.e. their remainder after dividing by 6 is 1 or 5). Justifying this fact is trivial: given any other remainder, the number can be factored as follows:

``````
6*k+2 = 2*(3*k+1)
6*k+3 = 3*(2*k+1)
6*k+4 = 2*(3*k+2)
```
```
so it cannot possibly be prime. Sieve of Eratosthenes is an ancient way to generate primes. Its naive implementation uses one bit per integer to encode whether it is prime or not. Thus, storage space required to find all primes up to n equals `floor(n/8)+1` bytes. Using the above observation, the storage requirements can be cut down by a factor of 3 as shown below.

The first prime after 5 is 7. Consider the following sequence of numbers, all of which are 1 or 5 modulo 6: 7, 11, 13, 17, 19, 23, 25, 29, 31, 35, 37, 41, 43, 47, 49, 53, 55,... Each of these numbers corresponds to one bit in the sieve. Note that the largest among first 8 numbers (encoded in the 1st byte of the sieve) is 29. The naive implementation can encode only numbers 1-8 in the 1st byte.

The sieve is organized as a bit-vector encoding only numbers which 1 or 5 modulo 6. The first task is to map a number `n` to its bit index in the bit vector. This is accomplished by this formula: `b = floor(n/3)-1`. Thus, 7 is mapped to 1, 11 to 2, etc. Once `b` is found, it is trivial to access the `b`'th bit in the bit-vector.

To check whether an arbitrary n is prime, proceed as follows

``````int is_prime(int n)
{
int r;

if(n < 7)
return B[n];
r = n % 6;
if((r != 1) && (r != 5))
return 0;
return B[n/3-1];
}
``````

This is pseudo-code where `B` is a bit-vector indexed by bit. `B[n]` is 1 if `n` is prime. The slowest operations in this process are division and modulus operations. They can be suitably optimized (e.g. substituted with multiplication). Optimizations will be the topic of a possible future article.

This article has shown the basic idea of compressing space needed for the sieve of Eartosthenes. Note that there are more advanced sieves (also more complicated to code), such as Sieve of Atkin.