打印从 0 到 10,000 的素数答案

【问题标题】：Print the prime numbers from 0 to 10,000打印从 0 到 10,000 的素数
【发布时间】：2023-04-06 02:37:01
【问题描述】：

我目前正在尝试创建一个仅使用 for、do while 和 ifs 打印从 0 到 10,000 的素数的程序。我创建了这个程序，但它没有运行

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();
        }

我不知道问题出在哪里，也不知道 for inside 是否重置。

【问题讨论】：

如果您不熟悉使用断点逐行遍历调试构建，那么这是一个尝试的好机会
我不能使用布尔类型的数据。
您已经在 sn-p 中使用了 3 个布尔值（以条件的形式）。

标签： c# for-loop numbers primes do-while

【解决方案1】：

第一个问题是x % 1 将总是为零，至少对于非零x。您需要从一个开始测试（内部）循环，并且为了提高效率，当您超过数字本身的平方根时停止 - 如果n 有一个因子f 其中f > sqrt(n)，您将已经找到因子n / f。

第二个问题是每次余数非零时你都会写出一个候选数。所以，因为15 % 4 是三，所以尽管十五是非素数，它还是会被输出。它还将在15 % 2、15 % 4、15 % 6、15 % 7 等处输出。

素数测试的正常（朴素）算法是：

# 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

【讨论】：

【解决方案2】：

试试这个没有bool变量！！！：

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();
}

检查Console.ReadKey();它应该在上for循环之后，你甚至可以用<=改变上for战利品的条件，因为10000也需要检查prime条件。

【讨论】：

这里的问题是我不能使用 bool;只有我说的。
@SantiagoMendozaFlores 为什么不使用 bool？然后尝试使用Linq 扩展或其他解决方案，在这种情况下，仅使用标志变量将起作用。
这是一个家庭作业，挑战是在不使用 bool 的情况下完成它。
@SantiagoMendozaFlores 检查答案而不使用 bool 变量。参考sanfoundry.com/csharp-program-prime-number-factor
我猜你的意思是if(isPrime != 2)作为素数的法官

【解决方案3】：

你有什么理由把 Console.ReadKey();循环内？

除非在循环中按键，否则你应该把它放在循环之外。

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();
}

并且可能该代码只是打印很多 x。你应该修复它。

【讨论】：

【解决方案4】：

下面是打印 0 到 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);
            }
        }
    }
}

【讨论】：

【解决方案5】：

这是打印任意上限的 Prime No 的简单逻辑。

输入：10 输出：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();
        }
    }      
}

【讨论】：

【解决方案6】：

这是我的代码，您可以在其中生成和打印两个数字之间的质数（在 string_starting_number 和 string_last_number 之间）。 string_starting_number 的最低可能值为 0，而 string_last_number 的最高可能值为 decimal。MaxValue-1=79228162514264337593543950334 而不是 79228162514264337593543950335，因为 for 循环中的 decimal_a++ 命令会导致溢出错误。

注意在string_starting_number和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();
        }
    }
}

【讨论】：