1
#include <iostream>
2
using namespace std;
3

4
const int N = 1e6 + 10;  // 定义足够大的数组大小
5
int a[N], b[N], c[N];    // a, b存储输入数字，c存储结果
6
int la, lb, lc;          // 分别表示a, b, c的长度
7

8
// 高精度加法模板 - c = a + b
9
void add(int c[], int a[], int b[]) {
10
    for(int i = 0; i < lc; i++) {
11
        c[i] += a[i] + b[i];    // 对应位相加，再加上进位
12
        c[i + 1] += c[i] / 10;  // 处理进位：将进位加到下一位
13
        c[i] %= 10;             // 处理余数：保留当前位的个位数
14
    }
15
    // 处理最高位的进位
16
    if(c[lc]) lc++;  // 如果最高位有进位，结果长度加1
17
}
18

19
int main() {
20
    string x, y;
21
    cin >> x >> y;  // 用字符串读入两个大数
22

23
    // 1. 拆分每一位，逆序放在数组中
24
    la = x.size();  // 获取第一个数字的长度
25
    lb = y.size();  // 获取第二个数字的长度
26
    lc = max(la, lb);  // 结果长度至少是两个数字中较长的那个
27

28
    // 将字符串转换为数字数组（逆序存储，个位在索引0）
29
    for(int i = 0; i < la; i++)
30
        a[la - 1 - i] = x[i] - '0';  // 逆序存储，方便计算
31
    for(int i = 0; i < lb; i++)
32
        b[lb - 1 - i] = y[i] - '0';  // 逆序存储，方便计算
33

34
    // 2. 模拟加法的过程
35
    add(c, a, b);  // 调用高精度加法函数：c = a + b
36

37
    // 输出结果（需要逆序输出，因为存储时是逆序的）
38
    for(int i = lc - 1; i >= 0; i--)
39
        cout << c[i];
40

41
    return 0;
42
}

1
#include <iostream>
2
using namespace std;
3

4
const int N = 1e6 + 10;  // 定义足够大的数组大小
5
int a[N], b[N], c[N];    // a, b存储输入数字，c存储结果
6
int la, lb, lc;          // 分别表示a, b, c的长度
7

8
// 比较两个字符串表示的数字大小
9
bool cmp(string& x, string& y) {
10
    // 先比较长度：长度不同时，长度小的数字小
11
    if(x.size() != y.size())
12
        return x.size() < y.size();
13
    // 长度相同时，按照字典序比较
14
    return x < y;
15
}
16

17
// 高精度减法模板 - c = a - b
18
void sub(int c[], int a[], int b[]) {
19
    for(int i = 0; i < lc; i++) {
20
        c[i] += a[i] - b[i];  // 对应位相减
21

22
        // 如果当前位结果为负数，需要借位
23
        if(c[i] < 0) {
24
            c[i + 1] -= 1;  // 向高位借1
25
            c[i] += 10;     // 当前位加10
26
        }
27
    }
28
    // 处理前导零：去掉结果开头不必要的0
29
    while(lc > 1 && c[lc - 1] == 0)
30
        lc--;
31
}
32

33
int main() {
34
    string x, y;
35
    cin >> x >> y;  // 用字符串读入两个大数
36

37
    // 比较大小，确保用较大的数减较小的数
38
    if(cmp(x, y)) {
39
        swap(x, y);  // 如果x < y，交换两个数
40
        cout << '-'; // 输出负号
41
    }
42

43
    // 1. 拆分每一位，逆序放在数组中
44
    la = x.size();  // 获取第一个数字的长度
45
    lb = y.size();  // 获取第二个数字的长度
46
    lc = max(la, lb);  // 结果长度至少是两个数字中较长的那个
47

48
    // 将字符串转换为数字数组（逆序存储，个位在索引0）
49
    for(int i = 0; i < la; i++)
50
        a[la - i - 1] = x[i] - '0';
51
    for(int i = 0; i < lb; i++)
52
        b[lb - i - 1] = y[i] - '0';
53

54
    // 2. 模拟减法的过程
55
    sub(c, a, b);  // 调用高精度减法函数：c = a - b
56

57
    // 输出结果（需要逆序输出，因为存储时是逆序的）
58
    for(int i = lc - 1; i >= 0; i--)
59
        cout << c[i];
60

61
    return 0;
62
}

