【C语言】求2024的质因数和

疯狂的小菜鸡.

已于 2025-03-04 20:17:00 修改

阅读量746

点赞数 13

文章标签：算法 c语言学习开发语言

于 2025-03-03 20:42:35 首次发布

本文链接：https://blog.youkuaiyun.com/2401_88601421/article/details/145998574

版权

相信你是最棒哒！！！

1. 质因数的定义

质因数是指一个数的因数，同时它本身是一个质数。质数的定义是：大于1的自然数中，除了1和它本身以外，没有其他因数的数。例如：

2、3、5、7、11 等都是质数。
1 不是质数，因为它只有一个因数（它自己），不符合质数的定义。

因此，1 不能作为质因数。

2. 质因数分解的目标

质因数分解的目标是将一个数表示为若干个质数的乘积。例如：

12 的质因数分解是：12 = 2 × 2 × 3。
2024 的质因数分解是：2024 = 2 × 2 × 2 × 11 × 23。

在这个过程中，我们只关心那些能整除目标数的质数，而 1 不是质数，所以不会出现在质因数分解的结果中。

【例题】质因数的和

如果一个数 p 是个质数，同时又是整数 a 的约数，则 p 称为 a 的一个质因数。请问， 2024 的所有质因数的和是多少？

正确代码

#include<stdio.h>
int main()
{
    int n = 2024, s = 0, zhishu = 2;
    while (n > 1)  // 关键改进：循环条件改为 n > 1
    {
        if (n % zhishu == 0)
        {
            s += zhishu;  // 将 zhishu 加入质因数和
            n /= zhishu;  // 更新 n，继续分解
        }
        else
        {
            zhishu++;  // 如果当前 zhishu 不能整除 n，尝试下一个数
        }
    }
    printf("2024的所有质因数的和是: %d", s);
    return 0;
}

. 为什么这样可以正确运行？

循环条件：while (n > 1) 确保了当 n 被完全分解为 1 时，循环会正确终止。
质因数分解逻辑：每次找到一个质因数后，程序会将 n 除以该质因数，继续分解，直到 n 变为 1。
避免死循环：当 n = 1 时，循环条件 n > 1 不再满足，程序会正确退出循环。

最终，所有质因数的和为 40。

关键问题：循环条件应该是 n > 1，而不是 n > 0。

这个程序怎么确定数是质数的？

在这个程序中，我们实际上并没有直接判断一个数是否是质数。相反，我们利用了一个重要的性质：从2开始的连续整数序列中，如果一个数能整除目标数，那么它一定是质数，或者它之前已经有一个质数能整除目标数。

解释

从2开始：我们从最小的质数2开始尝试，如果2能整除目标数，那么2就是一个质因数。
逐步增加：如果当前的数不能整除目标数，我们尝试下一个数。由于我们是按顺序尝试的，所以如果一个数能整除目标数，那么它一定是质数，或者它之前已经有一个质数能整除目标数。
质因数的性质：如果一个数能整除目标数，并且它之前没有其他数能整除目标数，那么它一定是质数。这是因为任何合数都可以分解为质数的乘积，而我们是从最小的质数开始尝试的。

例子

以2024为例，程序的运行过程如下：

用2分解：
- 2024 ÷ 2 = 1012，2是质因数。
- 1012 ÷ 2 = 506，2是质因数。
- 506 ÷ 2 = 253，2是质因数。
尝试3、5、7：这些数都不能整除253。
用11分解：
- 253 ÷ 11 = 23，11是质因数。
检查23：
- 23 ÷ 23 = 1，23是质因数。

在这个过程中，我们并没有直接判断每个数是否是质数，而是利用了从2开始的连续整数序列中，如果一个数能整除目标数，那么它一定是质数，或者它之前已经有一个质数能整除目标数的性质。

总结

程序没有直接判断质数，而是利用了从2开始的连续整数序列的性质。
如果一个数能整除目标数，并且它之前没有其他数能整除目标数，那么它一定是质数。

【补充题】

如果一个数 p 是个质数，同时又是整数 a 的约数，则 p 称为 a 的一个质因数。

请问， 2024 的最大的质因数是多少？

上代码：

#include <stdio.h>

int main() {
    int n = 2024;
    int max = 1;  // 用于存储最大的质因数

    // 从最小的质数 2 开始
    for (int i = 2; i <= n; i++) {
        // 如果 i 是 n 的因数
        while (n % i == 0) {
            max = i;  // 更新最大质因数
            n /= i;   // 将 n 除以 i，继续分解
        }
    }

    printf("2024的最大质因数是: %d\n", max);
    return 0;
}

