Question

我为自己制作了一个主要的检查程序并且它完美地工作，然而，在输入一百万个数字后它崩溃了。

这是我的代码：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <windows.h>

/* Prototypes */
void primeChecker(int num1, int num2);

int main() {
    int startNumber = 1000;
    int endNumber = 1000000;

    primeChecker(startNumber, endNumber);

    /* Stops the program */
    return (0);
}

void primeChecker(int num1, int num2) {
    int isPrime, i, count = 0;

    int number1 = num1;
    int number2 = num2;

    while (number1 <= number2) {
        /* Assume isPrime is true */
        isPrime = 1;

        for (i = 2; i < number1 && isPrime; i++) {
            if (number1 % i == 0) {
                isPrime = 0;
            }
        }
        if (isPrime == 1) {
            count++;
            //printf("%d ", num1);
        }
        number1++;
    }
    printf("There are %d prime numbers between %d and %d", count, num1, num2);
    printf("\n");
}

有人知道问题是什么吗？

Answer 1

您的代码没有任何问题。您的算法只是非常无效，因此您的程序将需要几分钟才能运行（在我的计算机上花了2分钟，您的程序可能会慢一点。）

如果更改行

，您可以看到这一点

//printf("%d ", num1);

，我认为，你一直在使用

进行调试

printf("%d\n", number1);

因为number1实际上是循环中变化的数字（num1在整个函数调用中是恒定的）。然后，该程序将慢慢地将所有素数从1,000计数到1,000,000。

Answer 2

我不相信您的代码会导致崩溃，因为您的算法效率低下，所以只需几分钟即可运行。

要改善代码的运行时间，请尝试编写更有效的主要检查算法。例如，对于primeChecker函数，只有mod number1，所有素数小于sqrt（number1），这足以确定其质数。然后，这将要求您检查从2,3,5，...等开始的所有数字的初始值，并生成一个素数数组，直到number2，但总体上会在运行时为您节省更多。

Answer 3

#include <stdio.h>
#include <stdlib.h>

typedef struct prime_int* p_t;

struct prime_int
{
  int num;
  p_t next;
};
//this to create a list of prime integer
p_t new_pt(int n, p_t p)
{
    p_t t = malloc(sizeof(struct prime_int));
    t->num = n;
    t->next = p;
    return t;
}
//this to test the number by dividing it by all the prime number
//between 2 and its middle if it cannot be divide it is prime
// and we add it to the list of integer
void prime(int n, p_t p){
    p_t new_pt(int v, p_t k);
    int b = n/2;
    p_t t = p, tmp = NULL;
    while(t){
            if(t->num > b) break;
            else
            {
                tmp = t;
                if(n%(t->num))t = t->next;
                else return;
            }
          }
    if(!tmp)return;
    while(tmp->next)tmp=tmp->next;
    tmp->next = new_pt(n, NULL);
}
//just to print all the prime number and free the previously 
//allocated data and print the total number of prime integer
int affiche(p_t p)
{
    int i = 0;
    p_t tmp = NULL;
    while(p)
    {
        printf("%d ", p->num);
        i++;
        tmp = p;
        p = p->next;
        free(tmp);
    }
    return i;
}

int main(){
   int affiche(p_t p);
   int i = 3;
   void prime(int n, p_t p);
   p_t new_pt(int n, p_t p);
   p_t deb = new_pt(2,new_pt(3, NULL));
   while(1)
   {
        prime(i,deb);
        if(i>1000000)break;
        i+=2;
   }
   i = affiche(deb);
   printf("\n total number of prime integer %d", i);
   return 1;
}

执行后

素数的总数78498

进程返回1（0x1）执行时间：50.575 s

Answer 4

这绝对不是最有效的方法，执行需要相当长的时间，但这是我的解决方案。 Prime使用简单的增量和模式检查计算数字是否为素数。如果数字是素数，则返回1或不返回0（将被添加到计数中）。我在这里使用uint64_t的原因是它最初设计用于处理更大的数字，但如果需要，可以随意将其更改为int。

#include <stdio.h>
#include <inttypes.h>

int prime(uint64_t N){
    uint64_t i;
    for(i=2;i<=N/2;++i){
        if(N%i==0){ return 0; }
    } return 1;
}

int main(){
  int i, count=0;
  for ( i = 1000; i < 1000000; i++ )
    count+=prime(i);

  printf("Count is %d.\n", count);
}

伯爵是78330。

输入1,000,000个号码后程序没有运行？

4 个答案: