2009-10-19 13 views
7

Aşağıdaki Python kodunun Clojure eşdeğeri (tam algoritma için) nedir?Clojure asal sayıları

from itertools import count 
from math import sqrt 

def prime_gen(): 
    primes = [] 
    for n in count(2): 
     if all(n%p for p in primes if p <= sqrt(n)): 
      primes.append(n) 
      yield n 
+0

Bilginize Python kesin algoritma zayıftır çok daha hızlıdır. Alex Martelli'nin verimli sonsuz prime jeneratörü için bak. –

+0

http://stackoverflow.com/questions/2211990/how-to-implement-an-efficient-infinite-generator-of-prime-numbers-in-python –

cevap

10

bunu yapabilir gibi bu Pythonish gibidir:

(def prime-gen 
    (let [primes (atom [])] 
     (for [n (iterate inc 2) 
      :when (not-any? #(zero? (rem n %)) 
          (filter #(<= % (Math/sqrt n)) 
            @primes))] 
     (do (swap! primes conj n) 
      n)))) 

(take 10 prime-gen) ; => (2 3 5 7 11 13 17 19 23 29) 

Clojure tamsayı 0 boolean yanlış olduğu dikkate almaz. Python kodunuzun bundan yararlandığını anlamak birkaç dakika sürdü. Clojure'da diğer önemli sayı algoritmalarıdır. Ayrıca clojure.contrib.lazy-seqs numaralı telefon numaralı bir asal sayı uygulaması var.

+0

Pitonish olması gerekmez :) Varsa Aynı algoritma için daha idiomatik bir clojure çözümü, lütfen de gönderin. – Roskoto

+2

Bağlantıyı takip etmelisiniz. Orada birçok örnek ve cevap var. Ayrıca http://clj-me.cgrand.net/2009/07/30/everybody-loves-the-sieve-of-eratosthenes/#comments. – dnolen

+1

Pekala, bu bir "atom" u mutasyona uğratmaktan başka hiçbir şeyden bağımsız değil. Yine de bir 'atom' kullanmaktan kaçınmak için bazı çarpıtmalar alırdı. Bazı algoritmalar, yan etkiler ve işlevsel olmayan bir programlama stili (özellikle, yerinde sıralama, karıştırma, belirli matematiksel işlevler vb.) Gerektirir ve bu durumlarda değişebilir veri yapılarını kullanmaya geçişte sorun yoktur. Bu yüzden Clojure onları kullanılabilir hale getiriyor. Bu tür şeyler için bile aşağı inip yerli Java veri yapılarını kullanabilirsiniz. –

0

Bu sürüm @Brian Carper en

(def prime-gen 
    (let [primes (atom [2N])] 
    (iterate 
     #(let [ps @primes] 
     (loop [n (inc %)] 
      (if (loop [i 0] 
       (let [p (nth ps i)] 
        (cond 
        (< n (* p p)) true 
        (zero? (mod n p)) false 
        :else (recur (inc i))))) 
      (do (swap! primes conj n) n) 
      (recur (inc n))))) 
     (first @primes))))