务必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:
有人看见吗呜呜呜
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;
}