C语言 高精度计算部分

务必C语言 需要高精度计算处理 后面我想法是第一个循环向后覆盖 请教高精度部分代码！或者完整代码！本人基础较弱 请附适当注释

（1）用短整型数组存储大整数，并定义相关的结构体和函数

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

//基于短整型数组定义大整数结果，数组的每一个分量对应大整数的一位
struct big_int_struct
{
    short int int_arr[100001];  //第一个分量对应大整数的最低位
    int digit_num;
};
//通过大整数字符串给大整数对应的短整型数组赋值
struct big_int_struct str2big_int(char *str)
{
    struct big_int_struct big_int_obj;
    int digit_num = (int)strlen(str);
    big_int_obj.digit_num = digit_num;
    int i;
    for (i = 0; i < digit_num; i++)
    {
        big_int_obj.int_arr[i] = str[digit_num - 1 - i] - '0';
    }
    return big_int_obj;
}
//处理短整型数组的分量大于10的情形
void norm_big_int(struct big_int_struct *big_int_ptr)
{
    int i;
    for (i = 0; i < big_int_ptr->digit_num; i++)
    {
        big_int_ptr->int_arr[i + 1] += big_int_ptr->int_arr[i] / 10;
        big_int_ptr->int_arr[i] %= 10;
    }
    if (big_int_ptr->int_arr[big_int_ptr->digit_num] != 0)
    {
        big_int_ptr->digit_num++;
    }
}
//比较两个大整数
int cmp_big_int(struct big_int_struct *big_int_a_ptr, struct big_int_struct *big_int_b_ptr)
{
    int a_digit_num = big_int_a_ptr->digit_num;
    int b_digit_num = big_int_b_ptr->digit_num;
    if (a_digit_num > b_digit_num) { return 1; }
    if (a_digit_num < b_digit_num) { return -1; }
    int i;
    for (i = a_digit_num - 1; i >= 0; i--)
    {
        if (big_int_a_ptr->int_arr[i] > big_int_b_ptr->int_arr[i]) { return 1; }
        if (big_int_a_ptr->int_arr[i] < big_int_b_ptr->int_arr[i]) { return -1; }
    }
    return 0;
}
//判断是否大整数的所有位都等于9
bool judge_all_digits_nine(struct big_int_struct *big_int_ptr)
{
    int i;
    for (i = 0; i < big_int_ptr->digit_num - 1; i++)
    {
        if (big_int_ptr->int_arr[i] != 9)
        {
            return false;
        }
    }
    return true;
}
//打印大整数
void print_big_int(struct big_int_struct *big_int_ptr)
{
    int i;
    for (i = big_int_ptr->digit_num - 1; i >= 0; i--)
    {
        printf("%d", big_int_ptr->int_arr[i]);
    }
    printf("\n");
}

（2）问题的C语言解决代码

int main()
{
    //初始化
    int L;
    char A_str[100000];
    scanf("%d", &L);
    scanf("%s", &A_str);
    int A_digit_num = (int)strlen(A_str);
    int i;

    //构造大整数结构对象
    struct big_int_struct big_int_A = str2big_int(A_str);
    struct big_int_struct big_int_result, big_int_tmp;

    //找到大于A且有长度L循环节的最小整数
    int cycle_section_num = (A_digit_num + L - 1) / L;
    if (A_digit_num%L == 0) //处理A_digit_num能被L整除的情形
    {
        big_int_tmp.digit_num = A_digit_num;
        for (i = 1; i <= cycle_section_num; i++)
        {
            memcpy(&(big_int_tmp.int_arr[big_int_tmp.digit_num - i*L]),
                &(big_int_A.int_arr[big_int_A.digit_num - L]),
                L * sizeof(big_int_tmp.int_arr[0]));
        }
        if (cmp_big_int(&big_int_tmp, &big_int_A) > 0)
        {
            big_int_result = big_int_tmp;
        }
        if (cmp_big_int(&big_int_tmp, &big_int_A) <= 0)
        {
            if (judge_all_digits_nine(&big_int_A))
            {
                big_int_result.digit_num = L*(cycle_section_num + 1);
                for (i = 1; i <= cycle_section_num + 1; i++)
                {
                    big_int_result.int_arr[i*L - 1] = 1;
                }
            }
            else
            {
                big_int_result = big_int_A;
                big_int_result.int_arr[big_int_result.digit_num - L] += 1;
                for (i = 2; i <= cycle_section_num; i++)
                {
                    memcpy(&(big_int_result.int_arr[big_int_result.digit_num - i*L]),
                        &(big_int_result.int_arr[big_int_result.digit_num - L]),
                        L * sizeof(big_int_result.int_arr[0]));
                }
            }
        }
    }
    else //处理A_digit_num不能被L整除的情形
    {
        big_int_result.digit_num = L*cycle_section_num;
        for (i = 1; i <= cycle_section_num; i++)
        {
            big_int_result.int_arr[i*L - 1] = 1;
        }
    }

    //输出结果
    norm_big_int(&big_int_result); //处理大整数对应短整数数组中存在大于10的分量的情形
    print_big_int(&big_int_result);

    return 0;
}

