sieve

The standard Sieve of Eratosthenes crosses out most composites multiple times; in fact the only ones that do not get marked more than once are those that are the product of exactly two primes. Naturally, the overdraw increases as the sieve gets bigger. For an odd sieve (i.e. without the evens) the overdraw hits 100% for n = 3,509,227, with 1,503,868 composites and 1,503,868 crossings-out of already crossed-out numbers. For n = 2^32 the overdraw rises to 134.25% (overdraw 2,610,022,328 vs. pop count 1,944,203,427 = (2^32 / 2) - 203,280,221). The Sieve of Sundaram - with another explanation at

When following the procedure on wikipedia for wheel factorization , I seem to have stumbled into a problem where the prime number 331 is treated as a composite number if I try to build a 2-3-5-7 wheel. With 2-3-5-7 wheel, 2*3*5*7=210. So I setup a circle with 210 slots and go through steps 1-7 without any issues. Then I get to step 8 and strike off the spokes of all multiples of prime numbers, I eventually strike off the spoke rooted at 121, which is a multiple of 11, which is a prime. For the spoke rooted at 121, 121 + 210 = 331. Unfortunately, 331 is a prime number. Is the procedure on

We know that all primes above 3 can be generated using: 6 * k + 1 6 * k - 1 However we all numbers generated from the above formulas are not prime. For Example: 6 * 6 - 1 = 35 which is clearly divisible by 5. To Eliminate such conditions, I used a Sieve Method and removing the numbers which are factors of the numbers generated from the above formula. Using the facts: A number is said to be prime if it has no prime factors. As we can generate all the prime numbers using the above formulas. If we can remove all the multiples of the above numbers we are left with only prime numbers. To generate

So, we can count divisors of each number from 1 to N in O(NlogN) algorithm with sieve: int n; cin >> n; for (int i = 1; i <= n; i++) { for (int j = i; j <= n; j += i) { cnt[j]++; //// here cnt[x] means count of divisors of x } } Is there way to reduce it to O(N)? Thanks in advance. Here is a simple optimization on @גלעד ברקן's solution. Rather than use sets, use arrays. This is about 10x as fast as the set version. n = 100 answer = [None for i in range(0, n+1)] answer[1] = 1 small_factors = [1] p = 1 while (p < n): p = p + 1 if answer[p] is None: print("\n\nPrime: " + str(p)) limit = n / p new