Programme pour trouver des nombres premiers
Je veux trouver le nombre premier compris entre 0 et une variable longue, mais je ne parviens pas à obtenir de sortie.
Le programme est
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication16
{
class Program
{
void prime_num(long num)
{
bool isPrime = true;
for (int i = 0; i <= num; i++)
{
for (int j = 2; j <= num; j++)
{
if (i != j && i % j == 0)
{
isPrime = false;
break;
}
}
if (isPrime)
{
Console.WriteLine ( "Prime:" + i );
}
isPrime = true;
}
}
static void Main(string[] args)
{
Program p = new Program();
p.prime_num (999999999999999L);
Console.ReadLine();
}
}
}
Quelqu'un peut-il m'aider et trouver quelle est l'erreur possible dans le programme?
Vous pouvez le faire plus rapidement en utilisant un tamis de division d'essai presque optimal en une (longue) ligne comme ceci:
Enumerable.Range(0, Math.Floor(2.52*Math.Sqrt(num)/Math.Log(num))).Aggregate(
Enumerable.Range(2, num-1).ToList(),
(result, index) => {
var bp = result[index]; var sqr = bp * bp;
result.RemoveAll(i => i >= sqr && i % bp == 0);
return result;
}
);
La formule d'approximation du nombre de nombres premiers utilisée ici est π(x) < 1.26 x / ln(x) . Nous avons seulement besoin de tester avec des nombres premiers non supérieurs à x = sqrt(num).
Notez que le tamis d'Eratosthenes a une complexité d'exécution bien meilleure que la division trial (devrait s'exécuter beaucoup plus rapidement pour de plus grandes valeurs num, si correctement implémenté).
Essaye ça:
void prime_num(long num)
{
// bool isPrime = true;
for (long i = 0; i <= num; i++)
{
bool isPrime = true; // Move initialization to here
for (long j = 2; j < i; j++) // you actually only need to check up to sqrt(i)
{
if (i % j == 0) // you don't need the first condition
{
isPrime = false;
break;
}
}
if (isPrime)
{
Console.WriteLine ( "Prime:" + i );
}
// isPrime = true;
}
}
Les gens ont mentionné quelques éléments de base permettant de le faire efficacement, mais personne n'a vraiment assemblé les morceaux. Le tamis d'Ératosthène est un bon début, mais avec cela, vous manquerez de mémoire long avant que vous n'ayez atteint la limite que vous avez définie. Cela ne veut pas dire pour autant que cela soit inutile: lorsque vous faites votre boucle, ce qui compte vraiment, ce sont les diviseurs principaux. En tant que tel, vous pouvez commencer par utiliser le tamis pour créer une base de diviseurs principaux, puis utiliser ceux de la boucle pour vérifier la primauté des nombres.
Lorsque vous écrivez la boucle, cependant, vous ne voulez PAS vraiment nous sqrt (i) dans la condition de boucle comme le suggèrent quelques réponses. Vous et moi savons que le sqrt est une fonction "pure" qui donne toujours la même réponse si le même paramètre d’entrée est donné. Malheureusement, le compilateur ne le SAIT PAS. Par conséquent, si vous utilisez quelque chose comme '<= Math.sqrt (x)' dans la condition de boucle, il calculera le carré du nombre à chaque itération de la boucle.
Vous pouvez éviter cela de deux manières différentes. Vous pouvez soit pré-calculer le sqrt avant la boucle et utiliser la valeur pré-calculée dans la condition de boucle, ou vous pouvez travailler dans l'autre sens et changer i<Math.sqrt(x) en i*i<x. Personnellement, je calculais bien la racine carrée - je pense que c'est plus clair et probablement un peu plus rapide - mais cela dépend du nombre d'itérations de la boucle (le i*i signifie qu'il est toujours en train de se multiplier). Avec seulement quelques itérations, i*i sera généralement plus rapide. Avec suffisamment d'itérations, la perte de i*i à chaque itération est supérieure au temps nécessaire pour exécuter sqrt une fois en dehors de la boucle.
Cela convient probablement à la taille des nombres que vous traitez - une limite de 15 chiffres signifie que la racine carrée est composée de 7 ou 8 chiffres, ce qui permet de conserver une quantité de mémoire assez raisonnable. D'un autre côté, si vous souhaitez traiter beaucoup de nombres dans cette plage, vous pouvez vous pencher sur certains des algorithmes de contrôle prime les plus sophistiqués, tels que les algorithmes de Pollard ou de Brent . Celles-ci sont plus complexes (c'est le moins que l'on puisse dire) mais un lot plus rapide pour les grands nombres.
Il existe d'autres algorithmes pour des nombres encore plus grands ( tamis quadratique , tamis de champ de nombres général ) mais nous ne les entrerons pas pour l'instant - ils sont beaucoup plus complexes et vraiment utiles. pour traiter de très grands nombres (le GNFS commence à être utile dans la plage des 100 chiffres et plus).
Il vous suffit de vérifier les diviseurs impairs jusqu'à la racine carrée du nombre. En d'autres termes, votre boucle intérieure doit commencer:
for (int j = 3; j <= Math.Sqrt(i); j+=2) { ... }
Vous pouvez également quitter la fonction dès que vous trouvez que le nombre n'est pas premier, vous n'avez pas besoin de vérifier d'autres diviseurs (je vois que vous le faites déjà!).
Cela ne fonctionnera que si num est supérieur à deux.
Aucun Sqrt
Vous pouvez éviter le Sqrt en gardant une somme en cours. Par exemple:
int square_sum=1;
for (int j=3; square_sum<i; square_sum+=4*(j++-1)) {...}
En effet, la somme des nombres 1+ (3 + 5) + (7 + 9) vous donnera une suite de carrés impairs (1,9,25, etc.). Et par conséquent, j représente la racine carrée de square_sum. Tant que square_sum est inférieur à i, alors j est inférieur à la racine carrée.
Première étape: écrit une méthode d'extension pour savoir si une entrée est première
public static bool isPrime(this int number ) {
for (int i = 2; i < number; i++) {
if (number % i == 0) {
return false;
}
}
return true;
}
2 step: write la méthode qui imprimera tous les nombres premiers compris entre 0 et le nombre saisi
public static void getAllPrimes(int number)
{
for (int i = 0; i < number; i++)
{
if (i.isPrime()) Console.WriteLine(i);
}
}
EDIT_ADD: Si Will Ness a raison, le but de la question est simplement de générer un flux continu de nombres premiers tant que le programme est exécuté (appuyer sur Pause/Break pour mettre en pause et sur une touche pour recommencer) sans espoir sérieux. à chaque fois que vous atteignez cette limite supérieure, le code doit alors être écrit sans argument de limite supérieure et une vérification de plage de "vrai" pour le premier «i» de la boucle. D'autre part, si la question voulait réellement imprimer les nombres premiers jusqu'à une limite, le code suivant ferait le travail beaucoup plus efficacement en utilisant Trial Division uniquement pour les nombres impairs, avec l'avantage de ne pas utiliser la mémoire du tout. (il pourrait également être converti en une boucle continue comme ci-dessus):
static void primesttt(ulong top_number) {
Console.WriteLine("Prime: 2");
for (var i = 3UL; i <= top_number; i += 2) {
var isPrime = true;
for (uint j = 3u, lim = (uint)Math.Sqrt((double)i); j <= lim; j += 2) {
if (i % j == 0) {
isPrime = false;
break;
}
}
if (isPrime) Console.WriteLine("Prime: {0} ", i);
}
}
Premièrement, le code de la question ne produit aucune sortie car ses variables de boucle sont des entiers et la limite testée est un très grand entier, ce qui signifie qu’il est impossible pour la boucle d’atteindre la limite produisant une boucle interne EDITED: la variable 'j' revient aux nombres négatifs; lorsque la variable 'j' revient à -1, le nombre testé échoue au test premier car tous les nombres sont divisibles par -1 _/END_EDIT. Même si cela était corrigé, le code de la question produisait une sortie très lente car il était lié par des divisions de 64 bits de très grandes quantités de nombres composites (tous les nombres pairs plus les composites impairs) par toute la gamme de nombres allant jusqu'au sommet supérieur. nombre de dix élevé à la seizième puissance pour chaque nombre premier qu'il peut éventuellement produire. Le code ci-dessus fonctionne car il limite le calcul aux nombres impairs et ne fait que des divisions modulo jusqu’à la racine carrée du nombre en cours de test.
Cela prend environ une heure pour afficher les nombres premiers jusqu'à un milliard. On peut donc imaginer combien de temps il faudrait pour afficher tous les nombres premiers à dix mille milliards de dollars (10 élevés à la seizième puissance), d'autant plus que le calcul devient plus lent. avec une portée croissante. END_EDIT_ADD
Bien que la réponse unique de @SLaks utilisant Linq fonctionne, ce n'est pas vraiment le tamis d'Eratosthène, car il ne s'agit que d'une version non optimisée de Trial Division , non optimisée, car elle n'élimine pas les impairs. nombres premiers, ne commence pas au carré du nombre premier de base trouvé et n'arrête pas la sélection des nombres premiers de base plus grands que la racine carrée du nombre le plus élevé à tamiser. Il est également assez lent en raison des multiples opérations d’énumération imbriquées.
Il s’agit en réalité d’un abus de la méthode Linq Aggregate et n’utilise pas efficacement le premier des deux générés de la gamme Linq. Elle peut devenir une division de première instance optimisée avec moins de frais généraux de dénombrement, comme suit:
static IEnumerable<int> primes(uint top_number) {
var cullbf = Enumerable.Range(2, (int)top_number).ToList();
for (int i = 0; i < cullbf.Count; i++) {
var bp = cullbf[i]; var sqr = bp * bp; if (sqr > top_number) break;
cullbf.RemoveAll(c => c >= sqr && c % bp == 0);
} return cullbf; }
qui court plusieurs fois plus vite que la réponse SLaks. Cependant, il est toujours lent et nécessite beaucoup de mémoire en raison de la génération de liste et des énumérations multiples ainsi que des opérations de division multiple (impliquées par le modulo).
La véritable implémentation suivante de Sieve of Eratosthenes est environ 30 fois plus rapide et prend beaucoup moins de mémoire, car elle n’utilise qu’une représentation à un bit par nombre tamisé et limite son énumération à la sortie de la séquence finale de l’itérateur, tout en optimisant le traitement de composites impairs, et uniquement l’abattage à partir des carrés des nombres premiers de base pour les nombres premiers de base jusqu’à la racine carrée du nombre maximal, comme suit:
static IEnumerable<uint> primes(uint top_number) {
if (top_number < 2u) yield break;
yield return 2u; if (top_number < 3u) yield break;
var BFLMT = (top_number - 3u) / 2u;
var SQRTLMT = ((uint)(Math.Sqrt((double)top_number)) - 3u) / 2u;
var buf = new BitArray((int)BFLMT + 1,true);
for (var i = 0u; i <= BFLMT; ++i) if (buf[(int)i]) {
var p = 3u + i + i; if (i <= SQRTLMT) {
for (var j = (p * p - 3u) / 2u; j <= BFLMT; j += p)
buf[(int)j] = false; } yield return p; } }
Le code ci-dessus calcule tous les nombres premiers à dix millions en environ 77 millisecondes sur un processeur Intel i7-2700K (3,5 GHz).
Chacune des deux méthodes statiques peut être appelée et testée avec les instructions using et avec la méthode principale statique comme suit:
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
static void Main(string[] args) {
Console.WriteLine("This program generates prime sequences.\r\n");
var n = 10000000u;
var elpsd = -DateTime.Now.Ticks;
var count = 0; var lastp = 0u;
foreach (var p in primes(n)) { if (p > n) break; ++count; lastp = (uint)p; }
elpsd += DateTime.Now.Ticks;
Console.WriteLine(
"{0} primes found <= {1}; the last one is {2} in {3} milliseconds.",
count, n, lastp,elpsd / 10000);
Console.Write("\r\nPress any key to exit:");
Console.ReadKey(true);
Console.WriteLine();
}
qui montrera le nombre de nombres premiers dans la séquence jusqu'à la limite, le dernier nombre trouvé et le temps passé à énumérer cette distance.
EDIT_ADD: Cependant, pour produire une énumération du nombre de nombres premiers inférieurs à dix mille milliards de dollars (puissance dix à seizième) comme le demande la question, une approche paginée segmentée utilisant un traitement multicœur est requise mais même avec C++ et le PrimeSieve très optimisé , il faudrait plus de 400 heures pour produire le nombre de nombres premiers trouvés, et des dizaines de fois pour les énumérer, donc plus d'un an pour résoudre le problème. demande. Pour le faire en utilisant l’algorithme non optimisé de Trial Division, il faudra des milliards de jours et même très longtemps, même en utilisant un algorithme optimisé de Trial Division comme dans environ dix à deux millions d’années de puissance (soit deux millions de zéros!) !).
Il n'est pas étonnant que son ordinateur de bureau soit resté assis et bloqué lorsqu'il l'a essayé !!!! S'il avait essayé une gamme plus petite, telle qu'un million, il aurait tout de même trouvé que cela prenait environ quelques secondes.
Les solutions que je décris ici ne résoudront pas le problème, car même le dernier crible d'Eratosthenes nécessitera environ 640 téraoctets de mémoire pour cette plage.C’est la raison pour laquelle seule une approche segmentée telle que celle de PrimeSieve peut traiter ce type de problème pour la plage spécifiée, et même cela prend du temps, comme dans des semaines ou des années, à moins que l’on ait accès à un super des centaines de milliers de cœurs. END_EDIT_ADD.
That is why only a page segmented approach such as that of PrimeSieve can handle this sort of problem for the range as specified at all, and even that requires a very long time, as in weeks to years unless one has access to a super computer with hundreds of thousands of cores. END_EDIT_ADD
C'est peut-être juste mon avis, mais il y a une autre erreur grave dans votre programme (mettre de côté la question du «nombre premier» donnée, à laquelle une réponse complète a été apportée).
Comme les autres intervenants, je suppose que c'est un devoir, ce qui indique que vous souhaitez devenir développeur (vraisemblablement).
Vous devez apprendre à compartimenter votre code. Ce n'est pas quelque chose que vous devrez toujours faire dans un projet, mais il est bon de savoir comment le faire.
Votre méthode prime_num (long num) pourrait contenir un meilleur nom, plus descriptif. Et s'il est supposé trouver tous les nombres premiers inférieurs à un nombre donné, il devrait les renvoyer sous forme de liste. Cela facilite la séparation de votre affichage et de vos fonctionnalités.
Si elle renvoie simplement une liste IList contenant des nombres premiers, vous pouvez les afficher dans votre fonction principale (en appelant éventuellement une autre fonction extérieure pour les imprimer) ou les utiliser pour des calculs ultérieurs.
Donc, ma meilleure recommandation à vous est de faire quelque chose comme ceci:
public void main(string args[])
{
//Get the number you want to use as input
long x = number;//'number' can be hard coded or retrieved from ReadLine() or from the given arguments
IList<long> primes = FindSmallerPrimes(number);
DisplayPrimes(primes);
}
public IList<long> FindSmallerPrimes(long largestNumber)
{
List<long> returnList = new List<long>();
//Find the primes, using a method as described by another answer, add them to returnList
return returnList;
}
public void DisplayPrimes(IList<long> primes)
{
foreach(long l in primes)
{
Console.WriteLine ( "Prime:" + l.ToString() );
}
}
Même si vous finissez par travailler dans un endroit où une ventilation comme celle-ci n'est pas nécessaire, il est bon de savoir comment le faire.
Ça sent plus de devoirs. Ma très ancienne calculatrice graphique avait un programme principal comme celui-ci. Techniquement, la boucle de vérification de la déviation interne doit seulement courir à i ^ (1/2). Avez-vous besoin de trouver "tous" les nombres premiers compris entre 0 et L? L'autre problème majeur est que vos variables de boucle sont "int" alors que vos données d'entrée sont "longues", cela provoquera un débordement, ce qui fera que vos boucles ne s'exécuteront pas une seule fois. Corrige les variables de la boucle.
Un code de ligne en C #: -
Console.WriteLine(String.Join(Environment.NewLine,
Enumerable.Range(2, 300)
.Where(n => Enumerable.Range(2, (int)Math.Sqrt(n) - 1)
.All(nn => n % nn != 0)).ToArray()));
La réponse de Sieve of Eratosthenes n'est pas tout à fait correcte. Comme écrit, il trouvera tous les nombres premiers compris entre 1 et 1000000. Pour trouver tous les nombres premiers compris entre 1 et num, utilisez:
private static IEnumerable Primes01(int num)
{
return Enumerable.Range(1, Convert.ToInt32(Math.Floor(Math.Sqrt(num))))
.Aggregate(Enumerable.Range(1, num).ToList(),
(result, index) =>
{
result.RemoveAll(i => i > result[index] && i%result[index] == 0);
return result;
}
);
}
La valeur de départ de l'agrégat doit être comprise entre 1 et num car cette liste contiendra la liste finale des nombres premiers. Enumerable.Range(1, Convert.ToInt32(Math.Floor(Math.Sqrt(num)))) est le nombre de fois où la graine est purgée.
Forums ExchangeCore avez une bonne application de console répertoriée qui cherche à écrire les nombres premiers trouvés dans un fichier. Il semble que vous puissiez également utiliser ce même fichier comme point de départ, de sorte que vous n’aurez plus à chercher des nombres premiers à fournir un téléchargement de ce fichier avec tous les nombres premiers trouvés jusqu’à 100 millions, ce serait donc un bon début.
L'algorithme de la page prend également quelques raccourcis (nombres impairs et vérifie uniquement jusqu'à la racine carrée), ce qui le rend extrêmement efficace et vous permet de calculer des nombres longs.
Je sais que c’est une vieille question tranquille, mais après avoir lu ceci: Sieve of Eratosthenes Wiki
Voici comment je l'ai écrit en comprenant l'algorithme:
void SieveOfEratosthenes(int n)
{
bool[] primes = new bool[n + 1];
for (int i = 0; i < n; i++)
primes[i] = true;
for (int i = 2; i * i <= n; i++)
if (primes[i])
for (int j = i * 2; j <= n; j += i)
primes[j] = false;
for (int i = 2; i <= n; i++)
if (primes[i]) Console.Write(i + " ");
}
Dans la première boucle, nous remplissons le tableau de booléens avec true.
La deuxième boucle for commencera à 2 puisque 1 n'est pas un nombre premier et vérifiera si le nombre premier n'est toujours pas changé, puis affectera false à l'index de j.
la dernière boucle vient d’être imprimée quand il est premier.
Pour être tout à fait franc, certaines des solutions suggérées sont très lentes et sont donc de mauvaises suggestions. Pour tester un nombre unique comme étant primordial, vous avez besoin d'un opérateur de division/modulo, mais pour calculer une plage, vous n'avez pas à le faire.
Fondamentalement, vous excluez simplement les nombres qui sont des multiples des nombres premiers trouvés, car ils ne sont (par définition) pas des nombres premiers.
Je ne donnerai pas l'intégralité de la mise en œuvre, car ce serait trop facile, c'est l'approche en pseudo-code. (Sur ma machine, l'implémentation réelle calcule tous les nombres premiers dans un Sytem.Int32 (2 milliards) en 8 secondes.
public IEnumerable<long> GetPrimes(long max)
{
// we safe the result set in an array of bytes.
var buffer = new byte[long >> 4];
// 1 is not a prime.
buffer[0] = 1;
var iMax = (long)Math.Sqrt(max);
for(long i = 3; i <= iMax; i +=2 )
{
// find the index in the buffer
var index = i >> 4;
// find the bit of the buffer.
var bit = (i >> 1) & 7;
// A not set bit means: prime
if((buffer[index] & (1 << bit)) == 0)
{
var step = i << 2;
while(step < max)
{
// find position in the buffer to write bits that represent number that are not prime.
}
}
// 2 is not in the buffer.
yield return 2;
// loop through buffer and yield return odd primes too.
}
}
La solution nécessite une bonne compréhension des opérations au niveau des bits. Mais ça va et ça va plus vite. Vous pouvez également sécuriser le résultat du résultat sur disque, si vous en avez besoin pour une utilisation ultérieure. Le résultat de 17 * 10 ^ 9 numéros peut être sauvegardé avec 1 Go et le calcul de cet ensemble de résultats prend environ 2 minutes maximum.
C'est le moyen le plus rapide de calculer des nombres premiers en C #.
void PrimeNumber(long number)
{
bool IsprimeNumber = true;
long value = Convert.ToInt32(Math.Sqrt(number));
if (number % 2 == 0)
{
IsprimeNumber = false;
}
for (long i = 3; i <= value; i=i+2)
{
if (number % i == 0)
{
// MessageBox.Show("It is divisible by" + i);
IsprimeNumber = false;
break;
}
}
if (IsprimeNumber)
{
MessageBox.Show("Yes Prime Number");
}
else
{
MessageBox.Show("No It is not a Prime NUmber");
}
}
public static void Main()
{
Console.WriteLine("enter the number");
int i = int.Parse(Console.ReadLine());
for (int j = 2; j <= i; j++)
{
for (int k = 2; k <= i; k++)
{
if (j == k)
{
Console.WriteLine("{0}is prime", j);
break;
}
else if (j % k == 0)
{
break;
}
}
}
Console.ReadLine();
}
Premier Helper calcul très rapide
public static class PrimeHelper
{
public static IEnumerable<Int32> FindPrimes(Int32 maxNumber)
{
return (new PrimesInt32(maxNumber));
}
public static IEnumerable<Int32> FindPrimes(Int32 minNumber, Int32 maxNumber)
{
return FindPrimes(maxNumber).Where(pn => pn >= minNumber);
}
public static bool IsPrime(this Int64 number)
{
if (number < 2)
return false;
else if (number < 4 )
return true;
var limit = (Int32)System.Math.Sqrt(number) + 1;
var foundPrimes = new PrimesInt32(limit);
return !foundPrimes.IsDivisible(number);
}
public static bool IsPrime(this Int32 number)
{
return IsPrime(Convert.ToInt64(number));
}
public static bool IsPrime(this Int16 number)
{
return IsPrime(Convert.ToInt64(number));
}
public static bool IsPrime(this byte number)
{
return IsPrime(Convert.ToInt64(number));
}
}
public class PrimesInt32 : IEnumerable<Int32>
{
private Int32 limit;
private BitArray numbers;
public PrimesInt32(Int32 limit)
{
if (limit < 2)
throw new Exception("Prime numbers not found.");
startTime = DateTime.Now;
calculateTime = startTime - startTime;
this.limit = limit;
try { findPrimes(); } catch{/*Overflows or Out of Memory*/}
calculateTime = DateTime.Now - startTime;
}
private void findPrimes()
{
/*
The Sieve Algorithm
http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
*/
numbers = new BitArray(limit, true);
for (Int32 i = 2; i < limit; i++)
if (numbers[i])
for (Int32 j = i * 2; j < limit; j += i)
numbers[j] = false;
}
public IEnumerator<Int32> GetEnumerator()
{
for (Int32 i = 2; i < 3; i++)
if (numbers[i])
yield return i;
if (limit > 2)
for (Int32 i = 3; i < limit; i += 2)
if (numbers[i])
yield return i;
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
// Extended for Int64
public bool IsDivisible(Int64 number)
{
var sqrt = System.Math.Sqrt(number);
foreach (var prime in this)
{
if (prime > sqrt)
break;
if (number % prime == 0)
{
DivisibleBy = prime;
return true;
}
}
return false;
}
private static DateTime startTime;
private static TimeSpan calculateTime;
public static TimeSpan CalculateTime { get { return calculateTime; } }
public Int32 DivisibleBy { get; set; }
}
class CheckIfPrime
{
static void Main()
{
while (true)
{
Console.Write("Enter a number: ");
decimal a = decimal.Parse(Console.ReadLine());
decimal[] k = new decimal[int.Parse(a.ToString())];
decimal p = 0;
for (int i = 2; i < a; i++)
{
if (a % i != 0)
{
p += i;
k[i] = i;
}
else
p += i;
}
if (p == k.Sum())
{ Console.WriteLine ("{0} is prime!", a);}
else
{Console.WriteLine("{0} is NOT prime", a);}
}
}
}
Vous pouvez aussi faire ceci:
class Program
{
static void Main(string[] args)
{
long numberToTest = 350124;
bool isPrime = NumberIsPrime(numberToTest);
Console.WriteLine(string.Format("Number {0} is prime? {1}", numberToTest, isPrime));
Console.ReadLine();
}
private static bool NumberIsPrime(long n)
{
bool retVal = true;
if (n <= 3)
{
retVal = n > 1;
} else if (n % 2 == 0 || n % 3 == 0)
{
retVal = false;
}
int i = 5;
while (i * i <= n)
{
if (n % i == 0 || n % (i + 2) == 0)
{
retVal = false;
}
i += 6;
}
return retVal;
}
}
Cette solution affiche tous les nombres premiers compris entre 0 et 100.
int counter = 0;
for (int c = 0; c <= 100; c++)
{
counter = 0;
for (int i = 1; i <= c; i++)
{
if (c % i == 0)
{ counter++; }
}
if (counter == 2)
{ Console.Write(c + " "); }
}
U peut utiliser le concept de nombre premier normal doit seulement deux facteurs (un et lui-même) ..__ donc faire comme ça, moyen facile
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace PrimeNUmber
{
class Program
{
static void FindPrimeNumber(long num)
{
for (long i = 1; i <= num; i++)
{
int totalFactors = 0;
for (int j = 1; j <= i; j++)
{
if (i % j == 0)
{
totalFactors = totalFactors + 1;
}
}
if (totalFactors == 2)
{
Console.WriteLine(i);
}
}
}
static void Main(string[] args)
{
long num;
Console.WriteLine("Enter any value");
num = Convert.ToInt64(Console.ReadLine());
FindPrimeNumber(num);
Console.ReadLine();
}
}
}
Il existe des moyens très optimaux d'implémenter l'algorithme. Mais si vous en savez peu sur les mathématiques et que vous suivez simplement la définition de prime comme exigence: Un nombre divisible seulement par 1 et par lui-même (et rien d’autre), voici un code simple à comprendre Nombres.
public bool IsPrime(int candidateNumber)
{
int fromNumber = 2;
int toNumber = candidateNumber - 1;
while(fromNumber <= toNumber)
{
bool isDivisible = candidateNumber % fromNumber == 0;
if (isDivisible)
{
return false;
}
fromNumber++;
}
return true;
}
Comme chaque nombre est divisible par 1 et par lui-même, nous commençons par vérifier à partir de 2 jusqu'au nombre immédiatement avant. C'est le raisonnement de base.
Très similaire - d'un exercice à mettre en œuvre Sieve of Eratosthenes en C #:
public class PrimeFinder
{
readonly List<long> _primes = new List<long>();
public PrimeFinder(long seed)
{
CalcPrimes(seed);
}
public List<long> Primes { get { return _primes; } }
private void CalcPrimes(long maxValue)
{
for (int checkValue = 3; checkValue <= maxValue; checkValue += 2)
{
if (IsPrime(checkValue))
{
_primes.Add(checkValue);
}
}
}
private bool IsPrime(long checkValue)
{
bool isPrime = true;
foreach (long prime in _primes)
{
if ((checkValue % prime) == 0 && prime <= Math.Sqrt(checkValue))
{
isPrime = false;
break;
}
}
return isPrime;
}
}
static void Main(string[] args)
{ int i,j;
Console.WriteLine("prime no between 1 to 100");
for (i = 2; i <= 100; i++)
{
int count = 0;
for (j = 1; j <= i; j++)
{
if (i % j == 0)
{ count=count+1; }
}
if ( count <= 2)
{ Console.WriteLine(i); }
}
Console.ReadKey();
}