## The First N Primes

### October 14, 2011

Our solution pre-computes the first element of the sieve, thus avoiding a test for an empty priority queue at each step through the algorithm:

`(define (n-primes n)`

(let ((pq (pq-insert lt? (cons 9 6) pq-empty)))

(let loop1 ((i 5) (pq pq) (ps (list 3 2)) (k 2))

(cond ((= n k) (reverse ps))

((< i (car (pq-first pq)))

(let* ((c (* i i)) (s (+ i i))

(pq (pq-insert lt? (cons c s) pq)))

(loop1 (+ i 2) pq (cons i ps) (+ k 1))))

(else (let loop2 ((pq pq))

(if (< i (car (pq-first pq)))

(loop1 (+ i 2) pq ps k)

(let* ((c (car (pq-first pq)))

(s (cdr (pq-first pq)))

(pq (pq-rest lt? pq)))

(loop2 (pq-insert lt? (cons (+ c s) s) pq))))))))))

The priority queue is ordered by increasing *i*×*i*, and then by increasing *i*×2 in case of a tie:

`(define (lt? a b)`

(or (< (car a) (car b))

(and (= (car a) (car b))

(< (cdr a) (cdr b)))))

Here is a list of the first 168 primes:

`> (n-primes 168)`

(2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73

79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 157

163 167 173 179 181 191 193 197 199 211 223 227 229 233 239

241 251 257 263 269 271 277 281 283 293 307 311 313 317 331

337 347 349 353 359 367 373 379 383 389 397 401 409 419 421

431 433 439 443 449 457 461 463 467 479 487 491 499 503 509

521 523 541 547 557 563 569 571 577 587 593 599 601 607 613

617 619 631 641 643 647 653 659 661 673 677 683 691 701 709

719 727 733 739 743 751 757 761 769 773 787 797 809 811 821

823 827 829 839 853 857 859 863 877 881 883 887 907 911 919

929 937 941 947 953 967 971 977 983 991 997)

We used priority queues from a previous exercise. You can run the program at http://programmingpraxis.codepad.org/61r9U0eR.

Pages: 1 2

Python 3 version. Uses heapq from the standard library for the priority queue.

I began odd_number at 5 to eliminate a test for when ‘next_composite’ isn’t set yet

My C++ solution

http://ideone.com/CWsQx

http://ideone.com/B0Bpy

my solution again with an amendment to line 18

Factor version, uses Priority Queue library and lazy lists.

Test:

This method is better suited to Prolog than the standard sieve, due to the fact that arrays do not exist in that language, and generators are pretty much how things are done, so without further ado, in Prolog…