C语言输入一个整数，求出它的各个因数。 输入格式: 输入数据首先包含一个整数T，表示测试实例的个数，然后是T组测试数据。每组测试数据包括一个整数。 输出格式: 逐行从小到大输出整数的因数。 输入样例: 2 1 6 输出样例: 1 1 2 3 6

这道题可以先用一个循环输出小于等于该整数的所有正整数，然后判断该整数是否是该正整数的因子，如果是的话就输出。下面是代码实现：

#include <stdio.h>

int main()
{
    int t, n, i, cnt;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        cnt = 0; //计数器，记录当前输出到了第几个因数
        for (i = 1; i <= n; i++)
        {
            if (n % i == 0) //如果i是n的因数
            {
                cnt++; //计数器加1
                printf("%d ", i); //输出因数
            }
        }
        printf("\n");
    }
    return 0;
}

需要注意的是，每组测试数据输出完毕后要输出一个空行，否则会被判为格式错误。

相关问题

写出C语言代码已知正整数 a0,a1,b0,b1，设某未知正整数 x 满足： 1． x 和 a0 的最大公约数是 a1 2． x 和 b0 的最小公倍数是 b1 求解满足条件的 x 的个数。请你帮助他编程求解这个问题。 对于 100%的数据，保证有 1≤a0，a1，b0，b1≤2,000,000,000。 输入格式: 第一行为一个正整数 n，表示有 n 组输入数据。n≤2000 接下来的 n 行每行一组输入数据，为四个正整数 a0，a1，b0，b1，之间用一个空格隔开。 输出格式: 共n 行。每组输入数据的输出结果占一行，为一个整数。 对于每组数据：若不存在这样的 x，请输出 0； 若存在这样的 x，请输出满足条件的 x 的个数；

以下是一种C语言的解法：

#include <stdio.h>

// 计算最大公约数
int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

// 计算最小公倍数
int lcm(int a, int b) {
    return a / gcd(a, b) * b;
}

int main() {
    int n;
    scanf("%d", &n);

    while (n--) {
        int a0, a1, b0, b1;
        scanf("%d%d%d%d", &a0, &a1, &b0, &b1);

        // 对于a0和b0不存在公因数的情况，x的范围是[a0*b1/a1, a0*b1]，每个满足条件的x都可以表示为 k*a0*b1 + a0*b1/a1
        if (gcd(a0, b0) == 1) {
            int l = a0 * b1 / a1;
            int r = a0 * b1;
            int cnt = (r - l) / (a0 * b1 / a1) + 1;
            printf("%d\n", cnt);
        }
        // 对于a0和b0存在公因数的情况，先将a0和b0分解质因数成p1^k1 * p2^k2 * ... * pn^kn的形式，对于每个pi，如果ki在a1和b1中出现的次数不同，则无解；否则x的范围是[lcm(a0,b0)*max(a1,b1)/a0, lcm(a0,b0)*min(a1,b1)/b0]，每个满足条件的x都可以表示为 k*lcm(a0,b0)*max(a1,b1) + lcm(a0,b0)*max(a1,b1)/a0
        else {
            int g = gcd(a0, b0);
            int a0_ = a0 / g, b0_ = b0 / g;
            int a1_ = a1, b1_ = b1;
            while (g > 1) {
                if (g % a0_ == 0) {
                    g /= a0_;
                    a1_ /= a0_;
                }
                else if (g % b0_ == 0) {
                    g /= b0_;
                    b1_ /= b0_;
                }
                else {
                    printf("0\n");
                    break;
                }
            }
            if (g == 1) {
                int l = lcm(a0, b0) * (a1_ > b1_ ? a1_ : b1_) / a0;
                int r = lcm(a0, b0) * (a1_ < b1_ ? a1_ : b1_) / b0;
                int cnt = (r - l) / (lcm(a0, b0) * (a1_ > b1_ ? a1_ : b1_) / a0) + 1;
                printf("%d\n", cnt);
            }
        }
    }

    return 0;
}

时间复杂度：O(n log(max(a0, a1, b0, b1)))

如何用c语言求一个数中两个因数的个数

在C语言中，计算一个整数中因数的个数通常不是通过直接遍历所有可能的因子，因为这会非常低效。一种常见的方法是采用Sieve of Eratosthenes算法，用于找到某个范围内的所有质数，然后检查给定的数是否可以分解为这些质数的乘积。但是，这里我们提供一个更简单的方法，适合小范围内的数字：

1. 首先，创建一个函数 `count_factors(int num)`，接受一个整数作为输入。
2. 初始化一个计数器变量 `factor_count` 为0，用于存储因数个数。
3. 从2开始，逐个检查小于等于num的所有整数。对于每个数i：
- 如果num能被i整除（即num % i == 0），说明i是num的一个因数，将`factor_count`加一，并继续寻找下一个因子（num /= i）。注意避免重复计数，因为一旦确定i是因子，就不再检查它之后的数是否也整除num。
4. 当i大于sqrt(num)时，循环结束。这是因为如果num还有其他更大的因数，那么至少会有一个对应的小于sqrt(num)的因子未被检查过。
5. 返回`factor_count`。

以下是简单的C代码示例：

#include <stdio.h>
#include <math.h>

int count_factors(int num) {
    int factor_count = 0;
    for (int i = 2; i <= sqrt(num); i++) {
        if (num % i == 0) {
            factor_count++;
            // 如果是偶数，只算一次，因为它有两个因数(1 和本身)
            if (i != 2 && i * i != num) {
                factor_count++;
            }
        }
    }
    // 包含1和自身在内的因数个数
    if (factor_count == 0 || num == 1) {
        factor_count += 2;
    } else if (num > 2) { // 考虑num可能是质数的情况
        factor_count += 1;
    }
    return factor_count;
}

int main() {
    int num;
    printf("Enter a number: ");
    scanf("%d", &num);
    printf("Number of factors: %d\n", count_factors(num));
    return 0;
}