Drucken Sie die Primzahlen von 0 bis 10.000

Im derzeit versuchen, erstellen Sie ein Programm, das druckt die Primzahlen von 0 bis 10.000 über nur für,während und ifs. Ich habe dieses Programm aber nicht läuft

static void Main(string[] args)
    { 
        for (int x = 2; x < 10000; x++)
        { 
            for (int y = 1; y < x; y++)
            { 
                if (x % y != 0)
                {
                    Console.WriteLine(x); 
                }  
            }
            Console.ReadKey();
        }

Ich weiß nicht, wo das problem ist und auch wenn das für den innen-setzt.

Wenn Sie nicht vertraut mit der Verwendung von Breakpoints zu gehen Zeile für Zeile durch ein Debug-build, dann ist dies eine gute Gelegenheit, es auszuprobieren
Ich kann kein boolean-Datentyp.
Sie sind bereits mit 3 Boolesche Werte (in form von Bedingungen) im snippet.

InformationsquelleAutor Santiago Mendoza Flores | 2015-03-04

c#do-while for-loop numbers primes

3

Versuchen Sie diese nicht mit bool variable!!!:
```
static void Main(string[] args)
{
    for (int x = 2; x < 10000; x++)
    {
        int isPrime = 0;
        for (int y = 1; y < x; y++)
        {
            if (x % y == 0)
                isPrime++;

            if(isPrime == 2) break;
        }
        if(isPrime != 2)
           Console.WriteLine(x);

        isPrime = 0;
    }
    Console.ReadKey();
}
```
Überprüfen Console.ReadKey(); sollte es nach oben for - Schleife, können Sie sogar Bedingung für die oberen for Beute mit <= seit 10000 müssen auch prüfen, ob prime Zustand.

Das problem hier ist, dass ich nicht verwenden können, bool; nur das, was ich sagte.
Warum nicht bool? versuchen Sie es mit Linq Verlängerung oder andere Lösung dann, in diesem Fall nur die Verwendung von flag-variable arbeiten.
Es ist für eine Hausaufgabe und die Herausforderung ist es, ohne Verwendung von bool.
Check Antwort ohne Verwendung von bool-Variablen. Ref sanfoundry.com/csharp-program-prime-number-factor
Ich denke, du meintest if(isPrime != 2) als Richter für Primzahl

InformationsquelleAutor Ankush Madankar

Unten ist der effizienteste Weg, um Druck Primzahlen zwischen 0 und 10000

using System.IO;
using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Below are prime numbers between 0 and 10000!");
        Console.WriteLine(2);
        for(int i=3;i<=10000;i++)
        {
            bool isPrime=true;
            for(int j=2;j<=Math.Sqrt(i);j++)
            {
                if(i%j==0)
                {
                    isPrime=false;
                    break;
                }
            }
            if(isPrime)
            {
                Console.WriteLine(i);
            }
        }
    }
}

InformationsquelleAutor malkam

Gibt es einen Grund, dass Sie die Konsole.ReadKey(); innerhalb der Schleife?

Sollten Sie setzen, dass aus der Schleife, es sei denn, drücken Sie die Taste während der loop.

static void Main(string[] args)
{
    for (int x = 2; x < 10000; x++)
    {

        for (int y = 1; y < x; y++)
        {

            if (x % y != 0)
            {
                Console.WriteLine(x);
            }
        }
    }
    Console.ReadKey();
}

Und wahrscheinlich, dass code ist nur print-Menge von x an.
Sie sollten, um es zu beheben.

InformationsquelleAutor Seung Hyun Ra

2

Das erste problem ist, dass x % 1 wird immer null sein, zumindest für nicht-null -x. Sie brauchen, um den test zu starten (innere) Schleife an einem und, für Effizienz, zu stoppen, wenn Sie überschritten haben, die Quadratwurzel der Zahl selbst, wenn n einen Faktor f wo f > sqrt(n) würden Sie bereits gefunden haben der Faktor n /f.

Das zweite problem ist, dass Sie schreiben, eine Kandidaten-Nummer jedes mal, wenn der Rest null ist. So, da 15 % 4 ist drei, er wird ausgegeben, trotz der Tatsache, dass fünfzehn ist sehr viel eine nicht-Primzahl. Es wird auch ausgegeben, bei 15 % 2, 15 % 4, 15 % 6, 15 % 7, und so weiter.

Den normalen (naiven) Algorithmus für prime-Tests:
```
# All numbers to test.

foreach number 2..whatever:
    # Assume prime, check all numbers up to squareroot(number).

    isPrime = true
    foreach test 2..infinity until test * test > number:
        # If a multiple, flag as composite and stop inner loop.

        if number % test == 0:
            isPrime = false
            exit foreach
        end
    end

    # If never flagged as composite, output as prime.

    if isPrime:
        output number
end
```
InformationsquelleAutor paxdiablo