逻辑：

详细步骤分析

初始状态：

n = 2024
max = 1
i = 2（从最小的质数开始）

循环过程：

检查 i = 2 是否是 n 的因数：
- n % 2 == 0，结果为 true，说明2是2024的因数。
- 更新 max = 2。
- 将 n 除以2：n = 2024 / 2 = 1012。
继续检查 i = 2 是否是新的 n 的因数：
- 1012 % 2 == 0，结果为 true，说明2仍然是1012的因数。
- 更新 max = 2（不变）。
- 将 n 除以2：n = 1012 / 2 = 506。
继续检查 i = 2 是否是新的 n 的因数：
- 506 % 2 == 0，结果为 true，说明2仍然是506的因数。
- 更新 max = 2（不变）。
- 将 n 除以2：n = 506 / 2 = 253。
继续检查 i = 2 是否是新的 n 的因数：
- 253 % 2 == 0，结果为 false，说明2不再是253的因数。
- 循环结束，i 自增为 3。
检查 i = 3 是否是 n 的因数：
- 253 % 3 == 0，结果为 false，说明3不是253的因数。
- i 自增为 4。
检查 i = 4 是否是 n 的因数：
- 253 % 4 == 0，结果为 false，说明4不是253的因数。
- i 自增为 5。
检查 i = 5 是否是 n 的因数：
- 253 % 5 == 0，结果为 false，说明5不是253的因数。
- i 自增为 6。
检查 i = 6 是否是 n 的因数：
- 253 % 6 == 0，结果为 false，说明6不是253的因数。
- i 自增为 7。
检查 i = 7 是否是 n 的因数：
- 253 % 7 == 0，结果为 false，说明7不是253的因数。
- i 自增为 8。
检查 i = 8 是否是 n 的因数：
- 253 % 8 == 0，结果为 false，说明8不是253的因数。
- i 自增为 9。
检查 i = 9 是否是 n 的因数：
- 253 % 9 == 0，结果为 false，说明9不是253的因数。
- i 自增为 10。
检查 i = 10 是否是 n 的因数：
- 253 % 10 == 0，结果为 false，说明10不是253的因数。
- i 自增为 11。
检查 i = 11 是否是 n 的因数：
- 253 % 11 == 0，结果为 true，说明11是253的因数。
- 更新 max = 11。
- 将 n 除以11：n = 253 / 11 = 23。
继续检查 i = 11 是否是新的 n 的因数：
- 23 % 11 == 0，结果为 false，说明11不再是23的因数。
- 循环结束，i 自增为 12。
检查 i = 12 是否是 n 的因数：
- 23 % 12 == 0，结果为 false，说明12不是23的因数。
- i 自增为 13。
检查 i = 13 是否是 n 的因数：
- 23 % 13 == 0，结果为 false，说明13不是23的因数。
- i 自增为 14。
检查 i = 14 是否是 n 的因数：
- 23 % 14 == 0，结果为 false，说明14不是23的因数。
- i 自增为 15。
检查 i = 15 是否是 n 的因数：
- 23 % 15 == 0，结果为 false，说明15不是23的因数。
- i 自增为 16。
检查 i = 16 是否是 n 的因数：
- 23 % 16 == 0，结果为 false，说明16不是23的因数。
- i 自增为 17。
检查 i = 17 是否是 n 的因数：
- 23 % 17 == 0，结果为 false，说明17不是23的因数。
- i 自增为 18。
检查 i = 18 是否是 n 的因数：
- 23 % 18 == 0，结果为 false，说明18不是23的因数。
- i 自增为 19。
检查 i = 19 是否是 n 的因数：
- 23 % 19 == 0，结果为 false，说明19不是23的因数。
- i 自增为 20。
检查 i = 20 是否是 n 的因数：
- 23 % 20 == 0，结果为 false，说明20不是23的因数。
- i 自增为 21。
检查 i = 21 是否是 n 的因数：
- 23 % 21 == 0，结果为 false，说明21不是23的因数。
- i 自增为 22。
检查 i = 22 是否是 n 的因数：
- 23 % 22 == 0，结果为 false，说明22不是23的因数。
- i 自增为 23。
检查 i = 23 是否是 n 的因数：
- 23 % 23 == 0，结果为 true，说明23是23的因数。
- 更新 max = 23。
- 将 n 除以23：n = 23 / 23 = 1。
循环结束：
- 当 n 变为1时，循环结束，因为已经完全分解了2024。