İlk 10000 asal sayılar için en etkili şifresi?

oy
49

İlk 10000 asal sayıları yazdırmak istiyorum. Herkes bana bu en verimli kod verebilir misiniz? Açıklamalar:

  1. kodunuzu n> 10000 için verimsiz olup olmadığı önemli değildir.
  2. kod boyutu önemli değildir.
  3. Sadece sert herhangi bir şekilde değerlerini kod olamaz.
Oluştur 03/08/2008 saat 06:45
kaynak kullanıcı
Diğer dillerde...                            


28 cevaplar

oy
41

Atkin Elek muhtemelen daha üst sınır çalışma süresi, aradığınızı olduğunu O (N / log N log).

Yalnızca 6 katları daha 1 ve 1 daha az sayıda çalıştırırsanız 3'ün üstünde tüm asal sayılar uzakta altı sayısının katları itibaren 1 gibi, o da hızlı olabilir. Ekstremde için Kaynak

Cevap 03/08/2008 saat 07:03
kaynak kullanıcı

oy
35

Bir elek önerimiz ya Eratosthenes Elek veya Atkin Elek.

elek veya Erastotenes muhtemelen asal bir listesini bulma en sezgisel bir yöntemdir. Temel olarak:

  1. 2 ila istersen sınırı numaralarının listesini yere yazın, en 1000 diyelim.
  2. (Bu 2'dir ilk yineleme için) kapalı çizili olmayan ilk numarayı alın ve listeden bu sayının katlarını kapalı geçer.
  3. Listenin sonuna ulaşıncaya kadar 2. adımı tekrarlayın. kapalı çizili olmayan tüm sayılar asal bulunmaktadır.

Açıkçası orada bu algoritma çalışmaları daha hızlı hale getirmek için yapılabilir epeyce optimizasyonlar vardır, ancak bu temel fikirdir.

Atkin elek benzer bir yaklaşım kullanır, ancak ne yazık ki size açıklamak için bu konuda yeterli bilgimiz yok. Ama bağlantılı algoritma eski Pentium II-350 üzerinde 1000000000 kadar olan tüm asal anlamaya 8 saniye sürer biliyorum

Eratosthenes Kaynak Kodu Elek: http://web.archive.org/web/20140705111241/http://primes.utm.edu/links/programs/sieves/Eratosthenes/C_source_code/

Atkin Kaynak Kodu Elek: http://cr.yp.to/primegen.html

Cevap 06/08/2008 saat 00:49
kaynak kullanıcı

oy
17

Bu hardcoding kısıtlama karşı kesinlikle değil ama korkunç yakındır. Neden programlama yoluyla yerine, bu listeyi indirip çıktısını?

http://primes.utm.edu/lists/small/10000.txt

Cevap 31/08/2008 saat 23:20
kaynak kullanıcı

oy
11

GateKiller , nasıl bir ekleme hakkında breako kadar ifiçinde foreachdöngü? Yani hızlandırmak olacağını çok gibi 6 2 ile bölünebilir olup olmadığını 3. ve 5. kontrol gerekmez çünkü (ben :-) yeterince itibar olsaydı yine senin çözümü oy vereceğini ...)

ArrayList primeNumbers = new ArrayList();

for(int i = 2; primeNumbers.Count < 10000; i++) {
    bool divisible = false;

    foreach(int number in primeNumbers) {
        if(i % number == 0) {
            divisible = true;
            break;
        }
    }

    if(divisible == false) {
        primeNumbers.Add(i);
        Console.Write(i + " ");
    }
}
Cevap 27/08/2008 saat 21:26
kaynak kullanıcı

oy
9

Haskell, biz kelime için Eratosthenes eleğin matematiksel tanımını neredeyse kelime yazabilirsiniz, " asal 1'in üzerinde doğal sayılar kompozitler her Prime'ın katları numaralandırma tarafından bulunan herhangi kompozit sayılar, olmadan ":

primes = 2 : minus [3..] (foldr (\p r-> p*p : union [p*p+p, p*p+2*p..] r) 
                                [] primes)

primes !! 10000 neredeyse anlık olduğunu.

Referanslar:


Yukarıdaki kod kolayca sadece oran üzerinde çalışıyor içine tweaked primes = 2:3:minus [5,7..] (foldr (\p r -> p*p : union [p*p+2*p, p*p+4*p..] r) [] (tail primes)). Zaman karmaşıklığı çok (hemen hemen bir iyileştirilir günlük bir ağaç benzeri yapıda katlanarak optimum yukarıda faktör), ve alan karmaşıklığı olan büyük ölçüde geliştirilmiş tarafından çok aşamalı asal üretim içinde,

primes = 2 : _Y ( (3:) . sieve 5 . _U . map (\p-> [p*p, p*p+2*p..]) )
  where
    _Y g = g (_Y g)                        -- non-sharing fixpoint combinator
    _U ((x:xs):t) = x : (union xs . _U . pairs) t       -- ~= nub.sort.concat
    pairs    (xs:ys:t)  = union xs ys : pairs t
    sieve k s@(x:xs) | k < x      = k : sieve (k+2) s   -- ~= [k,k+2..]\\s,
                     | otherwise  =     sieve (k+2) xs  --   when s⊂[k,k+2..]

