Your method of finding primes, by comparing every single element of the array with every possible factor is hideously inefficient. You can improve it immensely by doing a Sieve of Eratosthenes over the entire array at once. Besides doing far fewer comparisons, it also uses addition rather than division. Division is way slower.
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.
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
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
Reading that article I came up with an idea that doesn’t require a multimap. It handles colliding map keys by moving the colliding key forward by its prime value again and again until it reaches a key that isn’t in the map. Below primes is a map with keys of the next iterator value and … Read more
Edited: My answer to the question is: Yes, you can definitely use the Task Parallel Library (TPL) to find the primes to one billion faster. The given code(s) in the question is slow because it isn’t efficiently using memory or multiprocessing, and final output also isn’t efficient. So other than just multiprocessing, there are a … Read more
Normally, definition of primes stream in Richard Bird’s formulation of the sieve of Eratosthenes is self-referential: import Data.List.Ordered (minus, union, unionAll) ps = 2 : minus [3..] — `:` is “cons” (foldr (\p r -> p*p : union [p*p+p, p*p+2*p..] r) [] ps) The primes ps produced by this definition are used as the input … Read more
Your n/2 + n/3 + n/5 + … n/97 is not O(n), because the number of terms is not constant. [Edit after your edit: O(n2) is too loose an upper bound.] A loose upper-bound is n(1+1/2+1/3+1/4+1/5+1/6+…1/n) (sum of reciprocals of all numbers up to n), which is O(n log n): see Harmonic number. A more … Read more