Algorithm Design——高精度整数四则运算

要注意两种不同的初始化方法以及算法复杂度问题。

/**
    高精度整数的四则运算—— + - * / %
    以进制转换为例，输出X的N进制表示的数

    题目描述 ： 
    将M进制的数X转换为N进制的数输出。

    输入：
    输入的第一行包括两个整数：M和N(2<=M,N<=36)。 下面的一行输入一个数X，
    X是M进制的数，现在要求你将M进制的数X转换成N进制的数输出。 
    输出：
    输出X的N进制表示的数。

    样例输入：
    16 10 F
    样例输出： 
    15
*/

#include<cstdio>
#include<cstring>
#include<cstdlib>
using namespace std;

#define maxDigits 100

////高精度整数类
class bigInteger
{
public:
    int digit[maxDigits];
    int size;

public:
    void init()//初始化
    {
        for(int i = 0 ; i < maxDigits ; i ++)
            digit[i] = 0;

        size = 0;
    }

    void set(int x)//用一个普通整数初始化高精度整数
    {
        init();

        do
        {
            digit[size ++] = x % 10000;
            x /= 10000;
        }while(x != 0);
    }

    void output()//输出
    {
        for(int i = size - 1 ; i >= 0 ; i --)
        {
            if(i != size - 1)
                printf_s("%04d", digit[i]);//先输出数字，然后高位补0
            else
                printf_s("%d", digit[i]);
        }
        printf_s("\n");
    }

    bigInteger operator * (int x) const//高精度整数与普通整数的乘积
    {
        bigInteger ret;
        ret.init();
        int carry = 0;
        for(int i = 0 ; i < size ; i ++)
        {
            int tmp = x * digit[i] + carry;
            carry = tmp / 10000;
            tmp %= 10000;
            ret.digit[ret.size ++] = tmp;
        }
        if(carry != 0)
        {
            ret.digit[ret.size ++] = carry;
        }

        return ret;
    }

    bigInteger operator + (const bigInteger &A) const//高精度整数之间的加法运算
    {
        bigInteger ret;
        ret.init();
        int carry = 0;
        for(int i = 0 ; i < A.size || i < size; i ++)
        {
            int tmp = A.digit[i] + digit[i] + carry;
            carry = tmp / 10000;
            tmp %= 10000;
            ret.digit[ret.size ++] = tmp;
        }
        if(carry != 0)
        {
            ret.digit[ret.size ++] = carry;
        }

        return ret;
    }

    bigInteger operator / (int x) const//高精度整数除以普通整数
    {
        bigInteger ret;
        ret.init();
        int remainder = 0;//余数

        for(int i = size - 1 ; i >= 0 ; i --)//从最高位到最低位依次完成计算
        {
            int t = (remainder * 10000 + digit[i]) / x;//计算当前位数值加上高位剩余的余数的和对x求得的商
            int r = (remainder * 10000 + digit[i]) % x;//计算当前位数值加上高位剩余的余数的和对x求得的余数
            ret.digit[i] = t;//保存本位的值
            remainder = r;//保存至本位为止的余数
        }

        /////返回高精度整数的size初始值为0，即当前所有位数字都是0时，digit[0]代表数字0，最为最高有效位，高精度整数即是数字0=
        ret.size = 0;

        for(int i = 0 ; i < maxDigits ; i ++)//若存在非0位，确定最高的非0位，作为最高有效位
        {
            if(digit[i] != 0)
                ret.size = i;
        }
        ret.size ++;//最高有效位的下一位即为下一个我们不曾使用的digit数组单元，确定size的值
        return ret;
    }

    int operator % (int x) const//高精度整数对普通整数求余数
    {
        int remainder = 0;
        for(int i = size - 1 ; i >= 0 ; i --)
        {
            int t = (remainder * 10000 + digit[i]) / x;
            int r = (remainder * 10000 + digit[i]) % x;
            remainder = r;
        }
        return remainder;
    }
}a, b, c;

char str[10000];
char ans[10000];

int main()
{
    int n, m;
    while(scanf_s("%d%d", &m, &n) != EOF)
    {
        scanf_s("%s", str, _countof(str));//输入m进制数
        int L = strlen(str);
        a.set(0);//a的初始值是0，用来保存转换成10进制的m进制数
        b.set(1);//b的初始值是1，在m进制向10进制转换过程中，一次代表每一位的权重

        for(int i = L - 1 ; i >= 0 ; i --)//从低位到高位转换m进制到相应的10进制数
        {
            int t;
            if(str[i] >= '0' && str[i] <= '9')
            {
                t = str[i] - '0';
            }
            else
                t = str[i] - 'A' + 10;//确定当前位字符代表的数字

            a = a + b * t;//累加当前数字乘以当前权重的乘积
            b = b * m;//计算下一位权重
        }

        int size = 0;//代表转换为n进制后的字符个数
        do{//对转换成的10进制数求其n进制值
            int t = a % n;//求余数

            //确定当前位字符
            if(t >= 10)
                ans[size ++] = t - 10 + 'a';
            else
                ans[size ++] = t + '0';

            a = a / n;//求商
        }while(a.digit[0] != 0 || a.size != 1);//当a不为0时，重复该过程

        for(int i = size - 1 ; i >= 0 ; i --)
            printf_s("%c", ans[i]);
        printf("\n");
    }

    return 0;
}

/**
大整数求和

题目描述： 实现一个加法器，使其能够输出a+b的值。

输入：输入包括两个数a和b，其中a和b的位数不超过1000位。 

输出 ：可能有多组测试数据，对于每组数据，输出a+b的值。

样例输入： 
2 6
10000000000000000000 10000000000000000000000000000000 

样例输出：
8
10000000000010000000000000000000
*/

#include<cstdio>
#include<cstring>
#include<cstdlib>
using namespace std;

class bigInteger
{
public:
    int digit[1000];
    int size;

public:
    void init()
    {
        for(int i = 0 ; i < 1000 ; i ++)
            digit[i] = 0;
        size = 0;
    }

    ////将一个数字字符串转换成一个大数
    void set(char str[])
    {
        init();
        int L = strlen(str);

        for(int i = L - 1, j = 0 , t = 0 , c = 1 ; i >= 0 ; i --)
        {
            t += (str[i] - '0') * c;
            j ++;
            c *= 10;

            if(j == 4 || i == 0)
            {
                digit[size ++] = t;

                j = 0 ;
                t = 0;
                c = 1;
            }
        }
    }

    void output()
    {
        for(int i = size - 1 ; i >= 0 ; i --)
        {
            if(i != size - 1)
                printf_s("%04d", digit[i]);
            else
                printf_s("%d", digit[i]);
        }
        printf_s("\n");
    }

    bigInteger operator + (const bigInteger &A) const
    {
        bigInteger ret;
        ret.init();

        int carry = 0;
        for(int i = 0 ; i < A.size || i < size ; i ++)
        {
            int tmp = A.digit[i] + digit[i] + carry;
            carry = tmp / 10000;
            tmp %= 10000;
            ret.digit[ret.size ++] = tmp;
        }

        if(carry != 0)
        {
            ret.digit[ret.size ++] = carry;
        }

        return ret;
    }
}a, b, c;

char str1[1002], str2[1002];

int main()
{
    while(scanf_s("%s%s", str1, _countof(str1), str2, _countof(str2)) != EOF)
    {
        a.set(str1);
        b.set(str2);
        c = a + b;
        c.output();
    }

    return 0;
}