Quelle est la manière la plus élégante de générer des nombres premiers en C# ou Java ?

À la recherche de l'élégance : bonnes pratiques pour la génération de nombres premiers en C# ou Java

La génération de nombres premiers a toujours été un sujet que les programmeurs ont exploré depuis longtemps. Comment trouver un équilibre entre vitesse et clarté du code est devenu la clé de la conception d'algorithmes. Cet article explore des méthodes élégantes pour générer des nombres premiers en C# ou Java.

Tamis amélioré d'Eratosthène

Le tamis d'Ératosthène est l'une des méthodes courantes pour trouver les nombres premiers. En supprimant de manière itérative les multiples de chaque nombre premier, nous pouvons filtrer tous les nombres non premiers. Le code suivant est une amélioration de l'algorithme de tamisage standard :

public static List<int> GeneratePrimes(int limit)
{
    if (limit < 2) return new List<int>();

    var primes = new bool[limit + 1];

    for (int i = 2; i * i <= limit; i++)
    {
        if (!primes[i])
        {
            for (int j = i * i; j <= limit; j += i)
            {
                primes[j] = true;
            }
        }
    }

    var result = new List<int>();
    for (int i = 2; i <= limit; i++)
    {
        if (!primes[i])
        {
            result.Add(i);
        }
    }
    return result;
}

Génération de nombres premiers basée sur LINQ

Une autre approche consiste à profiter de la fonction d'évaluation paresseuse de LINQ. Ce code renvoie une séquence infinie de nombres premiers :

public static IEnumerable<int> GeneratePrimesLINQ()
{
    yield return 2;
    yield return 3;

    var primes = new HashSet<int> { 2, 3 };

    for (int i = 5; ; i += 2)
    {
        if (!primes.Any(p => i % p == 0))
        {
            primes.Add(i);
            yield return i;
        }
    }
}

Sélection de la méthode

La méthode à choisir dépend du scénario d'application spécifique. Le tamis modifié d'Eratosthène est efficace pour trouver un nombre fixe de nombres premiers, tandis que la méthode basée sur LINQ fournit une séquence infinie paresseuse adaptée au traitement incrémentiel. En fin de compte, la solution la plus élégante est celle qui répond de manière claire et efficace à un besoin spécifique.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!