contenu
Définition des nombres premiers (nombres premiers)
Un nombre naturel supérieur à 1, qui n'est pas divisible par d'autres nombres naturels que 1 et lui-même, est
质数（也叫素数）appelé un nombre composé ; sinon, il est appelé un nombre composé. 0 et 1 ne sont ni premiers ni composés, et le plus petit nombre premier est 2.
La méthode de jugement des nombres premiers (1) est couramment utilisée mais peu efficace
Cette méthode est plus facile à comprendre et plus facile à penser.
Mais cette méthode n'est pas très efficace.
//判断质数（素数）方法一
#include <stdio.h>
int main()
{
int n,i;
printf("请输入大于等于2的整数：");
scanf("%d",&n);
putchar('\n');
if(n<2)
{
printf("%d不是质数（素数）！\n");
}
else{
for(i=2;i<n;i++)
{
if(n%i==0) //如果有大于2的可以除尽的数，则不是素数
break;
}//注意这里的i是否被除尽，若除尽了，则通过break跳出for循环后直接通过下面的if判断（i<n）输出n不是素数
//若除不尽，那么for循环中的break则执行不到，亦即整个for循环都执行了，直到i++ = n不符合循环条件时才跳出循环，执行下面的else 即打印n是素数
printf("(i这时是：%d)\n\n",i); //测试 意为看看第一个不符合的（可以除尽的）数是多少？
if(i<n) //即 存在2~(n-1)之间有因数
{
printf("%d不是素数（质数）！\n",n);
}
else
printf("%d是素数（质数）！\n",n);
}
return 0;
}
Test :
De même, le processus de traitement si ce qui précède est un nombre premier peut également être encapsulé dans une fonction, ce qui signifie la même chose.
//将上述方法封装为函数Prime
#include <stdio.h>
int Prime(int n); //函数原型声明
int main()
{
int n;
printf("请输入大于等于2的整数：");
scanf("%d",&n);
putchar('\n');
Prime(n); //调用函数Prime来处理该数是不是素数
return 0;
}
int Prime(int n) //函数定义
{
int i;
if(n<2)
{
printf("%d不是质数（素数）！\n");
}
else{
for(i=2;i<n;i++)
{
if(n%i==0) //如果有大于2的可以除尽的数，则不是素数
break;
}
printf("(i这时是：%d)\n\n",i); //测试 意为看看第一个不符合的（可以除尽的）数是多少？
if(i<n) //即 存在2~(n-1)之间有因数
{
printf("%d不是素数（质数）！\n",n);
}
else
printf("%d是素数（质数）！\n",n);
}
}
Puis testez à nouveau :
Méthode pour juger des nombres premiers (2) Emprunter des fonctions mathématiques est plus efficace
"L'emprunt de fonctions mathématiques" mentionné ici n'est utilisé que pour trouver une racine carrée. L'idée centrale n'est pas d'utiliser des fonctions mathématiques pour trouver des nombres premiers.
En fait, il est toujours jugé en prenant le reste, mais le nombre de jugements requis ici n'est pas tellement.
//判断素数方法二：求数n的 算术平方根p，并对<=p的所有数 取余看是否为0。
//若有为0的（即有除尽的），则数n不是素数，否则n是素数
#include <stdio.h>
#include <math.h>
int main()
{
int n,i,k;
printf("请输入大于等于2的整数：");
scanf("%d",&n);
putchar('\n');
k=sqrt(n); //即对n开平方
printf("对%d开平方后得到的k是:%d\n",n,k); //测试，看对n开方得到的k是多少
putchar('\n');
for(i=2;i<=k;i++){
if(n%i==0)
break;
}
printf("(此时，i是%d)\n",i);//测试，亦为看看此时 第一个满足取余等于0 的因子是多少
putchar('\n');
if(n<2) //当输入的n小于2时，直接 输出 n不是 素数
{
printf("%d不是素数！\n",n);
}
else if(i<=k){
printf("%d不是素数！\n",n);
}
else{
printf("%d是素数！\n",n);
}
return 0;
}
L'épreuve est la suivante :
On peut voir que le nombre k obtenu après élévation au carré de 99 est 9, car k définit un nombre entier.
J'ai choisi les mêmes nombres que le test de la méthode 1, et les résultats du test étaient les mêmes. Cette méthode est donc également correcte. Quant à la méthode à choisir, cela dépend de ce que pense le lecteur.
Alors pourquoi la deuxième méthode n'a-t-elle pas à juger autant de fois en prenant le reste ? En d'autres termes, pourquoi est-il possible de déterminer si le nombre n est un nombre premier lorsque i est inférieur ou égal à k ? Pensez-y de cette façon : lorsque vous jugez le nombre n 不是素数, s'il existe un nombre i inférieur ou égal à k, qui peut diviser n de manière égale, alors n n'est certainement pas un nombre premier. (Parce que les facteurs des nombres premiers ne sont que 1 et lui-même !)
Quant à juger que n est un nombre premier, pensez de cette façon, l'opposé d'un nombre premier est 合数, par exemple, 4 est un nombre composé (en plus de 1 et lui-même, il y a d'autres facteurs, donc ce nombre est appelé un composé numéro).
Pour un nombre n, s'il se décompose en n=a*b, alors l'un de a et b doit être supérieur ou égal au radical n, et l'autre inférieur ou égal au radical n, c'est-à-dire disons, un nombre composé n doit avoir un facteur inférieur ou égal à égal à la racine de n. Donc pour un nombre n, il suffit de vérifier s'il a un facteur inférieur ou égal à la racine du nombre n (vérifier le facteur inférieur ou égal à n réduit le nombre de boucles, ce qui est aussi la raison de la simplification)
Par exemple, 36 est un nombre composé. La racine carrée de 36 est 6. De plus, 36 a plusieurs facteurs, tels que 1, 2, 3, 4, 6, 9 et 36. Parmi eux, 1, 2, 3 et 4 sont tous inférieurs à 6.
36 = 4 * 9 = 6 * 6. Parmi eux, 4<6 et 9>6. C'est pourquoi on dit que "pour un nombre n, s'il se décompose en n=a*b, alors l'un de a et b doit être supérieur ou égal à la racine n, et l'autre est inférieur ou égal à la racine n, c'est-à-dire qu'un nombre composé n doit être Il y a un facteur inférieur ou égal à la racine de n".
Donc, c'est pourquoi, pour juger si un nombre est un nombre premier, pourquoi vous pouvez utiliser la deuxième méthode, c'est-à-dire qu'il vous suffit de juger s'il existe un facteur inférieur ou égal à sa racine carrée, tout, puis le nombre n n'est pas un nombre premier. Inversement, le nombre n est un nombre premier.