高精度

算法很简单，但即使是unsigned long long 连21!都装不下，更不要说1000!了

算法内容

核心：用一个数组A[]，A[0]~A[n]分别存储大数的个位到第n位

注意：大的静态数组应该定义在全局

运算

大数与具体的数

相乘

1. 当前位*数+进位

   A[i] = A[i]+carry;
   

2. 令A[i]=个位的数，carry=其它位上的数

   carry = A[i]/10;
   A[i] %= 10;
   

   例：第一步结果为254，A[i]=4，carry=25

​ 故具体代码为：

int A[10000];//全局变量
int carry = 0;
for (int & i : A) {
    i = i * num + carry;
    carry = i / 10;
    i = i % 10;
}

​ 例：26*37（A中存了37）

​ 步骤：

1. 26*7=182，2存入A[0]，18留着进一步运算
2. 26*3=78，78+18=96，这时虽然得到了答案962，但是A需要把9和6分开存放，所以将6存入A[1],9留着进一步运算
3. 26*0+9=9，将9存入A[2],运算完成。

​ 运算过程基本跟列竖式相同。

若用字符串储存大数

大数与大数

注意：

1. 大数只能通过字符串读入！！！
2. 注意大数是正着存还是反着存

相加

​ 大数不超过100位

1. 遍历大数A、B

2. sum[i]=A[i]+B[i]+carry

3. carry=十位，sum[i]=个位

   for(int i = a.size()-1,j = b.size()-1;i >= 0||j >= 0||c > 0;i--,j--){
       if(i>=0)
           c += a[i]-'0';
       if(j>=0)
           c += b[j]-'0';
       s += (c%10)+'0';
       c /= 10;
   }
   reverse(s.begin(),s.end());
   

输出

1. 先寻找到最高位

   int last = 0;
   for (int i = 10000 - 1; i >= 0; --i) {
       if (A[i] != 0) {
           last = i;
           break;
       }
   }
   

2. 然后按位输出

   for (int i = last; i >= 0; --i) {
       cout << A[i];
   }
   

扩展

java

python

不用看了，python不用处理大数

1. 阶乘

   N = int(input())
   ans = 1
   for i in range(1, N+1):
       ans *= i     
   print(ans)
   

2. 大数相加

a = int(input())
b = int(input())
print(a+b)

总结

1. 大数存储方向决定遍历方式
2. 若用字符串存储大数：
   1. 取出时char-‘0’将字符变为整型
   2. 存入时int+‘0’,将整型变为字符
   3. 注意结果字符串的储存方向，反向时需要reverse（ans.begin(),ans.end()）进行调换方向

​ 3. 大数与大数运算需要在同一个循环体内设2个变量，代表同时遍历两个大数。

​