如何执行“数百万次计算”？

Question

我的代码贴在下面。当我运行这个程序时，它一直在计算。我使用的是旧的 Turbo C++ 编译器。这样的程序需要多长时间才能执行？我等了大约 5 分钟，但没有任何输出。

/*The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.

Find the sum of all the primes below two million.
*/
#include<stdio.h>
#include<conio.h>
#define TWO_MILLION 2*1000*1000
int IsPrime(long unsigned int num);
int main()
{
    long unsigned int i,sum=0;
    clrscr();
    for(i=2;i<TWO_MILLION;i++)
    {
        if(IsPrime(i))
        sum+=i;
    }
    gotoxy(25,25);
    printf("%ld",sum);
    getch();
    return 0;
}
int IsPrime(long unsigned int num)
{
    int flag=1;
    long unsigned int i;
    for(i=2;i<num;i++)
    {
        if(num%i==0)
        {
            flag=0;
            break;
        }
    }
    return flag;
}

Answer 1

您不是在进行数百万次计算，而是在进行数万亿次计算。

IsPrime 将在 O(n) 时间内运行，也就是说，它将执行 200 万条指令来确定单个数字。做这种事情需要两百万的时间太长了。

要做到这一点，你真的想使用类似的东西：http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes，它可以更有效地确定特定范围内的所有素数。

Answer 2

执行这样的程序需要多长时间？

这完全取决于您的平台。我怀疑你正在执行 ~(200 万)^2 次运算 (~4 万亿次) 计算，很长一段时间。

有更好的方法来执行您正在执行的操作 - 例如，要检查素数，您只需检查数字的平方根，而不是一直检查数字本身。更不用说可能有一个动态编程解决方案可以比这快得多。

Answer 3

正如其他人所说，这将需要很长时间。另一种有趣的方法是埃拉托色尼筛法。您可以在以下位置阅读：

http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes

基本上，您使用数字 2...2 百万初始化一个数组。尚未处理的最小数字是素数。然后，从数组中删除该数字的所有倍数并继续。它的运行速度会比你现有的快得多。

Answer 4

另类答案

gotoxy(25,25);

您是否以文本模式运行程序？如果文本屏幕只有80 x 25，并且如果第25行被其他东西遮挡，那么您可能不会在文本屏幕上看到任何变化。

Answer 5

正如其他人所说：检查实施的限制

如果TurboC++ 具有，则那些实现限制在该标头中定义了相应的宏

#include <limits.h>
#include <stdio.h>
int main(void) {
    printf("int goes from %d to %d.\n", INT_MIN, INT_MAX);
    printf("long goes from %ld to %ld.\n", LONG_MIN, LONG_MAX);
    return 0;
}

如果失败，您需要自己“计算”限制。我正在切换到unsigned，因为它们没有溢出问题，我只需要“计算”上限（下限为0）

#include <stdio.h>
int main(void) {
    unsigned u;
    unsigned long lu;

    u = -1; lu = -1;
    printf("unsigned ints go all the way to %u\n", u);
    printf("unsigned longs go all the way to %lu\n", lu);
    return 0;
}

---

在我的系统上，第一个程序输出

int 从 -2147483648 到 2147483647。
long 从 -9223372036854775808 到 9223372036854775807。

第二个程序输出

无符号整数一直到 4294967295
unsigned longs 一直到 18446744073709551615

Answer 6

除了“史诗”之外，仍然没有关于常量的评论/答案......

#define TWO_MILLION 2*1000*1000

这很糟糕。当您稍后更改该值时，您的名称内容不匹配：

#define TWO_MILLION 5*1000*1000

或者你把它重命名为

#define FIVE_MILLION 5*1000*1000

并且需要在您使用过它的任何地方进行更改。不要在内容之后命名你的常量，这只会把你的幻数变成幻名。以它们的含义命名它们，例如MAX_NUMBER UPPER_LIMIT RANGE_TO_TEST 或任何最适合的。

Answer 7

您也可以使用筛子方法来执行此操作，这些方法并不比您使用的复杂得多。这个想法是选择前 n 个连续的素数并用它们来构造一个筛子。我在my answer 中对另一个问题进行了讨论（带有证明），Sheldon L. Cooper 在his 中提供了一个实现。我认为他这样做没有得到足够的支持（我已经得到了“很好的答案”，所以也许你可以帮助他。

所以在计算完筛子数后，您只需要测试与筛子对齐且小于n 的平方根的数字的可分性。

Answer 8

这可能需要非常很长时间才能运行。

添加此以查看您的进度（尽管需要更长的时间）：

for(i=2;i<num;i++)
    {
        if(num%i==0)
        {
            flag=0;
            printf("%d,", num); /* <== show the prime */
            break;
        }
    }

编辑

正如其他人指出的那样，这是计算素数的最慢方法。也许您的任务的目的是让您查找（并实施）更快的任务？

Answer 9

您的程序导致整数溢出，您可以使用 long long 来修复它。

此外，您检查数字是否为素数的算法也不是很好。另一种同样简单的方法是将数字 2 测试为数字的平方根。您只需检查数字的平方根即可确定它是否为素数。

Answer 10

一个简单的改变会告诉你你的程序运行得有多快，以及它需要做多少工作。每 100 次迭代就可以轻松打印出您的状态。 （或者您可以将其设置为 1000 或 10000 次迭代。）

---

认识到您可以将IsPrime 中的循环速度加倍。
勾选2后，只需要查奇数，可以用i+=2代替i++前进。

如果您关心速度，为什么要花这么多时间检查偶数？ （请注意，一旦开始只做奇数，您还需要将输出测试更改为奇数）

您也可以在main 中加倍循环速度，同时避免那里的偶数。 （再一次，你必须特例 2，然后使用 i+=2，从 3 开始得到 3、5、7、9....）

通过使IsPrime 中的循环运行速度提高一倍，并使main 中的循环运行速度提高一倍，这将使您的程序运行速度4X。 （如果之前需要一个小时，现在需要 15 分钟。）

---

您可以进行的另一大速度改进是仅将循环运行到sqrt(num)，而不是num

由于我讨厌引入浮点函数，例如 sqrt，因此我建议使用一个近似值，它会在通过 sqrt 边界的 100 次迭代内停止，并且还会定期显示状态更新。

if (num%2 == 0)
{
    flag=0;
    return flag;
}

/* Now that we checked 2, we only need to check odd numbers from now on. */
for(i=3;i<num;i+=2)
{
    if (i%101 == 0)
    {
        printf("i is %d out of %d\n", i, num);
        if (i*i > num)
        {
            break;  /* If you pass the sqrt boundary, quit. */
        }
    }

    if(num%i==0)
    {
        flag=0;
        break;
    }
}

---

P.S. 我把这段代码放到了一个 C# 项目中（小移植）。 当然，它现在运行在 64 位操作系统上，具有更好的编译器和 2.8GHz CPU。
不到 20 秒就跑完了。