超大型数据加减法问题

宸宸城堡

背景：
计算机所能完成的一个基本功能就是完成数据的计算，譬如加法、减法等等。但是在任何一种计算机上，计算中能够使用的数字都是有一定范围的，超过了范围，就没法得到精确的结果。

你现在接受了一个任务，要编写一个高精度计算器的核心部分。所谓高精度计算器，就是可以计算很大很大的数据的计算器。

输入：
输入的第一行是一个正整数，表示下面有几组数据需要计算。之后的每一行是两个十进制的正整数和一个运算符，每个整数可以由最多 500 个数字组成。运算符可以是加号或者减号。

输出：
对应着输入的每一行数据，输出计算的结果，每个结果占一行。

用例1：
   输入：
   2（回车）
   213914+23466123（回车）
   32862934-23481243（回车）

   输出：
   23680037（回车）
   9381691（回车）

用例2：
   输入：
   3（回车）
   483291674192731231+1236187236812735123（回车）
   123129678463287562378-28935687264871236（回车）
   999999999+1（回车）
   输出：
   1719478911005466354（回车）
   123100742776022691142（回车）
   1000000000（回车）

感谢各位大佬！！！！！！！

人造人

题目也没有说不能调用库函数，所以这里我就调用库函数算了

1. #include <stdio.h>
   
2. #include <mpfr.h>
   
3. #include <ctype.h>
   
4. 
   
5. void output(void) {
   
6.     char buff[8192]; fgets(buff, 8192, stdin);
   
7.     mpfr_t a, b, c;
   
8.     char *op = NULL;
   
9.     mpfr_inits2(8192, a, b, c, NULL);
   
10.     for(size_t i = 0; buff[i]; ++i) {
    
11.         if(!isdigit(buff[i])) {
    
12.             op = &buff[i];
    
13.             break;
    
14.         }
    
15.     }
    
16.     mpfr_strtofr(a, buff, &op, 10, MPFR_RNDD);
    
17.     mpfr_set_str(b, op + 1, 10, MPFR_RNDD);
    
18.     if(*op == '-') mpfr_neg(b, b, MPFR_RNDD);
    
19.     mpfr_add(c, a, b, MPFR_RNDD);
    
20.     mpfr_printf("%.0Rf\n", c);
    
21.     mpfr_clears(a, b, c, NULL);
    
22.     mpfr_free_cache();
    
23. }
    
24. 
    
25. int main(void) {
    
26.     size_t count; scanf("%lu", &count);
    
27.     getchar();
    
28.     for(size_t i = 0; i < count; ++i) {
    
29.         output();
    
30.     }
    
31.     return 0;
    
32. }
    

复制代码

宸宸城堡

人造人 发表于 2021-11-8 22:47
题目也没有说不能调用库函数，所以这里我就调用库函数算了

不允许调用库函数

人造人

宸宸城堡 发表于 2021-11-9 11:33
不允许调用库函数

为什么？

hrpzcf

要不去参考一下Python底层对超长整型的实现？

jhq999

我这个思路，不知道有多少BUG ,目前知道一个，就是减法时数位相同前面小于后面，我懒得调换了。

1. int DivStr(char* inch,char* valch1,char* valch2,char *sg);
   
2. int Bigoperation(char* valch1,char* valch2,char sg,char* valch3);
   
3. int main()
   
4. {
   
5.         char invalch[64]={0},valch[3][64]={0},sg=0;
   
6.         int i=0,j=0,sgd=0;
   
7.         scanf("%s",invalch);
   
8.         if(!(sgd=DivStr(invalch,valch[0],valch[1],&sg)))return 0;
   
9.         if(sgd)
   
10.         {
    
11.                 if (-1==sgd)
    
12.                 {
    
13.                         if(Bigoperation(valch[1],valch[0],sg,valch[2]))
    
14.                         {
    
15.                                 if('-'==sg)printf("-");
    
16.                                 while (valch[2][++i]);
    
17.                                 for (; i>=0; i--)
    
18.                                 {
    
19.                                         printf("%c",valch[2][i]);
    
20.                                 }
    
21.                         }
    
22. 
    
23.                 }
    
24.                 else if (1==sgd)
    
25.                 {
    
26.                         if(Bigoperation(valch[0],valch[1],sg,valch[2]))
    
27.                         {
    
28.                                 while (valch[2][++i]);
    
29.                                 for (; i>=0; i--)
    
30.                                 {
    
31.                                         printf("%c",valch[2][i]);
    
32.                                 }
    
33.                         }
    
34. 
    
35.                 }
    
36.         }
    
37. 
    
38.         return 0;
    
39. }
    
