Here’s a functional implementation of the Sieve of Eratosthenes, as presented in Odersky’s “Functional Programming Principles in Scala” Coursera course : // Sieving integral numbers def sieve(s: Stream[Int]): Stream[Int] = { s.head #:: sieve(s.tail.filter(_ % s.head != 0)) } // All primes as a lazy sequence val primes = sieve(Stream.from(2)) // Dumping the first five … Read more
Here’s an algorithm that is built on mapping and reducing (folding). It expresses the sieve of Eratosthenes P = {3,5,7, …} \ U {{p2, p2+2p, p2+4p, …} | p in P} for the odd primes (i.e without the 2). The folding tree is indefinitely deepening to the right, like this: where each prime number … Read more
The Sieve of Eratosthenes in two lines. primes = set(range(2,1000000)) for n in [2]+range(3,1000000/2,2): primes -= set(range(2*n,1000000,n)) Edit: I’ve realized that the above is not a true Sieve of Eratosthenes because it filters on the set of odd numbers rather than the set of primes, making it unnecessarily slow. I’ve fixed that in the following … Read more
The odds, i.e. 2-coprimes, are generated by “rolling the wheel” [2], i.e. by repeated additions of 2, starting from the initial value of 3 (similarly from 5, 7, 9, …), n=3; n+=2; n+=2; n+=2; … # wheel = [2] 3 5 7 9 The 2-3-coprimes are generated by repeated additions of 2, then 4, and … Read more
There are a couple of small optimizations for your version. By reversing the roles of True and False, you can change “if flags[i] is False:” to “if flags[i]:“. And the starting value for the second range statement can be i*i instead of i*3. Your original version takes 0.166 seconds on my system. With those changes, … Read more
Sure. Read about the Sieve of Eratosthenes. Instead of checking for primality, you generate prime numbers.
Removing a number and reinserting all its multiples (by the primes in the set) into a priority queue is wrong (in the sense of the question) – i.e. it produces correct sequence but inefficiently so. It is inefficient in two ways – first, it overproduces the sequence; second, each PriorityQueue operation incurs extra cost (the … Read more
Although you have gathered from your reading that a Page Segmented Sieve of Eratosthenes is a fast way of finding the primes over a large range, your question code (even when corrected) does not implement a Page Segmented SoE, test the code over a large range, nor is it particularly fast as SoE implementations go. … Read more
One good method is the Miller-Rabin test. It should be noted however, that this is only a probabilistic test.
You are making the Sieve of Eratosthenes much slower by making use of array manipulation functions such as Array#indexOf and Array#splice which runs in linear time. When you can have O(1) for both operations involved. Below is the Sieve of Eratosthenes following conventional programming practices: var eratosthenes = function(n) { // Eratosthenes algorithm to find … Read more