1
#include <iostream>
2
using namespace std;
3

4
const int N = 1e6 + 10;  // 定义足够大的数组大小
5
int a[N], b[N], c[N];    // a, b存储输入数字，c存储结果
6
int la, lb, lc;          // 分别表示a, b, c的长度
7

8
// 高精度乘法模板 - c = a * b
9
void mul(int c[], int a[], int b[]) {
10
    // 无进位相乘，然后相加
11
    for(int i = 0; i < la; i++) {
12
        for(int j = 0; j < lb; j++) {
13
            // a的第i位与b的第j位相乘，结果加到c的第i+j位
14
            c[i + j] += a[i] * b[j];
15
        }
16
    }
17

18
    // 统一处理进位
19
    for(int i = 0; i < lc; i++) {
20
        c[i + 1] += c[i] / 10;  // 进位加到下一位
21
        c[i] %= 10;             // 保留当前位的个位数
22
    }
23

24
    // 处理前导零：去掉结果开头不必要的0
25
    while(lc > 1 && c[lc - 1] == 0)
26
        lc--;
27
}
28

29
int main() {
30
    string x, y;
31
    cin >> x >> y;  // 用字符串读入两个大数
32

33
    // 1. 拆分每一位，逆序放在数组中
34
    la = x.size();  // 获取第一个数字的长度
35
    lb = y.size();  // 获取第二个数字的长度
36
    lc = la + lb;   // 乘积的最大可能长度是两个数字长度之和
37

38
    // 将字符串转换为数字数组（逆序存储，个位在索引0）
39
    for(int i = 0; i < la; i++)
40
        a[la - 1 - i] = x[i] - '0';
41
    for(int i = 0; i < lb; i++)
42
        b[lb - 1 - i] = y[i] - '0';
43

44
    // 2. 模拟乘法的过程
45
    mul(c, a, b);  // 调用高精度乘法函数：c = a * b
46

47
    // 输出结果（需要逆序输出，因为存储时是逆序的）
48
    for(int i = lc - 1; i >= 0; i--)
49
        cout << c[i];
50

51
    return 0;
52
}

1
#include <iostream>
2
using namespace std;
3

4
const int N = 1e6 + 10;  // 定义足够大的数组大小
5
typedef long long LL;     // 定义长整型别名
6
int a[N], b, c[N];       // a存储被除数，b存储除数，c存储商
7
int la, lc;              // 分别表示a, c的长度
8

9
// 高精度除法模板 - c = a / b （高精度 / 低精度）
10
void div(int c[], int a[], int b) {
11
    LL t = 0;  // 标记每次除完之后的余数
12

13
    // 从高位到低位遍历被除数
14
    for(int i = la - 1; i >= 0; i--) {
15
        // 计算当前的被除数：余数×10 + 当前位数字
16
        t = t * 10 + a[i];
17

18
        // 计算当前位的商和余数
19
        c[i] = t / b;  // 当前位的商
20
        t %= b;        // 当前位的余数
21
    }
22

23
    // 处理前导0：去掉商开头不必要的0
24
    while(lc > 1 && c[lc - 1] == 0)
25
        lc--;
26
}
27

28
int main() {
29
    string x;
30
    cin >> x >> b;  // 用字符串读入被除数，整数读入除数
31

32
    la = x.size();  // 获取被除数的长度
33

34
    // 将字符串转换为数字数组（逆序存储，个位在索引0）
35
    for(int i = 0; i < la; i++)
36
        a[la - 1 - i] = x[i] - '0';
37

38
    // 模拟除法的过程
39
    lc = la;  // 商的长度初始化为被除数的长度
40
    div(c, a, b);  // 调用高精度除法函数：c = a / b
41

42
    // 输出结果（需要逆序输出，因为存储时是逆序的）
43
    for(int i = lc - 1; i >= 0; i--)
44
        cout << c[i];
45

46
    return 0;
47
}