(Haskell'de parantezler gruplandırma için kullanılan bir işlev çağrısı, sadece yan yana değeriyle, (:)a, aleyhte listeleri için operatör ve (.)fonksiyonel bir bileşim operatörü: (f . g) x = (\y-> f (g y)) x = f (g x)).

Cevap 24/04/2012 saat 17:30
kaynak kullanıcı

oy
9

@Matt: log () (10000 log) ~ 2

(Eğer anılan) wikipedia makalesinden Atkin Elek :

Bu elek, N kullanarak kadar asal hesaplar O(N/log log N), N'nin ile işlemleri 1/2 + o (1) hafıza bitleri. Yani kullanan Eratosthenes elek biraz daha iyi olduğu O(N) (N operasyonları ve O 1/2 (/) log N log log N) bellek bitleri (AOL Atkin, DJ Bernstein, 2004) . Bu asimptotik hesaplama karmaşıklığı basit tekerlek çarpanlara olarak optimizasyonlar ve daha küçük bloklara hesaplama bölme içerir.

Boyunca asimptotik hesaplama karmaşıklığını göz önüne alındığında O(N)(Eratosthenes için) ve O(N/log(log(N)))(küçük için biz söyleyemeyiz (Atkin için) N=10_000) daha hızlı olacaktır eğer uygulanırsa hangi algoritması.

Achim Flammenkamp yazdığı Eratosthenes Sieve :

Atıf:

@ num1

Mutlaka o> 10 ^ 10 için 10 ^ 9 hakkında daha geniş aralıklarla, için, Eratosthenes Elek indirgenemez ikili kuadratik formları kullanır Atkins ve Bernstein Elek tarafından geride edilir. W. Galway'in doktora onların arka plan bilgiler için kağıt yanı sıra paragraf 5'e bakınız tez.

Bu nedenle için 10_000Eratosthenes Elek Atkin kalburu sonra hızlı olabilir.

OP cevaplamak için kod edilir prime_sieve.c (bahsettiği num1)

Cevap 06/10/2008 saat 21:03
kaynak kullanıcı

oy
7

GMP kullanarak, tek aşağıdaki yazabilirsiniz:

#include <stdio.h>
#include <gmp.h>

int main() {
  mpz_t prime;
  mpz_init(prime);
  mpz_set_ui(prime, 1);
  int i;
  char* num = malloc(4000);
  for(i=0; i<10000; i++) {
    mpz_nextprime(prime, prime);
    printf("%s, ", mpz_get_str(NULL,10,prime));
  }
}

aşağıdaki gibi benim 2.33GHz Macbook Pro günü, o yürütür:

time ./a.out > /dev/null

real    0m0.033s
user    0m0.029s
sys    0m0.003s

Aynı dizüstü bilgisayarda 1.000.000 asal Hesaplama:

time ./a.out > /dev/null

real    0m14.824s
user    0m14.606s
sys     0m0.086s

GMP derece şey bu tür için optimize edilmiştir. Eğer gerçekten kendi yazarak algoritmaları anlamak istemiyorsanız, C altında libGMP kullanmak tavsiye olurdu

Cevap 29/08/2008 saat 08:06
kaynak kullanıcı

oy
4

Ben üzerinde bulunan kod adapte olması CodeProject şunları oluşturmak:

ArrayList primeNumbers = new ArrayList();

for(int i = 2; primeNumbers.Count < 10000; i++) {
    bool divisible = false;

    foreach(int number in primeNumbers) {
        if(i % number == 0) {
            divisible = true;
        }
    }

    if(divisible == false) {
        primeNumbers.Add(i);
        Console.Write(i + " ");
    }
}

Benim ASP.NET Server bu test rountine çalıştırmak için yaklaşık 1 dakika sürdü.

Cevap 05/08/2008 saat 20:55
kaynak kullanıcı

oy
4

Değil verimli hiç ama asal sayılar test etmek için normal bir ifade kullanabilirsiniz.

/^1?$|^(11+?)\1+$/

Oluşan bir dizi için, bu testler , k1” s, k, bir asal olmayan (yani, dizi bir mevcut olup olmadığını “ 1” ya da “herhangi bir sayıda 1bir şekilde ifade edilebilir s” n -ary ürün).

Cevap 03/08/2008 saat 19:52
kaynak kullanıcı

oy
3

Burada birkaç gün önce PowerShell yazdığı Eratosthenes bir Elek olduğunu. Bu döndürülmesi gereken asal sayıların sayısının belirlenmesi için bir parametre var.

#
# generate a list of primes up to a specific target using a sieve of eratosthenes
#
function getPrimes { #sieve of eratosthenes, http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
    param ($target,$count = 0)
    $sieveBound = [math]::ceiling(( $target - 1 ) / 2) #not storing evens so count is lower than $target
    $sieve = @($false) * $sieveBound
    $crossLimit = [math]::ceiling(( [math]::sqrt($target) - 1 ) / 2)
    for ($i = 1; $i -le $crossLimit; $i ++) {
        if ($sieve[$i] -eq $false) {
            $prime = 2 * $i + 1
            write-debug "Found: $prime"
            for ($x = 2 * $i * ( $i + 1 ); $x -lt $sieveBound; $x += 2 * $i + 1) {
                $sieve[$x] = $true
            }
        }
    }
    $primes = @(2)
    for ($i = 1; $i -le $sieveBound; $i ++) {
        if($count -gt 0 -and $primes.length -ge $count) {
            break;
        }
        if($sieve[$i] -eq $false) {
            $prime = 2 * $i + 1
            write-debug "Output: $prime"
            $primes += $prime
        }
    }
    return $primes
}
Cevap 07/09/2009 saat 19:52
kaynak kullanıcı

oy
3

Eratosthenes Elek o basitlik ve hız var yüzünden, gitmek yoludur. C My uygulaması

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h>

int main(void)
{
    unsigned int lim, i, j;

    printf("Find primes upto: ");
    scanf("%d", &lim);
    lim += 1;
    bool *primes = calloc(lim, sizeof(bool));

    unsigned int sqrtlim = sqrt(lim);
    for (i = 2; i <= sqrtlim; i++)
        if (!primes[i])
            for (j = i * i; j < lim; j += i)
                primes[j] = true;

    printf("\nListing prime numbers between 2 and %d:\n\n", lim - 1);
    for (i = 2; i < lim; i++)
        if (!primes[i])
            printf("%d\n", i);

    return 0;
}

CPU Süresi (tek çekirdekli kullanılarak, Pentium çift çekirdekli E2140 1.6 GHz'de) asal bulmak

~ Lim = 100,000,000 için 4s

Cevap 21/08/2008 saat 00:45
kaynak kullanıcı

oy
2

BenGoldberg bahsettiği deque elek algoritması çok zarif çünkü sadece, daha yakından bakmak hak değil, aynı zamanda bazen (tamamen akademik egzersizdir Atkin kalburu aksine) pratikte yararlı olabilir çünkü.

en düşük sayıyı aşmadığı bu asal kare yani - deque elek algoritması ardındaki temel fikir şu anda 'etkin' asal faktörlerin her biri için en az bir ayrı birden içerecek kadar sadece büyük küçük, sürgülü elek kullanmaktır Şu anda hareketli elek ile temsil etti. ÇDR'nin bir diğer farkı kompozitlerin değil, Boolean yarıklar içine deque elek depolar gerçek faktörlerdir.

Algoritma elek ölçüde CPU'nun L1 önbellek kapasitesini aşan başlayana kadar geniş bir aralık üzerinde oldukça daha yüksek bir performans gerektiği gibi elek penceresinin boyutunu uzanır. tam uyan son asal 25237523 algoritmanın makul çalışma aralığı için kaba bir rakam rakam verir (1,579,791st asal) vardır.

Algoritma, oldukça basit ve sağlam olup, bu Eratosthenes bir bölünmemiş Sieve çok daha geniş bir aralık üzerinde bile bir performansa sahiptir. İkincisi çok daha hızlı elek yani ihtimaller-sadece bayt büyüklüğünde bool değerlerden oluşan ile elek için 2 ^ 16 kadar, önbelleğine tamamen uyuyor olarak uzun. her zaman (en az C / C ++, Pascal veya Java / C # gibi derlenen dilde) engeline rağmen deque çok daha hızlı kalsa Sonra performansı, daha fazla düşer.

Bu dili bulmak çünkü Burada, C # deque elek algoritmasının bir işleme - pek çok kusurlarını rağmen - fevkalade hantal ve bilgiçlik taslayan C ++ daha prototipleme algoritmalar ve deney için çok daha pratik. (Sidenote: Ben özgür kullanıyorum LINQPad mümkün projeleri, makefiles, dizinleri durumlarda ne kurma ile tüm messiness olmadan, sağ dalış yapar ve bana bir piton isteminde olarak etkileşim aynı derecede verir).

C # açık deque türü yok ama düz List<int>algoritması göstermek için yeterince iyi çalışıyor.

Not: bu sadece n asal dışına sqrt (n) kapalı pop mantıklı değildir, çünkü bu sürüm, asal bir deque kullanmaz. 100 asal kaldırmak ve 9900 bırakmak ne iyi olurdu? en azından bu yolla tüm asal ileri işlemler için hazır, düzgün bir vektör toplanır.

static List<int> deque_sieve (int n = 10000)
{
    Trace.Assert(n >= 3);

    var primes = new List<int>()  {  2, 3  };
    var sieve = new List<int>()  {  0, 0, 0  };

    for (int sieve_base = 5, current_prime_index = 1, current_prime_squared = 9; ; )
    {
        int base_factor = sieve[0];

        if (base_factor != 0)
        {
            // the sieve base has a non-trivial factor - put that factor back into circulation
            mark_next_unmarked_multiple(sieve, base_factor);
        }
        else if (sieve_base < current_prime_squared)  // no non-trivial factor -> found a non-composite
        {
            primes.Add(sieve_base);

            if (primes.Count == n)
                return primes;
        }
        else // sieve_base == current_prime_squared
        {
            // bring the current prime into circulation by injecting it into the sieve ...
            mark_next_unmarked_multiple(sieve, primes[current_prime_index]);

            // ... and elect a new current prime
            current_prime_squared = square(primes[++current_prime_index]);
        }

        // slide the sieve one step forward
        sieve.RemoveAt(0);  sieve_base += 2;
    }
}

İşte iki yardımcı işlevler şunlardır:

static void mark_next_unmarked_multiple (List<int> sieve, int prime)
{
    int i = prime, e = sieve.Count;

    while (i < e && sieve[i] != 0)
        i += prime;

    for ( ; e <= i; ++e)  // no List<>.Resize()...
        sieve.Add(0);

    sieve[i] = prime;
}

static int square (int n)
{
    return n * n;
}

Muhtemelen algoritmayı anlamanın en kolay yolu asal onlar segmentinin ucuna çekim yaparken dinlensin diye bir taşma alanına eşliğinde 1'lik bir kesimi büyüklüğü ile Eratosthenes özel segmentli Elek olarak bunu hayal etmektir. Segmentin (aka tek hücreli Bunun dışında sieve[0]biz bunu almak zaman taşma alanının parçası iken bu ezildi çünkü) zaten elenmiş edilmiştir.

Ile temsil edilir sayı sieve[0]tutulur sieve_baserağmen, sieve_frontya window_baseda Ben'in koduna paralellikler veya pencereli / parçalı elekler uygulamalarını çizmek için izin iyi bir isim olurdu.

Eğer sieve[0]sıfır olmayan bir değeri içeren bu değer bir faktördür sieve_baseve böylece bileşik olarak kabul edilebilir. Hücre 0 o faktörün katları olduğundan sadece o faktörü artı 0'dır sonraki hop, hesaplamak kolaydır. Biz başka hiçbir faktör şu anda (gerekirse elek uzanan) park edildiğinde faktörün bir katı bulmak kadar o hücre başka faktör tarafından zaten işgal edilmeli o zaman sadece bu yüzden tekrar faktörünü ekleyin ve. Bu aynı zamanda normal bir segmentli elek gibi sonraki bir segmentinden çeşitli asal mevcut çalışma ofsetleri depolama gerek olmadığı anlamına gelir. Biz bir faktör bulmak zaman sieve[0], ofset çalışan bugünkü 0'dır.

Geçerli asal şu şekilde devreye giriyor. (A faktörü ile işaretlenmemiş çünkü, bir asal olarak tespit edildiğinde yani) bir asal sadece akışında kendi oluşum sonrası akım haline gelebilir ve bu kesin ana kadar geçerli kalır sieve[0]onun kare ulaşır. Bu asal Tüm alt katları sadece normal ÇDR'nin olduğu gibi nedeniyle küçük asal faaliyetlerine kapalı vurdu olmalıdır. Meydanın tek faktör asal kendisidir ve bu noktada dolaşımda henüz olmadığından Ama daha küçük asal hiçbiri, kare kapalı çakar. Bu durumda algoritma tarafından gerçekleştirilen eylemlerin açıklıyor sieve_base == current_prime_squared(ima sieve[0] == 0yoluyla).

Şimdi durum sieve[0] == 0 && sieve_base < current_prime_squaredkolaylıkla açıklanabilir: Ne demektir sieve_baseşimdiki asal daha küçük asal herhangi bir çoklu olamaz, aksi takdirde kompozit olarak işaretlenmiş olurdu. Değer olarak geçerli Prime'ın meydanına azdır çünkü, ya şimdiki asal daha yüksek çoklu olamaz. Dolayısıyla yeni bir asal olmalıdır.

Algoritma açıkça Eratosthenes Sieve esinlenerek, fakat aynı derecede belli çok farklıdır. Eratosthenes elek elementer işlemler basitliğinden üstün hızı elde: operasyon her adım için bir tek indeks ilavesi ve bir deposu, uzun menziller için yaptığı kadar.

İşte Normalde yani 2 ^ 16 kadar, ushort aralığında faktör asal eleme için kullanmak Eratosthenes basit, ayrılmamış Elek olduğunu. Bu yazı için ben yerine göre 2 ^ 16 ötesine çalışmaya modifiye ettik intiçinushort

static List<int> small_odd_primes_up_to (int n)
{
    var result = new List<int>();

    if (n < 3)
        return result;

    int sqrt_n_halved = (int)(Math.Sqrt(n) - 1) >> 1, max_bit = (n - 1) >> 1;
    var odd_composite = new bool[max_bit + 1];

    for (int i = 3 >> 1; i <= sqrt_n_halved; ++i)
        if (!odd_composite[i])
            for (int p = (i << 1) + 1, j = p * p >> 1; j <= max_bit; j += p)
                odd_composite[j] = true;

    result.Add(3);  // needs to be handled separately because of the mod 3 wheel

    // read out the sieved primes
    for (int i = 5 >> 1, d = 1; i <= max_bit; i += d, d ^= 3)
        if (!odd_composite[i])
            result.Add((i << 1) + 1);

    return result;
}

İlk 10000 elekten (hatta C # milisaniye kısmını) KiByte aşılacak 32 tipik bir L1 önbellek hazırlar ama fonksiyonu hala çok hızlı olduğu zaman.

Eğer deque elek için bu kodu karşılaştırırsanız o zaman deque eleğin işlemleri çok daha karmaşık olduğunu görmek kolaydır, ve her zaman üst üste geçitleri-off en kısa streç yapar çünkü etkili bir yükü itfa edemez (tam olarak bir tek geçiş-off, zaten kapalı çaprazlaşması katlarını atlama sonra).

Not: C # kodu kullanır intyerine uintyeni derleyiciler için altı kodunuzu oluştururken bir alışkanlığı var çünkü uintmuhtemelen kullanılan Yukarıdaki kod C ++ sürümünde ... imzalı tamsayı doğru insanları itmek amacıyla, unsignedboyunca doğal olarak; kriter C olmak zorunda ++ Ben bir sözde yeterli deque türüne dayanacaktır istedim çünkü ( std::deque<unsigned>; kullanmaktan hiçbir performans kazancı yoktu unsigned short). İşte benim Haswell laptop (VC ++ 2015 / x64) için sayılardır:

deque vs simple: 1.802 ms vs 0.182 ms
deque vs simple: 1.836 ms vs 0.170 ms 
deque vs simple: 1.729 ms vs 0.173 ms

Not: C # kez daha tam olarak C # ve gösterir için oldukça iyidir C ++ zamanlamaları, çift oldukça edilir List<int>bir deque olarak istismar bile hiç sarkma yok.

Basit elek kodu hala zaten normal çalışma aralığı (görevlisi önbellek dayak ile,% 50 oranında aştı L1 önbelleği boyutu) ötesine operasyon olsa bile, suyun dışında deque darbeler. Burada hakim kısmı elenmiş asal dışına okumaya ve bu önbellek sorundan çok etkilenmez. Her durumda işlev bir 3 seviyeli elek hiyerarşisinde faktörlerin yani seviye 0 faktörlerini eleme için tasarlanmış ve genellikle o sadece bir kaç yüz faktörleri veya binlerce sayısının düşük dönmek zorundadır. Bu nedenle sadeliği.

Performans parçalı bir elek kullanılarak elenmiş ve asal ayıklanması için kod optimize ederek bir büyüklük sırasına göre daha geliştirilebilir (mod 3 basamaklı ve açıldıktan iki kez ya da mod 15 ve bir kez unrolled) ve yine daha fazla performans dışında sıkışmış lebileceğini abartı bir mod 16 ya da mod 30 tekerleğini kullanarak kodu (tüm kalıntıları için, yani tam Açma elemanı). Bunun gibi bir şey cevabım açıklanmıştır asal konumlandırılmış asal sayı bulun benzer sorun tartışıldı Kod İnceleme, üzerine bitti. Ama bir kerelik görev için alt milisaniye kez iyileştirilmesi noktayı görmek zor ...

perspektif içine işleri biraz koymak için buraya 100,000,000 kadar eleme için C ++ zamanlamaları şunlardır:

deque vs simple: 1895.521 ms vs 432.763 ms
deque vs simple: 1847.594 ms vs 429.766 ms
deque vs simple: 1859.462 ms vs 430.625 ms

(Ben kod şu anda sadece C # meydan yapmak beri, hiçbir C ++ zamanlamaları mevcuttur) aksine, birkaç çan ve ıslık ile C # bölümlenmiş bir elek 95 ms aynı işi yapar.

her operasyon ağır bir maliyeti vardır ve tercüman havai mispredicted dallar ya karşı çok çevrim ops alt döngüsü op (vardiya, ekleme) vs tahmin (çarpma nedeniyle tüm farklılıkları cüceler nereye şeyler Python gibi tercüme edilmiş bir dilde kesinlikle farklı görünebilir ve belki de bölme). Yani Eratosthenes Sieve basitlik avantajı aşındırmaya bağlı olduğu ve bu deque çözüm biraz daha cazip hale olabilir.

Ayrıca, bu konudaki diğer kişilerce anlatıldığı zamanlamalar birçok muhtemelen hakimdir çıkış zamanında . Bu benim ana silahı böyle basit bir sınıftır tamamen farklı bir savaş var:

class CCWriter
{
    const int SPACE_RESERVE = 11;  // UInt31 + '\n'

    public static System.IO.Stream BaseStream;
    static byte[] m_buffer = new byte[1 << 16];  // need 55k..60k for a maximum-size range
    static int m_write_pos = 0;
    public static long BytesWritten = 0;         // for statistics

    internal static ushort[] m_double_digit_lookup = create_double_digit_lookup();

    internal static ushort[] create_double_digit_lookup ()
    {
        var lookup = new ushort[100];

        for (int lo = 0; lo < 10; ++lo)
            for (int hi = 0; hi < 10; ++hi)
                lookup[hi * 10 + lo] = (ushort)(0x3030 + (hi << 8) + lo);

        return lookup;
    }

    public static void Flush ()
    {
        if (BaseStream != null && m_write_pos > 0)
            BaseStream.Write(m_buffer, 0, m_write_pos);

        BytesWritten += m_write_pos;
        m_write_pos = 0;
    }

    public static void WriteLine ()
    {
        if (m_buffer.Length - m_write_pos < 1)
            Flush();

        m_buffer[m_write_pos++] = (byte)'\n';
    }

    public static void WriteLinesSorted (int[] values, int count)
    {
        int digits = 1, max_value = 9;

        for (int i = 0; i < count; ++i)
        {
            int x = values[i];

            if (m_buffer.Length - m_write_pos < SPACE_RESERVE)
                Flush();

            while (x > max_value)
                if (++digits < 10)
                    max_value = max_value * 10 + 9;
                else
                    max_value = int.MaxValue;               

            int n = x, p = m_write_pos + digits, e = p + 1;

            m_buffer[p] = (byte)'\n';

            while (n >= 10)
            {
                int q = n / 100, w = m_double_digit_lookup[n - q * 100];
                n = q;
                m_buffer[--p] = (byte)w;
                m_buffer[--p] = (byte)(w >> 8);
            }

            if (n != 0 || x == 0)
                m_buffer[--p] = (byte)((byte)'0' + n);

            m_write_pos = e;
        }
    }
}

Yani 10000 (sıralı) numaralarını yazmak için en az 1 ms alır. o yaygara ve sıfır yükü minimum, meydan gönderimleri kodlama içinde metinsel eklenmek üzere tasarlanmıştır çünkü statik sınıf var.

Genel olarak ben bulunmuştur çok , odaklanmış iş böyle devam sonra bir sonraki aralık elek, daha sonra tüm dizi dışarı patlama sonra, bir vektör / diziye Tüm asal ayıklamak, elek belirli bir aralık anlamına tüm gruplar üzerinde yapılan ve eğer hızlı yerine her şeyi birlikte karışarak arasında. Belirli görevlere odaklanmış ayrı işlevleri olması aynı zamanda daha kolay karıştırmak yapar ve maç, bu yeniden kullanımını sağlar ve bu gelişme / test kolaylaştırır.

Cevap 19/04/2016 saat 17:07
kaynak kullanıcı

oy
2

Python

import gmpy
p=1
for i in range(10000):
    p=gmpy.next_prime(p)
    print p 
Cevap 22/02/2010 saat 08:45
kaynak kullanıcı

oy
2

Elek yanlış cevap gibi görünüyor. Elek size asal verir kadar bir dizi N , değil ilk N asal. Run @Imran veya @ Andrew Szeto ve N'ye kadar asal olsun

Eğer sonuç kümesinin belirli bir boyuta çarpana kadar giderek daha büyük sayılar için elekler denemeye devam ve zaten elde sayıların bazı önbelleğe almayı kullandığında elek hala kullanılabilir olabilir, ama ben yine de @ Pat gibi bir çözüm daha hızlı olacağına inanıyorum .

Cevap 19/06/2009 saat 19:12
kaynak kullanıcı

oy
2

Uyarlanması ve itibaren aşağıdaki GateKiller , burada ben kullandım son hali bu.

    public IEnumerable<long> PrimeNumbers(long number)
    {
        List<long> primes = new List<long>();
        for (int i = 2; primes.Count < number; i++)
        {
            bool divisible = false;

            foreach (int num in primes)
            {
                if (i % num == 0)
                    divisible = true;

                if (num > Math.Sqrt(i))
                    break;
            }

            if (divisible == false)
                primes.Add(i);
        }
        return primes;
    }

Temelde aynı, ama ben "kırmak Sqrt" öneri ekledi ve bu benim için daha iyi uymasını sağlamak için etrafında değişkenlerden bazıları değiştirdik. (Ben Euler üzerinde çalışan ve 10001th asal gerekli)

Cevap 16/02/2009 saat 06:17
kaynak kullanıcı

oy
1

Eratosthenes Sieve kullanarak, hesaplama oldukça hızlı "bilinen çapında" asal sayılar algoritmaya karşılaştırmak edilir.

O wiki (var dan pseudocode kullanarak https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes ), C # üzerinde çözüm mümkün.

/// Get non-negative prime numbers until n using Sieve of Eratosthenes.
public int[] GetPrimes(int n) {
    if (n <= 1) {
        return new int[] { };
    }

    var mark = new bool[n];
    for(var i = 2; i < n; i++) {
        mark[i] = true;
    }

    for (var i = 2; i < Math.Sqrt(n); i++) {
        if (mark[i]) {
            for (var j = (i * i); j < n; j += i) {
                mark[j] = false;
            }
        }
    }

    var primes = new List<int>();
    for(var i = 3; i < n; i++) {
        if (mark[i]) {
            primes.Add(i);
        }
    }

    return primes.ToArray();
}

GetPrimes (100000000) 2s ve 330ms alır.

NOT : değişebilir Değer Donanım Özellikleri bağlıdır.

Cevap 12/05/2016 saat 03:40
kaynak kullanıcı

oy
1

Burada C ++ çözeltisi ÇDR'nin bir formu olduğu:

#include <iostream>
#include <deque>

typedef std::deque<int> mydeque;

void my_insert( mydeque & factors, int factor ) {
    int where = factor, count = factors.size();
    while( where < count && factors[where] ) where += factor;
    if( where >= count ) factors.resize( where + 1 );
    factors[ where ] = factor;
}

int main() {
    mydeque primes;
    mydeque factors;
    int a_prime = 3, a_square_prime = 9, maybe_prime = 3;
    int cnt = 2;
    factors.resize(3);
    std::cout << "2 3 ";

    while( cnt < 10000 ) {
        int factor = factors.front();
        maybe_prime += 2;
        if( factor ) {
            my_insert( factors, factor );
        } else if( maybe_prime < a_square_prime ) {
            std::cout << maybe_prime << " ";
            primes.push_back( maybe_prime );
            ++cnt;
        } else {
            my_insert( factors, a_prime );
            a_prime = primes.front();
            primes.pop_front();
            a_square_prime = a_prime * a_prime;
        }
        factors.pop_front();
    }

    std::cout << std::endl;
    return 0;
}

Elek bu sürümü süresiz asal sayıları hesaplamak unutmayın.

Ayrıca STL dikkat dequealır O(1)gerçekleştirmek için zaman push_back, pop_frontve indislemenin olsa rasgele erişim.

resizeIşlem alır O(n)burada, zaman nelemanlarının sayısı ilave edilmektedir. Bu işlevi nasıl kullandıklarını nedeniyle, bu küçük bir sabittir tedavi edebilir.

Vücut whiledöngü in my_insertyürütüldüğünde O(log log n), nerede kez ndeğişkeni eşittir maybe_prime. Durumu ifade Bunun nedeni whilekez her asal faktör için true değerlendirecek maybe_prime. "Bkz Bölen fonksiyonunu Wikipedia'da".

Sayısına bölümünden elde edilen çarpımı my_insertdenir, bu etmesi gerektiğini göstermektedir O(n log log n)listelemek için zaman nhangi, tahmin edileceği üzere, Eratosthenes Elek gerekiyordu Zaman karmaşıklığı olması ... asal.

Bu kod Bununla birlikte, olduğu verimli, öyle değil en verimli şiddetle gibi asal nesil için bir ihtisas kütüphanesi kullanarak öneririm ... primesieve . Herkes Stackoverflow yazdığınız istemesinden daha Herhangi gerçekten verimli, iyi optimize çözüm daha fazla kod alacaktır.

Cevap 16/04/2016 saat 18:33
kaynak kullanıcı

oy
1

Aşağıdaki Mathcad kodu 3 dakikadan daha kısa bir ilk milyon asal hesaplanmıştır.

kayan nokta kullanarak olurdu bu sayıların tümü için iki katına ve temelde yorumlanır olduğunu unutmayın. Ben sözdizimi açıktır umuyoruz.

Burada görüntü açıklama girin

Cevap 02/03/2014 saat 02:15
kaynak kullanıcı

oy
1

İşte 1 dk benim iş dizüstü 27 saniye içinde Tüm asal <10.000.000 bulur benim VB 2008 koddur. Hatta sayıları atlar ve sadece <deney sayısının sqrt olan asal arar. Sadece sentinal değere 0'dan asal sayıları bulmak için tasarlanmıştır.

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles 
Button1.Click

    Dim TestNum As Integer
    Dim X As Integer
    Dim Z As Integer
    Dim TM As Single
    Dim TS As Single
    Dim TMS As Single
    Dim UnPrime As Boolean
    Dim Sentinal As Integer
    Button1.Text = "Thinking"
    Button1.Refresh()
    Sentinal = Val(SentinalTxt.Text)
    UnPrime = True
    Primes(0) = 2
    Primes(1) = 3
    Z = 1
    TM = TimeOfDay.Minute
    TS = TimeOfDay.Second
    TMS = TimeOfDay.Millisecond
    For TestNum = 5 To Sentinal Step 2
        Do While Primes(X) <> 0 And UnPrime And Primes(X) ^ 2 <= TestNum
            If Int(TestNum / Primes(X)) - (TestNum / Primes(X)) = 0 Then
                UnPrime = False
            End If
            X = X + 1

        Loop
        If UnPrime = True Then
            X = X + 1
            Z = Z + 1
            Primes(Z) = TestNum
        End If
        UnPrime = True
        X = 0
    Next
    Button1.Text = "Finished with " & Z
    TM = TimeOfDay.Minute - TM
    TS = TimeOfDay.Second - TS
    TMS = TimeOfDay.Millisecond - TMS
    ShowTime.Text = TM & ":" & TS & ":" & TMS
End Sub
Cevap 11/03/2011 saat 03:25
kaynak kullanıcı

oy
0

İlk 10000 asal istediğim için sadece karmaşık bir algoritma kodlama yerine aşağıdaki öneride bulunuruz

boolean isPrime(int n){
//even but is prime
    if(n==2)
        return true;
//even numbers filtered already 
    if(n==0 || n==1 || n%2==0)
        return false;

// loop for checking only odd factors
// i*i <= n  (same as i<=sqrt(n), avoiding floating point calculations)
    for(int i=3 ; i*i <=n ; i+=2){
    // if any odd factor divides n then its not a prime!
        if(n%i==0)
            return false;
    }
// its prime now
    return true;
}

İhtiyacınız olarak artık çağrı asal

for(int i=1 ; i<=1000 ; i++){
    if(isPrime(i)){
       //do something
    }
}
Cevap 16/11/2018 saat 05:34
kaynak kullanıcı

oy
0

Bunu uygulamak zorunda, size bazı ipuçları verebilir.

  1. Her numara için, bu sayının yarısı olsun. Örneğin, 21 kontrol etmek için, sadece aralık 2-10 bölünerek kalan alın.
  2. onun bir tek sayı, tek sayı sadece bölme ve tersi de geçerlidir. Bu gibi 21 için olduğu gibi, sadece 3, 5, 7, 9 ile bölün.

En etkili yöntem şimdiye kadar hiç kalktı.

Cevap 29/07/2018 saat 19:25
kaynak kullanıcı

oy
0

JavaScript Array.prototype.find () yöntemini kullanma. 2214.486 ms

function isPrime (number) {

  function prime(element) {
    let start = 2;
    while (start <= Math.sqrt(element)) {
      if (element % start++ < 1) {
        return false;
      }
    }
    return element > 1;
  }

  return [number].find(prime)

}

function logPrimes (n) {

  let count = 0
  let nth = n

  let i = 0
  while (count < nth) {
    if (isPrime(i)) {
      count++
      console.log('i', i) //NOTE: If this line is ommited time to find 10,000th prime is 121.157ms
      if (count === nth) {
        console.log('while i', i)
        console.log('count', count)
      }
    }
    i++
  }

}

console.time(logPrimes)

logPrimes(10000)

console.timeEnd(logPrimes) // 2214.486ms
Cevap 09/06/2018 saat 21:49
kaynak kullanıcı

oy
0

Yaptığım kodu Buraya:


enter code here
#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;


int main() {
/* Enter your code here. Read input from STDIN. Print output to STDOUT*/   

unsigned long int n;

int prime(unsigned long int);

scanf("%ld",&n);

unsigned long int val;

for(unsigned long int i=0;i<n;i++)
{
    int flag=0;

    scanf("%ld",&val);

    flag=prime(val);

    if(flag==1)
        printf("yes\n");

    else
        printf("no\n");
}

return 0;

}

int prime(unsigned long int n)
{

if(n==2) return 1;

else if (n == 1||n%2==0)  return 0;

for (unsigned long int i=3; i<=sqrt(n); i+=2)
    if (n%i == 0)
        return 0;

return 1;
}
Cevap 20/01/2018 saat 15:50
kaynak kullanıcı

oy
0

İşte laptop 0.049655 saniyede ilk 10.000 asal bulur zaman kodu, birinci 1,000,000 asal 6 saniyenin altında ve birinci 2.000.000 15 saniye içinde
küçük bir açıklama. Bu yöntem asal sayı bulmak için 2 tekniklerini kullanır

  1. Bunun yerine, herhangi bir sayıda daha küçük asal sayılar test sayısına bölünmesi ile, bu kod test, bu da daha fazla hesaplama 4 basamaklı sayı için en az 10 kat azaltır ve bu nedenle ilk olarak bir asal olmayan sayı asal sayıların katları bir kompozit Daha büyük bir sayı
  2. sayının kökü daha büyüktür herhangi bir sayı meslektaşı numarası olacaktır çünkü ikinci olarak asal bölünmesi yanında, sadece daha ileri ölçüde hesaplamaları azaltan test edilen sayının köküne küçük veya eşit asal sayılar böler, bu çalıştığını sayının kökü daha küçük olmak zorunda ama biz zaten kökünden daha küçük tüm numaraları test ettik çünkü nedenle sayı test edilen kök daha büyük bir sayı ile rahatsız etmek gerekmez.

Ilk 10.000 asal sayısı için Örnek çıktı
https://drive.google.com/open?id=0B2QYXBiLI-lZMUpCNFhZeUphck0 https://drive.google.com/open?id=0B2QYXBiLI-lZbmRtTkZETnp6Ykk

Burada C dilinde kodu 1 girin ve ardından 10,000 ilk 10.000 asal yazdırmak için.
Düzenleme: Bu o ince olması gerekenden daha pencereler ya da görsel stüdyo ancak linux üzerinde olup olmadığını lm argümanı kullanarak kodunu derlemek gerekir veya kod çalışmayabilir, matematik kütüphanesini içeriyor unuttum
Örnek: gcc -Wall -o "% e " "% m" -lm

#include <stdio.h>
#include <math.h>
#include <time.h>
#include <limits.h>

/* Finding prime numbers */
int main()
{   
    //pre-phase
    char d,w;
    int l,o;
    printf("  1. Find first n number of prime numbers or Find all prime numbers smaller than n ?\n"); // this question helps in setting the limits on m or n value i.e l or o 
    printf("     Enter 1 or 2 to get anwser of first or second question\n");
    // decision making
    do
    {
        printf("  -->");
        scanf("%c",&d);
        while ((w=getchar()) != '\n' && w != EOF);
        if ( d == '1')
        {
            printf("\n  2. Enter the target no. of primes you will like to find from 3 to 2,000,000 range\n  -->");
            scanf("%10d",&l);
            o=INT_MAX;
            printf("  Here we go!\n\n");
            break;
        }
        else if ( d == '2' )
        {
            printf("\n  2.Enter the limit under which to find prime numbers from 5 to 2,000,000 range\n  -->");
            scanf("%10d",&o);
            l=o/log(o)*1.25;
            printf("  Here we go!\n\n");
            break;
        }
        else printf("\n  Try again\n");
    }while ( d != '1' || d != '2' );

    clock_t start, end;
    double cpu_time_used;
    start = clock(); /* starting the clock for time keeping */

    // main program starts here
    int i,j,c,m,n; /* i ,j , c and m are all prime array 'p' variables and n is the number that is being tested */
    int s,x;

    int p[ l ]; /* p is the array for storing prime numbers and l sets the array size, l was initialized in pre-phase */
    p[1]=2;
    p[2]=3;
    p[3]=5;
    printf("%10dst:%10d\n%10dnd:%10d\n%10drd:%10d\n",1,p[1],2,p[2],3,p[3]); // first three prime are set
    for ( i=4;i<=l;++i ) /* this loop sets all the prime numbers greater than 5 in the p array to 0 */
        p[i]=0;

    n=6; /* prime number testing begins with number 6 but this can lowered if you wish but you must remember to update other variables too */
    s=sqrt(n); /* 's' does two things it stores the root value so that program does not have to calaculate it again and again and also it stores it in integer form instead of float*/
    x=2; /* 'x' is the biggest prime number that is smaller or equal to root of the number 'n' being tested */

    /* j ,x and c are related in this way, p[j] <= prime number x <= p[c] */

    // the main loop begins here
    for ( m=4,j=1,c=2; m<=l && n <= o;)
    /* this condition checks if all the first 'l' numbers of primes are found or n does not exceed the set limit o */
    {
            // this will divide n by prime number in p[j] and tries to rule out non-primes
            if ( n%p[j]==0 )
            {
                /* these steps execute if the number n is found to be non-prime */

                ++n; /* this increases n by 1 and therefore sets the next number 'n' to be tested */
                s=sqrt(n); /* this calaulates and stores in 's' the new root of number 'n' */
                if ( p[c] <= s && p[c] != x ) /* 'The Magic Setting' tests the next prime number candidate p[c] and if passed it updates the prime number x */
                {
                    x=p[c];
                    ++c;
                }
                j=1;
                /* these steps sets the next number n to be tested and finds the next prime number x if possible for the new number 'n' and also resets j to 1 for the new cycle */
                continue; /* and this restarts the loop for the new cycle */
            }
            // confirmation test for the prime number candidate n
            else if ( n%p[j]!=0 && p[j]==x )
            {
                /* these steps execute if the number is found to be prime */
                p[m]=n;
                printf("%10dth:%10d\n",m,p[m]);
                ++n;
                s = sqrt(n);
                ++m;
                j=1;
                /* these steps stores and prints the new prime number and moves the 'm' counter up and also sets the next number n to be tested and also resets j to 1 for the new cycle */
                continue; /* and this restarts the loop */
                /* the next number which will be a even and non-prime will trigger the magic setting in the next cycle and therfore we do not have to add another magic setting here*/
            }
            ++j; /* increases p[j] to next prime number in the array for the next cycle testing of the number 'n' */
            // if the cycle reaches this point that means the number 'n' was neither divisible by p[j] nor was it a prime number
            // and therfore it will test the same number 'n' again in the next cycle with a bigger prime number
    }
    // the loops ends
    printf("  All done !!\n");
    end = clock();
    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("  Time taken : %lf sec\n",cpu_time_used);
}
Cevap 06/05/2017 saat 11:48
kaynak kullanıcı

oy
0

Ben yaklaşık bir yıl boyunca bulmak asal üzerinde çalışıyoruz. Bu benim en hızlı olduğu tespit şudur:

import static java.lang.Math.sqrt;
import java.io.PrintWriter;
import java.io.File;
public class finder {
    public static void main(String[] args) {
        primelist primes = new primelist();
        primes.insert(3);
        primes.insert(5);
        File file = new File("C:/Users/Richard/Desktop/directory/file0024.txt");
        file.getParentFile().mkdirs();
        long time = System.nanoTime();
        try{
            PrintWriter printWriter = new PrintWriter ("file0024.txt"); 
            int linenum = 0;
            printWriter.print("2");
            printWriter.print (" , ");
            printWriter.print("3");
            printWriter.print (" , ");
            int up;
            int down;           
            for(int i =1; i<357913941;i++){//
                if(linenum%10000==0){
                    printWriter.println ("");
                    linenum++;
                }
                down = i*6-1;
                if(primes.check(down)){
                    primes.insert(down);
                    //System.out.println(i*6-1);
                    printWriter.print ( down );
                    printWriter.print (" , ");
                    linenum++;  
                }
                up = i*6+1;
                if(primes.check(up)){
                    primes.insert(up);
                    //System.out.println(i*6+1);
                    printWriter.print ( up );
                    printWriter.print (" , ");
                    linenum++;  
                }
            }
            printWriter.println ("Time to execute");
            printWriter.println (System.nanoTime()-time);
            //System.out.println(primes.length);
            printWriter.close ();
        }catch(Exception e){}
    } 
}
class node{
    node next;
    int x;
    public node (){
        node next;
        x = 3;
    }
    public node(int z) {
        node next;
        x = z;
    }
}
class primelist{
    node first;
    int length =0;
    node current;
    public void insert(int x){
        node y = new node(x);
        if(current == null){
            current = y;
            first = y;
        }else{
            current.next = y;
            current = y;
        }
        length++;
    }
    public boolean check(int x){
        int p = (int)sqrt(x);
        node y = first;
        for(int i = 0;i<length;i++){
            if(y.x>p){
                return true;
            }else if(x%y.x ==0){
                return false;
            }
            y = y.next;
        }
        return true;
    }
}

1902465190909 nano saniye 2'de başlayan 2147483629 ulaşmak için.

Cevap 14/08/2016 saat 00:20
kaynak kullanıcı

oy
0

Ben asal bir sürü hesaplama programı yazarken biraz zaman harcamak ve bu ilk 1.000.000.000 asal içeren bir metin dosyası hesaplamak için alışkınım koddur. Bu Almanca, ama ilginç bölüm yöntemidir calcPrimes(). Asal Primzahlen olarak adlandırılan bir dizi saklanır. Hesaplamalar 64bit tamsayılar ile çünkü ben bir 64bit CPU önerilir.

import java.io.*;
class Primzahlengenerator {
    long[] Primzahlen;
    int LastUnknown = 2;
    public static void main(String[] args)  {
        Primzahlengenerator Generator = new Primzahlengenerator();
        switch(args.length) {
            case 0:  //Wenn keine Argumente übergeben worden:
                Generator.printHelp(); //Hilfe ausgeben
                return; //Durchfallen verhindern
            case 1:
                try {
                    Generator.Primzahlen = new long[Integer.decode(args[0]).intValue()];
                }
                catch (NumberFormatException e) {
                    System.out.println("Das erste Argument muss eine Zahl sein, und nicht als Wort z.B. \"Tausend\", sondern in Ziffern z.B. \"1000\" ausgedrückt werden.");//Hinweis, wie man die Argumente angeben muss ausgeben
                    Generator.printHelp();                    //Generelle Hilfe ausgeben
                    return;
                }
                break;//dutchfallen verhindern

            case 2:
                switch (args[1]) {
                    case "-l":
                        System.out.println("Sie müsen auch eine Datei angeben!"); //Hilfemitteilung ausgeben
                        Generator.printHelp();                                    //Generelle Hilfe ausgeben
                        return;
                }
                break;//durchfallen verhindern
            case 3:
                try {
                    Generator.Primzahlen = new long[Integer.decode(args[0]).intValue()];
                }
                catch (NumberFormatException e) {
                    System.out.println("Das erste Argument muss eine Zahl sein, und nicht als Wort z.B. \"Tausend\", sondern in Ziffern z.B. \"1000\" ausgedrückt werden.");//Hinweis, wie man die Argumente angeben muss ausgeben
                    Generator.printHelp();                      //Generelle Hilfe ausgeben
                    return;
                }
                switch(args[1]) {
                    case "-l":
                        Generator.loadFromFile(args[2]);//Datei Namens des Inhalts von Argument 3 lesen, falls Argument 2 = "-l" ist
                        break;
                    default:
                        Generator.printHelp();
                        break;
                }
                break;
            default:
                Generator.printHelp();
                return;
        }
        Generator.calcPrims();
    }
    void printHelp() {
        System.out.println("Sie müssen als erstes Argument angeben, die wieviel ersten Primzahlen sie berechnen wollen.");   //Anleitung wie man das Programm mit Argumenten füttern muss
        System.out.println("Als zweites Argument können sie \"-l\" wählen, worauf die Datei, aus der die Primzahlen geladen werden sollen,");
        System.out.println("folgen muss. Sie muss genauso aufgebaut sein, wie eine Datei Primzahlen.txt, die durch den Aufruf \"java Primzahlengenerator 1000 > Primzahlen.txt\" entsteht.");
    }
    void loadFromFile(String File) {
        // System.out.println("Lese Datei namens: \"" + File + "\"");
        try{
            int x = 0;
            BufferedReader in = new BufferedReader(new FileReader(File));
            String line;
            while((line = in.readLine()) != null) {
                Primzahlen[x] = new Long(line).longValue();
                x++;
            }
            LastUnknown = x;
        } catch(FileNotFoundException ex) {
            System.out.println("Die angegebene Datei existiert nicht. Bitte geben sie eine existierende Datei an.");
        } catch(IOException ex) {
            System.err.println(ex);
        } catch(ArrayIndexOutOfBoundsException ex) {
            System.out.println("Die Datei enthält mehr Primzahlen als der reservierte Speicherbereich aufnehmen kann. Bitte geben sie als erstes Argument eine größere Zahl an,");
            System.out.println("damit alle in der Datei enthaltenen Primzahlen aufgenommen werden können.");
            }
        /* for(long prim : Primzahlen) {
            System.out.println("" + prim);
        } */
        //Hier soll code stehen, der von der Datei mit angegebenem Namen ( Wie diese aussieht einfach durch angeben von folgendem in cmd rausfinden:
        //java Primzahlengenerator 1000 > 1000Primzahlen.txt
        //da kommt ne textdatei, die die primzahlen enthält. mit Long.decode(String ziffern).longValue();
        //erhält man das was an der entsprechenden stelle in das array soll. die erste zeile soll in [0] , die zweite zeile in [1] und so weiter.
        //falls im arry der platz aus geht(die exception kenn ich grad nich, aber mach mal:
        //int[] foo = { 1, 2, 3};
        //int bar = foo[4];
        //dann kriegst ne exception, das ist die gleiche die man kriegt, wenn im arry der platzt aus geht.
    }
    void calcPrims() {
        int PrimzahlNummer = LastUnknown;
        // System.out.println("LAstUnknown ist: " + LastUnknown);
        Primzahlen[0] = 2;
        Primzahlen[1] = 3;
        long AktuelleZahl = Primzahlen[PrimzahlNummer - 1];
        boolean IstPrimzahl;
        // System.out.println("2");
        // System.out.println("3");
        int Limit = Primzahlen.length;
        while(PrimzahlNummer < Limit) {
            IstPrimzahl = true;
            double WurzelDerAktuellenZahl = java.lang.Math.sqrt(AktuelleZahl);
            for(int i = 1;i < PrimzahlNummer;i++) {
                if(AktuelleZahl % Primzahlen[i] == 0) {
                    IstPrimzahl = false;
                    break;
                }
                if(Primzahlen[i] > WurzelDerAktuellenZahl) break;
            }
            if(IstPrimzahl) {
                Primzahlen[PrimzahlNummer] = AktuelleZahl;
                PrimzahlNummer++;
                // System.out.println("" + AktuelleZahl);
            }
            AktuelleZahl = AktuelleZahl + 2;
        }
        for(long prim : Primzahlen) {
            System.out.println("" + prim);
        }
    }
}
Cevap 23/04/2012 saat 20:46
kaynak kullanıcı

oy
0

Sadece bunu öğrenmeye başladı gibi bu kullanarak piton yazdım ve mükemmel çalışıyor. 10000 asal belirtildiği gibi aynı bu kodla oluşturmak http://primes.utm.edu/lists/small/10000.txt . Olmadığını kontrol etmek için n, bölmek asal olmadığını ndan numaralarıyla 2için sqrt(n). Sayının bu aralığın herhangi mükemmel böler olursa no zaman asal değil.

import math
print ("You want prime till which number??")
a = input()
a = int(a)
x = 0
x = int(x)
count = 1
print("2 is prime number")
for c in range(3,a+1):
    b = math.sqrt(c)
    b = int(b)
    x = 0
    for b in range(2,b+1):
        e  = c % b
        e = int(e)
        if (e == 0):
            x = x+1
    if (x == 0):
        print("%d is prime number" % c)
        count = count + 1
print("Total number of prime till %d is %d" % (a,count))
Cevap 27/12/2010 saat 18:37
kaynak kullanıcı

oy
-1
using System;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            int n, i = 3, j, c;
            Console.WriteLine("Please enter your integer: ");
            n = Convert.ToInt32(Console.ReadLine());
            if (n >= 1)
            {
                Console.WriteLine("First " + n + " Prime Numbers are");
                Console.WriteLine("2");
            }
            for(j=2;j<=n;)
            {
                for(c=2;c<=i-1;c++)
                {
                    if(i%c==0)
                        break;
                }
                    if(c==i)
                    {
                        Console.WriteLine(i);
                        j++;
                    }
                    i++;                                
            }
            Console.Read();
        }
    }
}
Cevap 08/05/2012 saat 05:15
kaynak kullanıcı

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more