40. int Bigoperation(char* valch1,char* valch2,char sg,char* valch3)
    
41. {
    
42.         int i=0,j=0,k=0;
    
43.         if ('+'==sg)
    
44.         {
    
45.                 for (i = 0,j=0;valch1[i]||valch2[j]; i++,j++)
    
46.                 {
    
47.                         if ('\0'==valch1[i])
    
48.                         {
    
49.                                 i--;
    
50.                         }
    
51.                         if ('\0'==valch2[j])
    
52.                         {
    
53.                                 j--;
    
54.                         }
    
55.                         if (i==j)
    
56.                         {
    
57.                                 valch3[i]+=valch1[i]+valch2[j]-'0';
    
58. 
    
59.                         }
    
60.                         else if (i>j)
    
61.                         {
    
62.                                 valch3[i]+=valch1[i];
    
63.                         }
    
64.                         else
    
65.                         {
    
66.                                 valch3[j]+=valch2[j];
    
67.                         }
    
68.                         int k=i;
    
69.                         if (k<j)k=j;
    
70.                         if (valch3[k]>'9')
    
71.                         {
    
72.                                 valch3[k]-=0xa;
    
73.                                 valch3[k+1]++;
    
74.                         }
    
75.                 }
    
76.                 i=i>j?i:j;
    
77. 
    
78.                 while(valch3[i])i++;
    
79.                 i--;
    
80.                 if (valch3[i]>'9')
    
81.                 {
    
82.                         valch3[i]-=0xa;
    
83.                 }
    
84.                 else if(valch3[i]<'0')
    
85.                 {
    
86.                         valch3[i]+='0';
    
87.                 }
    
88.                 return 1;
    
89.         }
    
90.         if ('-'==sg)
    
91.         {
    
92.                 for (i = 0,j=0;valch1[i]||valch2[j]; i++,j++)
    
93.                 {
    
94.                         if ('\0'==valch1[i])
    
95.                         {
    
96.                                 i--;
    
97.                         }
    
98.                         if ('\0'==valch2[j])
    
99.                         {
    
100.                                 j--;
     
101.                         }
     
102.                         if (i==j)
     
103.                         {
     
104.                                 valch3[i]+=valch1[i]-valch2[j]+'0';
     
105. 
     
106.                         }
     
107.                         else if (i>j)
     
108.                         {
     
109.                                 valch3[i]+=valch1[i];
     
110.                         }
     
111.                         else
     
112.                         {
     
113.                                 valch3[j]+=valch2[j];
     
114.                         }
     
115.                         k=i;
     
116.                         if (k<j)k=j;
     
117.                         if (valch3[k]<'0')
     
118.                         {
     
119.                                 valch3[k]=0x3a-'0'+valch3[k];
     
120.                                 valch3[k+1]--;
     
121.                         }
     
122.                 }
     
123.                 if (valch3[k]=='0')
     
124.                 {
     
125.                         valch3[k]='\0';
     
126.                 }
     
127.                 return 1;
     
128.         }
     
129.         return 0;
     
130. }
     
131. int DivStr(char* inch,char* valch1,char* valch2,char *sg)
     
132. {
     
133.         int i=0,j=0,sgd=1;
     
134.         while ('+'!=inch[j]&&'-'!=inch[j])j++;
     
135.         for (i = 0; i < j; i++)
     
136.         {
     
137.                 valch1[j-1-i]=inch[i];
     
138.                 if ('0'>inch[i]||'9'<inch[i])
     
139.                 {
     
140.                         return 0;
     
141.                 }
     
142.         }
     
143.         *sg=inch[i];
     
144.         sgd=i;
     
145.         inch[i]='\0';
     
146.         j=i+1;
     
147.         while (inch[j])j++;
     
148.         if ((sgd-1)<(j-sgd))sgd=-1;//就是这里
     
149.         else
     
150.                 sgd=1;
     
151.         for (i=0,j--; inch[j]; j--,i++)
     
152.         {
     
153.                 valch2[i]=inch[j];
     
154.                 if ('0'>inch[j]||'9'<inch[j])
     
155.                 {
     
156.                         return 0;
     
157.                 }
     
158.         }
     
159.         return sgd;
     
160. }

复制代码