Probleme mit Schleifen in einem Programm, um Primzahlen zu finden - c #, Schleifen, Konsolenanwendungen, verschachtelte Schleifen

Hallo, ich hatte ein Problem damit, wieum das zum Laufen zu bringen. Es ist soll die erste x Anzahl der Primzahlen mit einer Benutzereingabe zum Setzen von x ermitteln. Dann werden alle in einem Array platziert, bevor die Ergebnisse gedruckt werden. Ich denke, ich habe ein Problem mit den Schleifen gemacht, da nach Eingabe der Benutzereingaben nichts passiert. Ich wäre dankbar, wenn irgendjemand vielleicht aufzeigen könnte, wo ich etwas falsch gemacht habe, und Vorschläge zur Behebung dieses Problems unterbreiten würde. Danke

static void Main(string[] args)
{
int max, i, count;
i = 0; // this is used to keep trck of how many primes have been added to the array
count = 0; // this is used to test each number
Console.WriteLine("This will work out the first x prime numbers with x being the number of prime numbers you want");
Console.WriteLine("Enter the number of prime numbers you want.");
max = Convert.ToInt32(Console.ReadLine());

int[] primes = new int[max];

while (i <= max)
{
while (count <= 9999)
{
if (count % 2 == 0 || count % 3 == 0 || count % 5 == 0 || count % 7 == 0 ) // tests if count number is a prime
{
if (count == 2 || count == 3 ||count == 5 ||count == 7 ) // ensures 2,3,5,7 are added to primes if neccesarry
{

primes[count] = count; //add to array
i++; // increments the count on the number of prime numbers
}
count ++; // increments the count
break;
}
else
{
primes[count] = count;
i++;
count ++;
}
}
}

Console.WriteLine("The first {0} prime numbers are ... ", max);
foreach(var item in primes)
{
Console.Write(item.ToString() + ", ");
}
}

Antworten:

Im Sinne des Versuchs, sich an den ursprünglichen Code zu halten, ist hier ein angepasster Ansatz Ihres Algorithmus, geändert um den Sieb von Eratosthenes:

• Das Sieb kann alle Primzahlen iterativ bestimmen, nur mit dem Wissen, dass 2 eine Primzahl ist.
• Die Ausgangsbedingung für die innere Schleife sollte sein, wenn wir die Quadratwurzel der getesteten Zahl überschreiten, mit unserer Liste der bekannten Primzahlen (nicht 9999 und break). Aufgrund der Definition einer Primzahl mit einer Liste von Primzahlen bis zu X können wir alle anderen Primzahlen bis X * X auflösen. (So können wir das Testen beenden, wenn wir die Quadratwurzel überschreiten, z. B. 2 und 3 4, 2 und 3 können bis zu 9 usw. auflösen. Das liegt auch daran, dass unsere Primzahlen bereits in aufsteigender Reihenfolge angeordnet sind.
• Ich habe die ursprünglichen Variablen beibehalten, d.h. count ist der nächste getestete Kandidat, i ist der aktuelle Index der Primzahl, max ist obere Grenze zu bevölkern.
• Die erste Primzahl 2 muss hart codiert sein (d. H. primes[0] = 2, der nächste Primzahlindex i wird 1 sein, und die erste Kandidatennummer, die wir danach überprüfen müssen, ist 3.

// We do need to hard code that 2 is a prime number. Everything else can be derived
primes[0] = 2;
i = 1;
count = 3;

// i.e. stop when we get the required number of primes
while (i < max)
{
// Indicator to stop testing this candidate if we find a factor
bool foundFactor = false;
// Start off each primality test from the start of our primes array
var primeIndex = 0;

// Try and find a factor of "count" with our known primes
while (!foundFactor && primeIndex < i)
{
// We can stop after the square root. Multiplication is faster than sqrt
if (primes[primeIndex]*primes[primeIndex] > count)
break;
// If the candidate number
if (count % primes[primeIndex] == 0)
foundFactor = true;
primeIndex++;
}
if (!foundFactor)
{
primes[i] = count;
i++;
}

count++;
}

Wie unter dem Link von @Massimo, ist der obige Brute-Force-Mechanismus äußerst ineffizient. Eine Verbesserung ist das "Rad der 6", auf das im Wiki-Artikel verwiesen wird - after count=6Mit dem Rad von 6 wird jeder Kandidatensatz in 6er-Reihen getestet, und alle Vielfachen von 2 und 3 können sofort eliminiert werden. Andere größere Räder sind ebenfalls möglich.

Erstens ist dies nicht der Weg, um zu testen, ob eine Zahl eine Primzahl ist, aber dann ist der Zyklus alles andere als falsch.

Wenn Sie ein Maximum setzen, das höher ist als die Anzahl der Primzahlen unter 9999, wird es für immer in der äußeren Schleife durchlaufen.

Im Wiki findest du erste Einblicke: http://en.wikipedia.org/wiki/Primality_test

Um meine Aussage zu überprüfen, können Sie einige Konsolenausgaben in die äußere Schleife einfügen und sich selbst überzeugen