Das Sieb von Eratosthenes ist ein effizienter Algorithmus zur Bestimmung aller Primzahlen bis zu einer bestimmten Grenze. Der Algorithmus funktioniert, indem er iterativ die Vielfachen jeder Primzahl ab dem Quadrat der Primzahl als nicht prim markiert. Die Schritte des Algorithmus sind wie folgt:

1. Erstelle eine Liste von booleschen Werten, die alle auf 'wahr' gesetzt sind. Die Indizes dieser Liste repräsentieren die Zahlen von 2 bis zu einer oberen Grenze n.
2. Setze den Wert der Indizes 0 und 1 auf 'falsch', da 0 und 1 keine Primzahlen sind.
3. Beginne mit der ersten Primzahl p (p = 2).
4. Markiere alle Vielfachen von p (beginnend mit p^2) als 'falsch'.
5. Finde die nächste Zahl in der Liste, die noch 'wahr' ist. Dies ist die nächste Primzahl.
6. Wiederhole die Schritte 4 und 5, bis p^2 größer als n ist.
7. Die verbleibenden 'wahren' Werte in der Liste repräsentieren Primzahlen.

Hier ist eine Beispielimplementierung in Python, die die ersten 1000 Primzahlen berechnet:

python
import itertools

def sieve_of_eratosthenes(limit):
    sieve = [True] * (limit + 1)
    sieve[0] = sieve[1] = False
    for start in range(2, int(limit**0.5) + 1):
        if sieve[start]:
            for multiple in range(start*start, limit + 1, start):
                sieve[multiple] = False
    return [num for num, is_prime in enumerate(sieve) if is_prime]

# Da wir die ersten 1000 Primzahlen benötigen, müssen wir eine obere Grenze schätzen.
# Eine grobe Schätzung für die n-te Primzahl ist n * log(n * log(n)).
# Für die ersten 1000 Primzahlen ist eine Grenze von etwa 8000 ausreichend.

limit = 8000
primes = sieve_of_eratosthenes(limit)
first_1000_primes = primes[:1000]

print(first_1000_primes)


Diese Implementierung verwendet das Sieb von Eratosthenes, um Primzahlen bis zu einem bestimmten Limit zu finden. Die Schätzung der oberen Grenze stellt sicher, dass wir mindestens die ersten 1000 Primzahlen erhalten.