c语言编写：输出四位数中劈成两半加起来再平方正好等于原来数字的所有四位数

以下是C语言代码实现：

#include <stdio.h>

int main() {
    int num, left, right, sum;
    for (num = 1000; num <= 9999; num++) {
        left = num / 100;
        right = num % 100;
        sum = (left + right) * (left + right);
        if (num == sum) {
            printf("%d\n", num);
        }
    }
    return 0;
}

代码思路：

1. 从1000开始循环到9999，依次判断每个四位数是否符合条件。
2. 将四位数拆成左右两半，左半部分为num/100，右半部分为num%100。
3. 计算左右两半之和的平方，即sum = (left + right) * (left + right)。
4. 如果num等于sum，则说明该数符合条件，输出该数。

相关问题

有位外国数学家叫卡普利加，在一次旅行中，遇到猛烈的暴风雨，电闪雷鸣过后，他看到路边一块里程碑，被雷电劈成两半，一半上刻着30，另一半刻着25。 这时，卡普利加的脑际中忽然发现了一个绝妙的数学关系： 30+25=55 55^2=3025 把劈成两半的数加起来，再平方，正好是原来的数字。 请问，除此之外，还有没有别的4位数，也具有这样的性质呢？ 输入格式: 本题没有输入 输出格式: 按照升序排列的方式输出所有4位数的雷劈数，每行输出一个。 输入样例: 输出样例 2025 3025 9801。C语言

这是一个求解问题，需要通过编程来实现。以下是一个 C 语言的实现：

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

int main() {
    for (int i = 1000; i < 10000; i++) {
        int a = i / 100;
        int b = i % 100;
        if ((a + b) * (a + b) == i) {
            printf("%d\n", i);
        }
    }
    return 0;
}

思路是遍历所有的 4 位数，将其分为前两位和后两位。如果前两位和后两位的和的平方等于这个数，那么就输出这个数。

c语言问题：计算两个十进制大整数（位数达数千）的乘积。大整数用char [10000]数组表示。 输入：两个大整数a, b，十进制，最多5000位 输出：a*b及运行时间

在C语言中，计算两个大整数的乘积通常会涉及到手动的位操作，因为C标准库并没有内置支持大整数乘法。下面是一个简单的长除法（Karatsuba algorithm 或者更传统的方法）实现的大整数乘法算法。注意，这种方法适用于位数较小（几百位）的情况，对于数千位数的计算可能会效率较低。

#include <stdio.h>
#include <string.h>
#define MAX_DIGITS 5000

// 单位长度的乘法
int multiply(int a[], int b[]) {
    int mul = 0;
    for (int i = 0; i < MAX_DIGITS; i++) {
        mul += a[i] * b[i];
        // 右移一位相当于除以10
        mul %= 10;
    }
    return mul;
}

// 辅助函数，将低位部分复制到高位
void shift(char dest[], char src[], int len) {
    memmove(dest + len, src, sizeof(char) * len);
    memset(src, 0, sizeof(char) * len);
    memcpy(src, dest, sizeof(char) * len);
}

// 主函数实现 Karatsuba 乘法
void karatsuba(char a[MAX_DIGITS], char b[MAX_DIGITS], char result[MAX_DIGITS]) {
    int m = strlen(a);
    int n = strlen(b);

    // 如果数字小于3位，则常规相乘
    if (m <= 3 && n <= 3) {
        int res[m + n];
        for (int i = 0; i < m + n; ++i)
            res[i] = multiply(a, b);
        strncpy(result, res, MAX_DIGITS);
    } else {
        char half_a[MAX_DIGITS / 2 + 1], half_b[MAX_DIGITS / 2 + 1];
        int l = min(m, n);

        // 将长数分割成两半
        for (int i = 0; i < l; i++)
            half_a[i] = a[i];
        shift(half_a, a + l, m - l);
        for (int i = 0; i < l; i++)
            half_b[i] = b[i];
        shift(half_b, b + l, n - l);

        // 递归计算中间值
        karatsuba(half_a, half_b, half_a);
        karatsuba(half_a, half_b, half_b);

        // 结果计算
        char x[l + 1], y[l + 1];
        for (int i = 0; i < l; i++)
            x[i] = half_a[i] + half_b[i];
        shift(x, half_a, l);
        shift(x, half_b, l);

        karatsuba(x, x, y); // y = (a+b)^2 - a^2 - b^2

        int z[m + n];
        multiply(a, a, z);
        multiply(b, b, z);
        for (int i = l; i < m + n; i++)
            z[i] -= y[i - l];

        // 把结果组合起来
        for (int i = m + n - 1; i >= l; i--) {
            result[i] = (z[i] % 10) + (x[i - l] % 10) + (half_a[i - l] % 10) + (half_b[i - l] % 10);
            result[i] %= 10;
        }
        while (result[m + n - 1] == 0) {
            result[m + n - 1] = 0;
            m--;
        }
    }
}

int main() {
    char a[MAX_DIGITS], b[MAX_DIGITS], result[MAX_DIGITS];
    scanf("%s%s", a, b);
    karatsuba(a, b, result);
    printf("Product: %s\n", result);

    // 获取运行时间的代码（如上所述，通常需要其他库来准确测量）
    // 时间戳开始和结束并计算差值
    clock_t start = clock();
    karatsuba(a, b, result);
    clock_t end = clock();
    double time_taken = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("Execution Time: %.6f seconds\n", time_taken);

    return 0;
}

此代码实现了 Karatsuba 算法来计算大整数乘积，但对于数千位的计算，推荐考虑使用外部库，如 GMP（GNU Multiple Precision Arithmetic Library）等，它们有更高效的算法和更好的性能。