Tabla de contenido
¿Qué son los números primos (números primos)?
Los números primos también se llaman números primos. Un número natural mayor que 1, excepto 1 y él mismo, no es divisible por otros números naturales llamados números primos; de lo contrario, se llama número compuesto (se estipula que 1 no es ni un número primo ni un número compuesto). ——De la Enciclopedia de Baidu
El primer método, solución violenta.
Fijamos un número como x, juzgamos si x es un número primo según la definición de número primo, vemos si puede ser divisible por 2, 3, 4·····, x-1, si no puede ser divisible por cualquiera de los enteros, entonces este número es un número primo.
Por ejemplo, para determinar si 11 es un número primo, necesitamos ver si puede ser divisible por los siguientes 10 números.
2, 3, 4,
5, 6, 7, 8, 9, 10 Como 11 no se puede dividir entre ninguno de estos números, se considera que es un número primo.
Si queremos encontrar un número primo entre 1 y 1000, podemos controlar x para aumentar de 2 a 1000, y cada vez que x aumenta en 1, debemos comenzar desde 2 para encontrar un número que pueda ser divisible por x hasta que podamos No lo encuentro Finalizar. Así que podemos usar dos capas de bucles for para controlar, la primera capa para controlar x para generar números del 2 al 1000, la segunda capa de bucles for para generar números del 2 al x-1 y determinar si es divisible. (Debido a que 1 no es un número primo, 1 está excluido)
Y también configuré un contador para contar el número aproximado de operaciones, lo cual es conveniente para la comparación con el siguiente método. el código se muestra a continuación:
//求1--1000内的质数（素数）
#include <stdio.h>
int main()
{
int x = 0;
int i = 0;
unsigned int count = 0; //统计运算的次数
for (x = 2; x < 1000; x++) //在2到1000之间找质数
{
for (i = 2; i < x; i++) //试除法，能不能被x整除，从2开始找，直到等于x
{
count++;
if (x % i == 0) //找到能被x整除的数了
{
break;
}
}
if (x == i) //找到和x相等也没有被整除的，证明是质数
{
printf("%d ",x);
}
}
printf("\n\n\n");
printf("运算的次数：%d ",count);
return 0;
}
El resultado de ejecutar el primer método:
El segundo método, con números impares
Es el primer método un poco complicado, por supuesto.
De hecho, ¿hemos
encontrado alguna regla a partir de los números primos: 2, 3, 5, 7, 9, 11, 13, 17, 19...?
Jejeje, es decir, salvo el 2, esos múltiplos de 2 (4, 6, 8, 10, 12, 14, 18...) no son números primos.
Entonces, nuestra primera capa del ciclo for no puede aumentar en 1 paso a paso, sino aumentar en 2 desde 3, para generar 3, 5, 7, 9, 11... para que los números pares se eviten inteligentemente. el código se muestra a continuación:
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
int x = 0;
int i = 0;
unsigned int count = 0;
x = 2;
printf("%d ",x); //已经知道2为质数，所以先第一个打印
for (x = 3; x < 1000; x += 2) //从3开始自增2
{
for (i = 2; i < x; i++)
{
count++;
if (x % i == 0)
{
break;
}
}
if (x == i)
{
printf("%d ",x);
}
}
printf("\n\n\n");
printf("运算的次数：%d ", count);
return 0;
}
El resultado del segundo método:
la comparación entre la primera y la segunda imagen:
todos encontraron que parece que el segundo método no es mucho menos que la primera operación, esto se debe a que al juzgar 33, 66, 666 en la etapa inicial Cuando i=3, se puede juzgar inmediatamente que no es un número primo, por lo que no se ha reducido mucho el número de operaciones.
El tercer método, un extraño enfoque de dos puntas
Combinado con el segundo método, salvo el 2, aquellos múltiplos de 2 (4, 6, 8, 10, 12, 14, 18...) no son números primos.
Entonces, un número primo que no sea 2 debe ser impar.
Por lo tanto, al juzgar si 11 es un número primo, ya no necesitamos juzgar si es divisible por 9 números de 2, 3, 4, 5, 6, 7, 8, 9 y 10. Solo necesitamos juzgar si es divisible por 3, 5, 7 y 9 son divisibles por números.
Entonces podemos controlar la segunda capa del bucle for para que no aumente en 1, sino que aumente en 2 desde 3.
el código se muestra a continuación:
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
int x = 0;
int i = 0;
unsigned int count = 0;
x = 2;
printf("%d ",x);
for (x = 3; x < 1000; x += 2) //只产生奇数
{
for (i = 3; i < x; i += 2) //只产生奇数
{
count++;
if (x % i == 0)
{
break;
}
}
if (x == i)
{
printf("%d ",x);
}
}
printf("\n\n\n");
printf("运算的次数：%d ", count);
return 0;
}
El resultado del tercer método:
El cuarto método, uso inteligente de matrices
Mirando la tercera base, también encontramos la siguiente regla:
los números enteros que no son divisibles por 3 no son divisibles por aquellos múltiplos de 3 que son mayores que 3 (6, 9, 12...).
Los enteros que no son divisibles por 5 tampoco lo son por aquellos múltiplos mayores de 5 (10, 15, 20...).
Entonces, si un número entero x no es divisible por ningún número primo menor que x, entonces x es primo.
De acuerdo con esta condición, tenemos otra forma de pensar para los números primos: usamos una matriz para almacenar números primos, y después de controlar x para aumentar, usamos x para eliminar cada elemento de la matriz. Si no es divisible, es un número primo y guardarlo en la matriz.
Por lo tanto, primero guardamos en el arreglo los dos números primos 2 y 3. La primera capa del bucle for sigue controlando el autoincremento de x, y la segunda capa del bucle for atraviesa el arreglo. Después del recorrido, si no son divisibles, se almacenarán en la matriz. Si uno de ellos es divisible, no es un número primo y no se guardará.
el código se muestra a continuación:
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
int arr[500] = {
0 };
int x = 0;
int i = 0;
unsigned int count = 0;
int sum = 0; //定义数组的下标
arr[sum] = 2; //把2存到数组中
sum++;
arr[sum] = 3; //把3存到数组中
sum++;
for (x = 5; x < 1000; x += 2)
{
//从下标0开始遍历，直到数组的最后一个质数
for (i = 0; i < sum; i++ )
{
count++;
if (x % arr[i] == 0)
{
break;
}
}
if (sum == i) //遍历后都不能整除
{
arr[sum] = x; //把质数保存到数组中
sum++; //下标加1，为下次放做准备
}
}
for (i = 0; i < sum; i++)
{
printf("%d ", arr[i]);
}
printf("\n\n\n");
printf("运算的次数：%d ", count);
return 0;
}
Resultado de la operación:
El quinto método, uso inteligente de la raíz cuadrada
Escritura 1:
Configuramos dos enteros a y b. Si no es un número primo, el entero x se puede escribir como x=a * b Por ejemplo:
36=2 * 18
36=3 * 12
36=4 * 9
36=6 * 6
Si el entero x es un número primo, entonces es imposible escribir en la forma de x = a * b. Entonces, si un número entero x no es divisible por ningún número primo menor o igual a la raíz cuadrada de x, entonces x es primo.
Por tanto, podemos modificar el cuarto método, es decir, en la segunda capa del bucle for, partiendo del primer elemento del array, cada uno se escribe como un cuadrado hasta que el cuadrado sea mayor que el entero x y salga del bucle.
el código se muestra a continuación:
//第五种方法，巧用平方根,写法1：
#include <stdio.h>
int main()
{
int arr[500] = {
0 };
int x = 0; //定义要找质数的变量
int i = 0;
unsigned int count = 0;
int sum = 0; //定义数组下标
arr[sum] = 2; //2是质数，储放到数组中
sum++;
arr[sum] = 3; //3也是质数，放到数组中
sum++;
for (x = 5; x < 1000; x += 2) //只查找奇数
{
for (i = 0;arr[i] * arr[i] <= x; i++) //利用数组中的元素平方去排查
{
count++;
if (x % arr[i] == 0) //不是质数
{
break;
}
}
if (arr[i]*arr[i]>x) //为质数
{
arr[sum] = x; //把找到的奇数放到数组中
sum++; //下标加1
}
}
for (i = 0; i < sum; i++)
{
printf("%d ",arr[i]);
}
printf("\n\n\n");
printf("运算的次数：%d ", count);
return 0;
}
Resultado de la operación:
Escritura 2:
No necesitamos una matriz, podemos transformarla directamente en el tercer método.
el código se muestra a continuación:
//第五种方法，巧用平方根,写法二：
#include <stdio.h>
int main()
{
int x = 0;
int i = 0;
unsigned int count = 0;
x = 2;
printf("%d ",x);
for (x = 3; x <= 1000; x += 2)
{
for (i = 2; i*i<=x; i++) //控制第二层循环
{
count++;
if (x % i == 0)
{
break;
}
}
if (i*i>x)
{
printf("%d ",x);
}
}
printf("\n\n\n");
printf("运算的次数为：%d ",count);
return 0;
}
Resultado de la operación:
Resumir
Desde lo simple y tosco del primer tipo hasta la excelente transformación del final, el número de cálculos se ha reducido paso a paso. ¿Te has dado cuenta de la belleza de la programación? Recomiendo especialmente la segunda forma de escribir la última, que puede ahorrar mucho tiempo de computación sin usar una matriz.
Si hay algo mal y hay formas de mejorarlo, indíquelo en el área de comentarios.
Ahora que has visto esto, por favor dame un pulgar hacia arriba, jejeje.