primes

I need to print all the prime numbers less than a given number n. I can use sieve of Eratothenes but the running time of that algorithm IS NOT O(n). Is there any O(n) time solution for this problem? I don't think you'll find an algorithm for checking an arbitrary number for primality with an O(n) time complexity. I'm pretty certain the NSA (and any other organisations that deal with crypto issues) wouldn't be very happy with that :-) The only way you'll get an O(n) or better way is to pre-calculate (for example) the first fifty million primes (or use someone else's already-precalculated list )

I had a go at a project euler coding challenge below, the answer given by the code is correct but I do not understand why its taking nearly a minute to run. It was finishing with similar times prior to using a sieve. Others users are reporting times as low as milliseconds. I assume I am making a basic error somewhere... // The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17. // Find the sum of all the primes below two million. public static long Ex010() { var sum = 0L; var sieve = new bool[2000000]; var primes = new List<int>(10000); for (int i = 2; i < sieve.Length; i++) { if (sieve[i-1])

I've all prime numbers that can be stored in 32bit unsigned int and I want to use them to generate some 64bit prime numbers . using trial division is too slow even with optimizations in logic and compilation. I'm trying to modify Sieve of Eratosthenes to work with the predefined list, as follow: in array A from 2 to 4294967291 in array B from 2^32 to X inc by 1 find C which is first multiple of current prime. from C mark and jump by current prime till X. go to 1. The problem is step 3 which use modulus to find the prime multiple, such operation is the reason i didn't use trail division. Is

Disclaimer: I'm working on Euler Problem 9. I'm adding up some pretty large numbers, all the primes from 1 to 2 000 000. Summing those primes takes forever. I'm using the haskell built in function 'sum'. as in: sum listOfPrimes Are there any other faster options? --My prime generator was the slow link in my code. It sounds like your problem is not summing the numbers, but generating them. What is your implementation of listOfPrimes? This paper may be of interest: http://lambda-the-ultimate.org/node/3127 I'm hoping you are using ghc -O2 and not ghci, right? Your problem will be in the

i came across this following question on a programming website : Peter wants to generate some prime numbers for his cryptosystem. Help him! Your task is to generate all prime numbers between two given numbers! Input The input begins with the number t of test cases in a single line (t<=10). In each of the next t lines there are two numbers m and n (1 <= m <= n <= 1000000000, n-m<=100000) separated by a space. I came up with the following solution : import java.util.*; public class PRIME1 { static int numCases; static int left, right; static boolean[] initSieve = new boolean[32000]; static

So I was working on a way to lazily generate primes, and I came up with these three definitions, which all work in an equivalent way - just checking whether each new integer has a factor among all the preceding primes: primes1 :: [Integer] primes1 = mkPrimes id [2..] where mkPrimes f (x:xs) = if f (const True) x then let g h y = y `mod` x > 0 && h y in x : mkPrimes (f . g) xs else mkPrimes f xs primes2 :: [Integer] primes2 = mkPrimes id (const True) [2..] where mkPrimes f f_ (x:xs) = if f_ x then let g h y = y `mod` x > 0 && h y in x : mkPrimes (f . g) ( f $ g $ const True) xs else mkPrimes f