Hier ist einfache Logik zu Drucken Prime Nicht für jede Obere Grenze.

Input : 10-Ausgang : 2 , 3 , 5 ,7

namespace PurushLogics
{
    class Purush_PrimeNos
    {
        static void Main()
        {
            //Prime No Program
            bool isPrime = true;
            Console.WriteLine("Enter till which number you would like print Prime Nos\n");
            int n = int.Parse(Console.ReadLine());
            Console.WriteLine("Prime Numbers : ");
            for (int i = 2; i <= n; i++)
            {
                for (int j = 2; j <= n; j++)
                {

                    if (i != j && i % j == 0)
                    {
                        isPrime = false;
                        break;
                    }

                }
                if (isPrime)
                {
                    Console.Write("\t" + i);
                }
               isPrime = true;
            }
            Console.ReadKey();
        }
    }      
}

InformationsquelleAutor Purushoth

Hier ist mein code, wo Sie können erstellen und drucken Sie die Primzahlen zwischen zwei zahlen (zwischen string_starting_number und string_last_number). Den niedrigsten Wert für die string_starting_number ist 0 und der höchste mögliche Wert für string_last_number ist dezimal.MaxValue-1=79228162514264337593543950334 und nicht 79228162514264337593543950335, weil der decimal_a++ Befehl innerhalb einer for-Schleife, die zu einem überlauf-Fehler.

Beachten Sie, dass Sie sollten die Eingabe der Werte in string-Typ in string_starting_number und in string_last_number.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace GeneratingPrimeNumbers
{
    class Program
    {
        static void Main(string[] args)
        {
            string string_starting_number = "1"; //input here your choice of starting number
            string string_last_number = "10"; //input here your choice of last number
            decimal decimal_starting_number = Convert.ToDecimal(string_starting_number);
            decimal decimal_last_number = Convert.ToDecimal(string_last_number);
            string primenumbers = "";
            ulong ulong_b;
            ulong ulong_c;
            if (decimal_starting_number <= ulong.MaxValue)
            {
                ulong ulong_starting_number = Convert.ToUInt64(decimal_starting_number);
                ulong ulong_last_number;
                if (decimal_last_number > ulong.MaxValue)
                {
                    ulong_last_number = ulong.MaxValue;
                }
                else
                {
                    ulong_last_number = Convert.ToUInt64(decimal_last_number);
                }
                if (ulong_starting_number == 0 || ulong_starting_number == 1 || ulong_starting_number == 2 || ulong_starting_number == 3)
                {
                    primenumbers = 2 + " " + 3;
                    ulong_starting_number = 5;
                }
                if (ulong_starting_number % 2 == 0)
                {
                    ulong_starting_number++;
                }
                ulong ulong_a;
                for (ulong_a = ulong_starting_number; ulong_a <= ulong_last_number; ulong_a += 2)
                {
                    ulong_b = Convert.ToUInt64(Math.Ceiling(Math.Sqrt(ulong_a)));
                    for (ulong_c = 3; ulong_c <= ulong_b; ulong_c += 2)
                    {
                        if (ulong_a % ulong_c == 0)
                        {
                            goto next_value_of_ulong_a;
                        }
                    }
                    primenumbers = primenumbers + " " + ulong_a;
                    next_value_of_ulong_a:
                    {
                    }
                }
            }
            if (decimal_last_number > ulong.MaxValue)
            {
                string ulong_maximum_value_plus_two = "18446744073709551617";
                if (decimal_starting_number <= ulong.MaxValue)
                {
                    decimal_starting_number = Convert.ToDecimal(ulong_maximum_value_plus_two);
                }
                if (decimal_starting_number % 2 == 0)
                {
                    decimal_starting_number++;
                }
                decimal decimal_a;
                for (decimal_a = decimal_starting_number; decimal_a <= decimal_last_number; decimal_a += 2)
                {
                    ulong_b = Convert.ToUInt64(Math.Ceiling(Math.Sqrt(ulong.MaxValue) * Math.Sqrt(Convert.ToDouble(decimal_a / ulong.MaxValue))));
                    for (ulong_c = 3; ulong_c <= ulong_b; ulong_c += 2)
                    {
                        if (decimal_a % ulong_c == 0)
                        {
                            goto next_value_of_decimal_a;
                        }
                    }
                    primenumbers = primenumbers + " " + decimal_a;
                    next_value_of_decimal_a:
                    {
                    }
                }
            }
            Console.WriteLine(primenumbers);
            Console.ReadKey();
        }
    }
}

InformationsquelleAutor John Kennedy Mendoza Aquino

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.