（3）代码运行结果截图
运行结果1：

运行结果2：

运行结果3：

运行结果4：

有人看见吗呜呜呜

1.通过字符串引入两串数字分别存放到两个字符数组
2.将其每一位数字逆序分别存放到两个整型数组
3.进行计算并处理进位（关键）
4.将结果存放到第三个整型数组当中（引进动态数组）
5.输出结果

你试一试，可能longlong也不够题目的范围，当作字符串来处理应该会更好

#include <stdio.h>

int main() {
    long long L;
    long long A;  // 使用long long是为了应付超大数
    scanf_s("%lld", &L);
    scanf_s("%lld", &A);

    // 计算A的位数 开始
    long long A_count = 0;  // 用来存储A的位数
    long long A_temp = A;  // 这里是A的一个暂存变量，用与中间计算结果的暂存
    while (A_temp >= 10) {
        A_temp /= 10;
        A_count++;
    }
    A_count++;

    
    // 判断A_count能否被L整除，按能整除和不能整除两种情况处理
    long long temp = 0; // 用与中间计算结果的暂存
    long long mid_temp = 1;  // 用与中间计算结果的暂存
    long long result = 0;
    if (A_count % L == 0) {  // A_count能被L整除
        temp = A_count - L;  // 此时存储的是减去一个L的剩余位数
        for (int j = 0; j < temp; j++) {
            mid_temp *= 10;  // 加入剩余位数为3，计算完毕后mid_temp=1000
        }
        temp = A / mid_temp + 1; // 循环数中的一个基数，假如A=123456，此时temp=124
        result = temp * mid_temp; // 拿124*1000，得到结果的一部分124000
        // 下面思路同理，最终得到124124
        for (int j = 1; j <= (A_count - L)/L; j++) {
            mid_temp = 1;
            for (int k = 0; k < ((A_count - L)-j*L); k++) {
                mid_temp *= 10;
            }
            result += temp * mid_temp;
        }
    }
    else {
        // 在不能整除的情况下，结果总是为100100类似的形式
        //如果A_count>L
        if (A_count > L) {
            while (A_count % L != 0)
                A_count++;
            temp = 1;
            for (int j = 1; j < L; j++) {
                temp *= 10;
            }
            mid_temp = 1;
            for (int j = 0; j < A_count - L; j++) {
                mid_temp *= 10;
            }
            result = temp * mid_temp;
            for (int i = 1; i <= (A_count - L) / L; i++) {
                mid_temp = 1;
                for (int k = 0; k < ((A_count - L) - i * L); k++) {
                    mid_temp *= 10;
                }
                result += temp * mid_temp;
            }
        }
        else {
            //如果A_count<L
            mid_temp = 1;
            for (int i = 1; i < L; i++) {
                mid_temp *= 10;
            }
            result = mid_temp;
        }

    }

    printf("%lld", result);

    return 0;
}