Sur le problème d'optimisation d'algorithme de trouver la somme des nombres premiers étant donné un plus grand nombre (1 milliard)

1. Donner d'abord un cas sur notre manuel (base de conception des scores en langage C)

#include <iostream>
#define Num 100000
using namespace std;


int main()
{
	int n=Num,k;
	for(int i=2;i<=n;i++)
	{
		for(int j=2;j<=i;j++)
		{
			if(i%j==0 && i!=j) break;
			if(i%j==0 && i==j)k=k+i;
		}
		//cout<<i<<endl;
	}
	cout<<k;

	return 0;
}

Je ne pense pas que cela puisse être appelé un algorithme. Je n’ose vraiment pas le tester avec 1 milliard, je vais donc passer les prochaines séries de tests.

100 000	2.442	Valeur: 454396537
500 000	50,89 s	Valeur: 132431603
1 000 000	1 million j'ai peur de tester	Pas testé

---

2. Inspiration d'autres idées

Voyant que cet algorithme se sent vraiment fort, en particulier lors du calcul de très grands nombres.

Le principe est, regardez la série de nombres suivante, commencez par 2, supprimez tous les multiples de 2, puis supprimez tous les multiples de 3, puis supprimez les multiples de 5, 5 ... Cela peut effacer de nombreux nombres.

 

2 3 4  5 6  7 8 9 10 11 12 13 14 15 16 17 .....

#include <iostream>
using namespace std;
#define Max_Num 100000

char isPrime[Max_Num+10]; //1为和数   0为质数 
int main(){
	for(int i=1;i<=Max_Num+10;i++)
		isPrime[i]=0; 
	int k=0;	
	for(int i=2;i<=Max_Num;i++)
		if(isPrime[i]==0)
		{k+=i; 
			for(int j=i*2;j<=Max_Num;j+=i)
				isPrime[j]=1;//1的就是 和数 
}
					
	//for(int i=2;i<=Max_Num;i++)
		
	//for(int i=2;i<=Max_Num;i++)
		//if(isPrime[i]==1)cout << i<<" ";
	
	//for(int i=Max_Num;true;i--)
		//if(isPrime[i]==0)
		
	//	{	cout<<i;
	//		break;	} 
	cout << k;
	
	
}

Publier également les résultats des tests

100 000	0,03281 s	Valeur: 454396537
500 000	0,04388 s	Valeur: 132431603
1 000 000	0,05515 s	Valeur: 3190663655
10 000 000	0,4939s	La valeur est hors de la plage int
100 000 000	4.282s	La valeur est hors de la plage int

 

Quand je l'ai testé à 10 000 000, la somme des nombres premiers devant était hors de la plage de int, mais je veux vous montrer le résultat du calcul.

J'ai donc eu une idée, tout le monde peut étendre cette réflexion au-delà de la portée de int,

Tout d'abord, vous ne pouvez pas utiliser la définition de int k; ce type de variable, car la valeur calculée de cette manière est hors plage, elle sera écrite dans la mémoire (int) suivante. (Possiblement) faire planter le programme, vous pouvez jeter un oeil à ma solution

Faites attention aux remarques détaillées:

int k[20]={0,0,0,0,0,0,0,0,0,0,0,0,0};
//定义个比较长的数组  来存放这个超出一个 int 范围的值
//超出的值会写入到下一个内存地址
//因为数组的内存是连续的，所以我定义这个较长的数组来存放这个 超大数字

int *p=k;
//定义个指针  指向这个数字的首地址




//初始化数组，令其全部为0

//然后从首地址开始写出
//首地址为p

 

10 000 000	0,4939s	Valeur: 3,574,358,836
100 000 000	4.282s	Valeur: 6,851,376,204
1 000 000 000	47,92 s	valeur:

Ps: Maintenant, je soupçonne qu'il y a un problème avec ma méthode, car lorsque j'utilise la méthode ci-dessus pour regarder la somme des nombres premiers à moins d'un milliard, la valeur écrite dans la mémoire est en fait inférieure à 100 millions. Je ne connais pas encore le problème. Où est-ce? Tout le monde, s'il vous plaît voir s'il y a un problème avec ma pensée, et le signaler