L老师讲解的大数问题 2013.5.20

模板来自吉林大学acm模板及网络。

老师均添加了一些注释及改进。

第一个，普通的大数运算：

#include <stdio.h>
#include <string.h>
/*==================================================*\
| 普通的大数运算
\*==================================================*/
const int MAXSIZE = 200;
void Add(char *str1, char *str2, char *str3);
//str3: 和
void Minus(char *str1, char *str2, char *str3);
//要求 str1表示的数比str2的大
void Mul(char *str1, char *str2, char *str3);
//str3: 乘积
void Div(char *str1, char *str2, char *str3, char *str4);
//str3:商  str4:余数
//增加str4, by lyh:13/5/19
int main(void)
{
    char str1[MAXSIZE], str2[MAXSIZE], str3[MAXSIZE], str4[MAXSIZE];
    while( scanf("%s %s", str1, str2) == 2 )
    {
        if( strcmp(str1, "0") )
        {
            memset(str3, '0', sizeof(str3)); // !!!!!
            Add(str1, str2, str3);
            printf("Add:%s\n", str3);
            memset(str3, '0', sizeof(str3));
            Minus(str1, str2, str3);
            printf("Minus:%s\n", str3);
            memset(str3, '0', sizeof(str3));
            Mul(str1, str2, str3);
            printf("Mul:%s\n", str3);
            if (strcmp(str2, "0"))
            {//第二个数不为0
                memset(str3, '0', sizeof(str3));
                memset(str4, '0', sizeof(str4));
                Div(str1, str2, str3,str4);
                printf("Div:%s\t%s\n", str3,str4);
            }
        }
        else //第一个数为0的处理
        {
            if( strcmp(str2, "0") )
                printf("%s\n-%s\n0\n0\t0\n", str2, str2);
            else //两个数都为0的处理
                printf("0\n0\n0\n0\t0\n");
        }
    }
    return 0;
}
void Add(char *str1, char *str2, char *str3)
{
    // str3 = str1 + str2;
    int i, j, i1, i2, tmp, carry;
    int len1 = strlen(str1), len2 = strlen(str2);
    char ch;
    i1 = len1-1;
    i2 = len2-1;
    j = carry = 0;
    for( ; i1 >= 0 && i2 >= 0; ++j, --i1, --i2 )
    {
        tmp = str1[i1]-'0'+str2[i2]-'0'+carry;
        carry = tmp/10;
        str3[j] = tmp%10+'0';
    }
    while( i1 >= 0 )
    {
        //处理剩余加数1
        tmp = str1[i1--]-'0'+carry;
        carry = tmp/10;
        str3[j++] = tmp%10+'0';
    }
    while( i2 >= 0 )
    {
        //处理剩余加数2
        tmp = str2[i2--]-'0'+carry;
        carry = tmp/10;
        str3[j++] = tmp%10+'0';
    }
    if( carry ) //最高位进位
        str3[j++] = carry+'0';
    str3[j] = '\0';
    for( i=0, --j; i < j; ++i, --j )
    {
        // 逆序结果
        ch = str3[i];
        str3[i] = str3[j];
        str3[j] = ch;
    }
}
void Minus(char *str1, char *str2, char *str3)
{
    // str3 = str1-str2 (str1 > str2)
    int i, j, i1, i2, tmp, carry;
    int len1 = strlen(str1), len2 = strlen(str2);
    char ch;
    i1 = len1-1;
    i2 = len2-1;
    j = carry = 0;
    while( i2 >= 0 )
    {
        //处理小数str2
        tmp = str1[i1]-str2[i2]-carry;
        if( tmp < 0 )
        {
            str3[j] = tmp+10+'0';
            carry = 1;
        }
        else
        {
            str3[j] = tmp+'0';
            carry = 0;
        }
        --i1;
        --i2;
        ++j;
    }
    while( i1 >= 0 )
    {
        //处理大数str1的剩余部分
        tmp = str1[i1]-'0'-carry;
        if( tmp < 0 )
        {
            str3[j] = tmp+10+'0';
            carry = 1;
        }
        else
        {
            str3[j] = tmp+'0';
            carry = 0;
        }
        --i1;
        ++j;
    }
    --j;
    //删除数字的前导0
    while( str3[j] == '0' && j > 0 ) --j;
    str3[++j] = '\0';
    for( i=0, --j; i < j; ++i, --j )
    {
        // 逆序结果
        ch = str3[i];
        str3[i] = str3[j];
        str3[j] = ch;
    }
}

void Mul(char *str1, char *str2, char *str3)
{
    int i, j, i1, i2, tmp, carry, jj;
    int len1 = strlen(str1), len2 = strlen(str2);
    char ch;
    jj = carry = 0;
    // jj 从最后1位向前依次处理每1位

    for( i1=len1-1; i1 >= 0; --i1 )
    {
        j = jj;  //j从jj开始依次处理每1位
        for( i2=len2-1; i2 >= 0; --i2, ++j )
        {
            tmp = (str3[j]-'0')+(str1[i1]-'0')*(str2[i2]-'0')+carry;
            if( tmp > 9 )
            {
                carry = tmp/10;
                str3[j] = tmp%10+'0';
            }
            else
            {
                str3[j] = tmp+'0';
                carry = 0;
            }
        }
        if( carry )
        {
            //最高位进位
            str3[j] = carry+'0';
            carry = 0;
            ++j;
        }
        ++jj;
    }
    --j;
    //去掉尾部0，即乘法结果的前导0
    while( str3[j] == '0' && j > 0 ) --j;
    str3[++j] = '\0';
    for( i=0, --j; i < j; ++i, --j )
    {
        ch = str3[i];
        str3[i] = str3[j];
        str3[j] = ch;
    }
}

void Div(char *str1, char *str2, char *str3,char *str4)
{
    int i1, i2, i, j, jj, tag, carry, cf, c[MAXSIZE];
    //c 存商
    int len1 = strlen(str1), len2 = strlen(str2), lend;
    char d[MAXSIZE];
    //d  当前被除数,
    memset(c, 0, sizeof(c));
    memcpy(d, str1, len2);
    lend = len2;
    j = 0; //商的位数，含前导0
    for( i1=len2-1; i1 < len1; ++i1 )
    {
        //i1:商在原被除数的位置
        if( lend < len2 )
        {
            //被除数位数小于除数位数，扩充被除数位数
            d[lend] = str1[i1+1];
            c[j] = 0;
            ++j;
            ++lend;
        }
        else if( lend == len2 )
        {
            jj = 1;//被除数与除数位数相同且大于除数
            for( i=0; i < lend; ++i )
            {
                if( d[i] > str2[i] ) break;
                else if( d[i] < str2[i] )
                {
                    jj = 0;
                    break;
                }
            }
            if( jj == 0 )
            {
                //被除数小于除数，被除数再扩充一位
                d[lend] = str1[i1+1];
                c[j] = 0;
                ++j;
                ++lend;
                continue;
            }
        }
        if( jj==1 || lend > len2 )
        {
            //被除数大于除数，或者长度比除数多1位
            cf = jj=0;
            //cf : 是否可以进行除法
            while( d[jj] <= '0' && jj < lend ) ++jj;
            //找到被除数的第一个非0数字
            if( lend-jj > len2 )
                cf = 1;  //被除数长度大于除数
            else if( lend-jj < len2 )
                cf = 0; //被除数长度小于除数
            else
            {
                //被除数长度等于除数
                i2 = 0;
                cf = 1;
                for( i=jj; i < lend; ++i )
                {
                    if( d[i] < str2[i2] )
                    {
                        //被除数小于除数
                        cf = 0;
                        break;
                    }
                    else if( d[i] > str2[i2] )
                    {
                        break;
                    }
                    ++i2;
                }
            }//else
            while( cf )
            {
                //被除数大于除数，求被除数/除数的商（商是1位数）
                i2 = len2-1;
                cf = 0;
                for( i=lend-1; i >= lend-len2; --i )
                {
                    //从末位向前 被除数-除数
                    d[i] = d[i]-str2[i2]+'0';
                    if( d[i] < '0' )
                    {
                        d[i] = d[i]+10;
                        carry = 1;
                        --d[i-1];
                    }
                    else carry = 0;
                    --i2;
                }
                ++c[j]; //累计可以的（被除数-除数）的次数，即商
                //以下代码与上面部分重复，判断被除数是否大于除数
                jj=0;
                while( d[jj] <= '0' && jj < lend ) ++jj;
                if( lend-jj > len2 ) cf = 1;
                else if( lend-jj < len2 ) cf = 0;
                else
                {
                    i2 = 0;
                    cf = 1;
                    for( i=jj; i < lend; ++i )
                    {
                        if( d[i] < str2[i2] )
                        {
                            cf = 0;
                            break;
                        }
                        else if( d[i] > str2[i2] )
                        {
                            break;
                        }
                        ++i2;
                    }
                }//else
            }//while

            jj = 0;
            //整理余数，得到新的被除数
            while( d[jj] <= '0' && jj < lend ) ++jj;
            for( i=0; i < lend-jj; ++i ) d[i] = d[i+jj];
            d[i] = str1[i1+1];
            lend = i+1;
            ++j;
        }//if
    }//for
    i = tag = 0;
    while( c[i] == 0 ) ++i;
    for( ; i < j; ++i, ++tag ) str3[tag] = c[i]+'0';
    str3[tag] = '\0';
//以下内容补充 by lyh:13/5/19
// 数组d 保存余数 
    i = tag = 0;
    while( d[i] == '0' ) ++i;
    while( d[i] != '\0' )
        str4[tag++] = d[i++];
    str4[tag] = '\0';
//商为0时正确返回
    if(str3[0]=='\0')
    {
        str3[0]='0';
        str3[1]='\0';
    }
//余数为0时正确返回
    if(str4[0]=='\0')
    {
        str4[0]='0';
        str4[1]='\0';
    }
}

代码很长，中间代码有冗余，应该还可以优化。

这是一位一位的计算。

第二个，比较高效的大数运算：

#include <stdio.h>
#include <string.h>
/*==================================================*\

 | 比较高效的大数
 | < , <= , + , - , * , / , %(修改/的最后一行可得)

\*==================================================*/

const int base = 10000;    // (base^2) fit into int
const int width = 4;       // width = log base
const int N  = 1000;       // n *  可表示的最大位数
struct bint
{
    int ln, v[N];
    bint (int r = 0)   // r应该是字符串！
    {
        for (ln = 0; r > 0; r /= base) v[ln++] = r % base;
    }
    bint& operator = (const bint& r)
    {
        memcpy(this, &r, (r.ln + 1) * sizeof(int));// !
        return *this;
    }
} ;

bool operator < (const bint& a, const bint& b)
{
    int i;
    if (a.ln != b.ln) return a.ln < b.ln;
    for (i = a.ln - 1; i >= 0 && a.v[i] == b.v[i]; i--);
    return i < 0 ? 0 : a.v[i] < b.v[i];
}

bool operator <= (const bint& a, const bint& b)
{
    return !(b < a);
}

bint operator + (const bint& a, const bint& b)
{
    bint res;
    int i, cy = 0;
    for (i = 0; i < a.ln || i < b.ln || cy > 0; i++)
    {
        if (i < a.ln) cy += a.v[i];
        if (i < b.ln) cy += b.v[i];
        res.v[i] = cy % base;
        cy /= base;
    }
    res.ln = i;
    return res;
}

bint operator - (const bint& a, const bint& b)
{
    bint res;
    int i, cy = 0;
    for (res.ln = a.ln, i = 0; i < res.ln; i++)
    {
        res.v[i] = a.v[i] - cy;
        if (i < b.ln) res.v[i] -= b.v[i];
        if (res.v[i] < 0) cy = 1, res.v[i] += base;
        else cy = 0;
    }
        //去掉结果的前导0，同时修正长度
    while (res.ln > 0 && res.v[res.ln - 1] == 0) res.ln--;
    return res;
}

bint operator * (const bint& a, const bint& b)
{
    bint res;
    res.ln = 0;
    if (0 == b.ln)
    {
        res.v[0] = 0;
        return res;
    }
    int i, j, cy;
    for (i = 0; i < a.ln; i++)
    {
        for (j=cy=0; j < b.ln || cy > 0; j++, cy/= base)
        {
            if (j < b.ln) cy += a.v[i] * b.v[j];
            if (i + j < res.ln) cy += res.v[i + j];
            if (i + j >= res.ln) res.v[res.ln++] = cy % base;
            else res.v[i + j] = cy % base;
        }
    }
    return res;
}
bint operator / (const bint& a, const bint& b)
{    // ! b != 0
    bint tmp, mod, res;
    int i, lf, rg, mid;
    mod.v[0] = mod.ln = 0;
    for (i = a.ln - 1; i >= 0; i--)
    {
        mod = mod * base + a.v[i];
                //试商，找到最大的商
        for (lf = 0, rg = base -1; lf < rg; )
        {
            mid = (lf + rg + 1) / 2;
            if (b * mid <= mod) lf = mid;
            else rg = mid - 1;
        }
        res.v[i] = lf; //商
        mod = mod - b * lf; //余数
    }
    res.ln = a.ln;
    while (res.ln > 0 && res.v[res.ln - 1] == 0) res.ln--;
    return res;          // return mod 就是%运算
}
int digits(bint& a)          // 返回位数
{
    if (a.ln == 0) return 0;
    int l = ( a.ln - 1 ) * 4;
        //最高位可能不足4位，需要逐位确定
    for (int t = a.v[a.ln - 1]; t; ++l, t/=10) ;
    return l;
}
bool read(bint& b, char buf[])  // 读取失败返回0
{
    if (1 != scanf("%s", buf)) return 0;
    int w, u, ln = strlen(buf);
    memset(&b, 0, sizeof(bint));
    if ('0' == buf[0] && 0 == buf[1]) return 1;
    for (w = 1, u = 0; ln; )
    {
        u += (buf[--ln] - '0') * w;
        if (w * 10 == base)
        {
            b.v[b.ln++] = u;
            u = 0;
            w = 1;
        }
        else w *= 10;
    }
    if (w != 1) b.v[b.ln++] = u;
    return 1;
}

void write(const bint& v)
{
    int i;
    printf("%d", v.ln == 0 ? 0 : v.v[v.ln - 1]);
    for (i = v.ln - 2; i >= 0; i--)
        printf("%04d", v.v[i]);  // ! 4 == width
    printf("\n");
}

int main(){
    const int MAXSIZE = 200;
    char str1[MAXSIZE];
    bint b1,b2,b3,b4;
    read(b1, str1);
    read(b2, str1);
    b3=b1+b2;
    write(b3);
    b3=b1-b2;
    write(b3);
    b3=b1*b2;
    write(b3);
    b3=b1/b2;
    write(b3);

    return 0;
}

　　与第一个不同的是，每四位每四位的计算，计算的时候不是用字符串计算，而是直接用原来的除法运算，因为原来的一定要快，大数运算的时候能用原来的加减乘除运算就尽量用原来的。为什么划出四位来，因为9999*9999约等于10^8，而int型数据最高不过能储存10^9位数，当然你也可以用64数运算（longlong）。

　　另外每四位除法运算的时候是用二分法试商，小学老师教我们的时候能凑出来就凑出来，因为基本一眼就看出来了，而正规的做法应该是不断二分试商，直到上界和下界交叉或等于的时候，那个结果就是正确结果。

 第三个，老师提了一下，思路和第二个差不多，只不过更加细化，加了一些东西，老师说“感觉上更快一些”，名字是《捡来的一个大数模板》，来自网络：

//http://www.cnblogs.com/cj695/archive/2012/07/28/2613678.html
#include <iostream>    
#include <cstring>    
using namespace std;    
    
#define DIGIT   4      //四位隔开,即万进制    
#define DEPTH   10000        //万进制    
#define MAX     251    //题目最大位数/4，要不大直接设为最大位数也行 
typedef int bignum_t[MAX+1];    //a[0] 用作临时变量
     
/************************************************************************/   
/* 读取操作数，对操作数进行处理存储在数组里                             */   
/************************************************************************/   
int read(bignum_t a,istream&is=cin)    
{    
    char buf[MAX*DIGIT+1],ch ;    
    int i,j ;    
    memset((void*)a,0,sizeof(bignum_t));    
    if(!(is>>buf))return 0 ;    
//字符串buf逆序，a[0] 初始化为字符串长度
    for(a[0]=strlen(buf),i=a[0]/2-1;i>=0;i--)    
    ch=buf[i],buf[i]=buf[a[0]-1-i],buf[a[0]-1-i]=ch ;    
//把数据补足为4(DIGIT)位 ,前面+0
    for(a[0]=(a[0]+DIGIT-1)/DIGIT,j=strlen(buf);j<a[0]*DIGIT;buf[j++]='0');    
//将buf中数据每4个一组依次存入a 
    for(i=1;i<=a[0];i++)    
    for(a[i]=0,j=0;j<DIGIT;j++)    
    a[i]=a[i]*10+buf[i*DIGIT-1-j]-'0' ;    
//取掉数字的前导0
    for(;!a[a[0]]&&a[0]>1;a[0]--);    
    return 1 ;    
}    
     
void write(const bignum_t a,ostream&os=cout)    
{    
    int i,j ;    
//逆序输出数组 a[],高位在后
    for(os<<a[i=a[0]],i--;i;i--)    
//输出每个a[i]的前导0，如果 a[i]=123,输出 0123，补足4位
    for(j=DEPTH/10;j;j/=10)    
    os<<a[i]/j%10 ;    
}     
     
int comp(const bignum_t a,const bignum_t b)    
{    
    int i ;    
//长度不相同
    if(a[0]!=b[0])     
    return a[0]-b[0];    
//从高到低逐位比较
    for(i=a[0];i;i--)    
    if(a[i]!=b[i])    
    return a[i]-b[i];    
    return 0 ;    
}    
     
int comp(const bignum_t a,const int b)    
{    
    int c[12]=    
    {    
        1     
    }    
    ;
//把整数 b 转换为 4个一组的万进制存贮      
    for(c[1]=b;c[c[0]]>=DEPTH;c[c[0]+1]=c[c[0]]/DEPTH,c[c[0]]%=DEPTH,c[0]++);    
//调用其他重载
    return comp(a,c);    
}    
     
int comp(const bignum_t a,const int c,const int d,const bignum_t b)    
{    
// 测试 a * c 是否大于b ，d 表示 
    int i,t=0,O=-DEPTH*2 ;    
    if(b[0]-a[0]<d&&c)    
    return 1 ;    
    for(i=b[0];i>d;i--)    
    {    
        t=t*DEPTH+a[i-d]*c-b[i];    
        if(t>0)return 1 ;    
        if(t<O)return 0 ;    
    }    
    for(i=d;i;i--)    
    {    
        t=t*DEPTH-b[i];    
        if(t>0)return 1 ;    
        if(t<O)return 0 ;    
    }    
    return t>0 ;    
}    
/************************************************************************/   
/* 大数与大数相加                                                       */   
/************************************************************************/   
void add(bignum_t a,const bignum_t b)    
{    
    int i ;    
    for(i=1;i<=b[0];i++)    
    if((a[i]+=b[i])>=DEPTH)    
    a[i]-=DEPTH,a[i+1]++;    
    if(b[0]>=a[0])    
    a[0]=b[0];    
    else    
    for(;a[i]>=DEPTH&&i<a[0];a[i]-=DEPTH,i++,a[i]++);    
    a[0]+=(a[a[0]+1]>0);    
}    
/************************************************************************/   
/* 大数与小数相加                                                       */   
/************************************************************************/   
void add(bignum_t a,const int b)    
{    
    int i=1 ;    
    for(a[1]+=b;a[i]>=DEPTH&&i<a[0];a[i+1]+=a[i]/DEPTH,a[i]%=DEPTH,i++);    
    for(;a[a[0]]>=DEPTH;a[a[0]+1]=a[a[0]]/DEPTH,a[a[0]]%=DEPTH,a[0]++);    
}    
/************************************************************************/   
/* 大数相减(被减数>=减数)                                               */   
/************************************************************************/   
void sub(bignum_t a,const bignum_t b)    
{    
    int i ;    
    for(i=1;i<=b[0];i++)    
    if((a[i]-=b[i])<0)    
    a[i+1]--,a[i]+=DEPTH ;    
    for(;a[i]<0;a[i]+=DEPTH,i++,a[i]--);    
    for(;!a[a[0]]&&a[0]>1;a[0]--);    
}    
/************************************************************************/   
/* 大数减去小数(被减数>=减数)                                           */   
/************************************************************************/   
void sub(bignum_t a,const int b)    
{    
    int i=1 ;    
    for(a[1]-=b;a[i]<0;a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH,i++);    
    for(;!a[a[0]]&&a[0]>1;a[0]--);    
}    
     
void sub(bignum_t a,const bignum_t b,const int c,const int d)    
{    
    int i,O=b[0]+d ;    
    for(i=1+d;i<=O;i++)    
    if((a[i]-=b[i-d]*c)<0)    
    a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH ;    
    for(;a[i]<0;a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH,i++);    
    for(;!a[a[0]]&&a[0]>1;a[0]--);    
}    
/************************************************************************/   
/* 大数相乘，读入被乘数a，乘数b，结果保存在c[]                          */   
/************************************************************************/   
void mul(bignum_t c,const bignum_t a,const bignum_t b)    
{    
    int i,j ;    
    memset((void*)c,0,sizeof(bignum_t));    
    for(c[0]=a[0]+b[0]-1,i=1;i<=a[0];i++)    
    for(j=1;j<=b[0];j++)    
    if((c[i+j-1]+=a[i]*b[j])>=DEPTH)    
    c[i+j]+=c[i+j-1]/DEPTH,c[i+j-1]%=DEPTH ;    
    for(c[0]+=(c[c[0]+1]>0);!c[c[0]]&&c[0]>1;c[0]--);    
}    
/************************************************************************/   
/* 大数乘以小数，读入被乘数a，乘数b，结果保存在被乘数                   */   
/************************************************************************/   
void mul(bignum_t a,const int b)    
{    
    int i ;    
    for(a[1]*=b,i=2;i<=a[0];i++)    
    {    
        a[i]*=b ;    
        if(a[i-1]>=DEPTH)    
        a[i]+=a[i-1]/DEPTH,a[i-1]%=DEPTH ;    
    }    
    for(;a[a[0]]>=DEPTH;a[a[0]+1]=a[a[0]]/DEPTH,a[a[0]]%=DEPTH,a[0]++);    
    for(;!a[a[0]]&&a[0]>1;a[0]--);    
}    
     
void mul(bignum_t b,const bignum_t a,const int c,const int d)    
{    
    int i ;    
    memset((void*)b,0,sizeof(bignum_t));    
    for(b[0]=a[0]+d,i=d+1;i<=b[0];i++)    
    if((b[i]+=a[i-d]*c)>=DEPTH)    
    b[i+1]+=b[i]/DEPTH,b[i]%=DEPTH ;    
    for(;b[b[0]+1];b[0]++,b[b[0]+1]=b[b[0]]/DEPTH,b[b[0]]%=DEPTH);    
    for(;!b[b[0]]&&b[0]>1;b[0]--);    
}    
/**************************************************************************/   
/* 大数相除,读入被除数a，除数b，结果保存在c[]数组                         */   
/* 需要comp()函数                                                         */   
/**************************************************************************/   
void div(bignum_t c,bignum_t a,const bignum_t b)    
{    
    int h,l,m,i ;    
    memset((void*)c,0,sizeof(bignum_t));    
    c[0]=(b[0]<a[0]+1)?(a[0]-b[0]+2):1 ;    
    for(i=c[0];i;sub(a,b,c[i]=m,i-1),i--)    
    for(h=DEPTH-1,l=0,m=(h+l+1)>>1;h>l;m=(h+l+1)>>1)    
    if(comp(b,m,i-1,a))h=m-1 ;    
    else l=m ;    
    for(;!c[c[0]]&&c[0]>1;c[0]--);    
    c[0]=c[0]>1?c[0]:1 ;    
}    
     
void div(bignum_t a,const int b,int&c)    
{    
    int i ;    
    for(c=0,i=a[0];i;c=c*DEPTH+a[i],a[i]=c/b,c%=b,i--);    
    for(;!a[a[0]]&&a[0]>1;a[0]--);    
}    
/************************************************************************/   
/* 大数平方根，读入大数a，结果保存在b[]数组里                           */   
/* 需要comp()函数                                                       */   
/************************************************************************/   
void sqrt(bignum_t b,bignum_t a)    
{    
    int h,l,m,i ;    
    memset((void*)b,0,sizeof(bignum_t));    
    for(i=b[0]=(a[0]+1)>>1;i;sub(a,b,m,i-1),b[i]+=m,i--)    
    for(h=DEPTH-1,l=0,b[i]=m=(h+l+1)>>1;h>l;b[i]=m=(h+l+1)>>1)    
    if(comp(b,m,i-1,a))h=m-1 ;    
    else l=m ;    
    for(;!b[b[0]]&&b[0]>1;b[0]--);    
    for(i=1;i<=b[0];b[i++]>>=1);    
}    
/************************************************************************/   
/* 返回大数的长度                                                       */   
/************************************************************************/   
int length(const bignum_t a)    
{    
    int t,ret ;    
    for(ret=(a[0]-1)*DIGIT,t=a[a[0]];t;t/=10,ret++);    
    return ret>0?ret:1 ;    
}    
/************************************************************************/   
/* 返回指定位置的数字，从低位开始数到第b位，返回b位上的数               */   
/************************************************************************/   
int digit(const bignum_t a,const int b)    
{    
    int i,ret ;    
    for(ret=a[(b-1)/DIGIT+1],i=(b-1)%DIGIT;i;ret/=10,i--);    
    return ret%10 ;    
}    
/************************************************************************/   
/* 返回大数末尾0的个数                                                  */   
/************************************************************************/   
int zeronum(const bignum_t a)    
{    
    int ret,t ;    
    for(ret=0;!a[ret+1];ret++);    
    for(t=a[ret+1],ret*=DIGIT;!(t%10);t/=10,ret++);    
    return ret ;    
}    
     
void comp(int*a,const int l,const int h,const int d)    
{    
    int i,j,t ;    
    for(i=l;i<=h;i++)    
    for(t=i,j=2;t>1;j++)    
    while(!(t%j))    
    a[j]+=d,t/=j ;    
}    
     
void convert(int*a,const int h,bignum_t b)    
{    
    int i,j,t=1 ;    
    memset(b,0,sizeof(bignum_t));    
    for(b[0]=b[1]=1,i=2;i<=h;i++)    
    if(a[i])    
    for(j=a[i];j;t*=i,j--)    
    if(t*i>DEPTH)    
    mul(b,t),t=1 ;    
    mul(b,t);    
}    
/************************************************************************/   
/* 组合数                                                               */   
/************************************************************************/   
void combination(bignum_t a,int m,int n)    
{    
    int*t=new int[m+1];    
    memset((void*)t,0,sizeof(int)*(m+1));    
    comp(t,n+1,m,1);    
    comp(t,2,m-n,-1);    
    convert(t,m,a);    
    delete[]t ;    
}    
/************************************************************************/   
/* 排列数                                                               */   
/************************************************************************/   
void permutation(bignum_t a,int m,int n)    
{    
    int i,t=1 ;    
    memset(a,0,sizeof(bignum_t));    
    a[0]=a[1]=1 ;    
    for(i=m-n+1;i<=m;t*=i++)    
    if(t*i>DEPTH)    
    mul(a,t),t=1 ;    
    mul(a,t);    
}    
    
#define SGN(x) ((x)>0?1:((x)<0?-1:0))    
#define ABS(x) ((x)>0?(x):-(x))    
     
int read(bignum_t a,int&sgn,istream&is=cin)    
{    
    char str[MAX*DIGIT+2],ch,*buf ;    
    int i,j ;    
    memset((void*)a,0,sizeof(bignum_t));    
    if(!(is>>str))return 0 ;    
    buf=str,sgn=1 ;    
    if(*buf=='-')sgn=-1,buf++;    
    for(a[0]=strlen(buf),i=a[0]/2-1;i>=0;i--)    
    ch=buf[i],buf[i]=buf[a[0]-1-i],buf[a[0]-1-i]=ch ;    
    for(a[0]=(a[0]+DIGIT-1)/DIGIT,j=strlen(buf);j<a[0]*DIGIT;buf[j++]='0');    
    for(i=1;i<=a[0];i++)    
    for(a[i]=0,j=0;j<DIGIT;j++)    
    a[i]=a[i]*10+buf[i*DIGIT-1-j]-'0' ;    
    for(;!a[a[0]]&&a[0]>1;a[0]--);    
    if(a[0]==1&&!a[1])sgn=0 ;    
    return 1 ;    
}    
struct bignum     
{    
    bignum_t num ;    
    int sgn ;    
    public :    
    inline bignum()    
    {    
        memset(num,0,sizeof(bignum_t));    
        num[0]=1 ;    
        sgn=0 ;    
    }    
    inline int operator!()    
    {    
        return num[0]==1&&!num[1];    
    }    
    inline bignum&operator=(const bignum&a)    
    {    
        memcpy(num,a.num,sizeof(bignum_t));    
        sgn=a.sgn ;    
        return*this ;    
    }    
    inline bignum&operator=(const int a)    
    {    
        memset(num,0,sizeof(bignum_t));    
        num[0]=1 ;    
        sgn=SGN (a);    
        add(num,sgn*a);    
        return*this ;    
    }    
    ;    
    inline bignum&operator+=(const bignum&a)    
    {    
        if(sgn==a.sgn)add(num,a.num);    
        else if            
        (sgn&&a.sgn)    
        {    
            int ret=comp(num,a.num);    
            if(ret>0)sub(num,a.num);    
            else if(ret<0)    
            {    
                bignum_t t ;    
                memcpy(t,num,sizeof(bignum_t));    
                memcpy(num,a.num,sizeof(bignum_t));    
                sub (num,t);    
                sgn=a.sgn ;    
            }    
            else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;    
        }    
        else if(!sgn)    
            memcpy(num,a.num,sizeof(bignum_t)),sgn=a.sgn ;    
        return*this ;    
    }    
    inline bignum&operator+=(const int a)    
    {    
        if(sgn*a>0)add(num,ABS(a));    
        else if(sgn&&a)    
        {    
            int  ret=comp(num,ABS(a));    
            if(ret>0)sub(num,ABS(a));    
            else if(ret<0)    
            {    
                bignum_t t ;    
                memcpy(t,num,sizeof(bignum_t));    
                memset(num,0,sizeof(bignum_t));    
                num[0]=1 ;    
                add(num,ABS (a));    
                sgn=-sgn ;    
                sub(num,t);    
            }    
            else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;    
        }    
        else if    
            (!sgn)sgn=SGN(a),add(num,ABS(a));    
        return*this ;    
    }    
    inline bignum operator+(const bignum&a)    
    {    
        bignum ret ;    
        memcpy(ret.num,num,sizeof (bignum_t));    
        ret.sgn=sgn ;    
        ret+=a ;    
        return ret ;    
    }    
    inline bignum operator+(const int a)    
    {    
        bignum ret ;    
        memcpy(ret.num,num,sizeof (bignum_t));    
        ret.sgn=sgn ;    
        ret+=a ;    
        return ret ;    
    }    
    inline bignum&operator-=(const bignum&a)    
    {    
        if(sgn*a.sgn<0)add(num,a.num);    
        else if            
        (sgn&&a.sgn)    
        {    
            int ret=comp(num,a.num);    
            if(ret>0)sub(num,a.num);    
            else if(ret<0)    
            {    
                bignum_t t ;    
                memcpy(t,num,sizeof(bignum_t));    
                memcpy(num,a.num,sizeof(bignum_t));    
                sub(num,t);    
                sgn=-sgn ;    
            }    
            else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;    
        }    
        else if(!sgn)add (num,a.num),sgn=-a.sgn ;    
        return*this ;    
    }    
    inline bignum&operator-=(const int a)    
    {    
        if(sgn*a<0)add(num,ABS(a));    
        else if(sgn&&a)    
        {    
            int  ret=comp(num,ABS(a));    
            if(ret>0)sub(num,ABS(a));    
            else if(ret<0)    
            {    
                bignum_t t ;    
                memcpy(t,num,sizeof(bignum_t));    
                memset(num,0,sizeof(bignum_t));    
                num[0]=1 ;    
                add(num,ABS(a));    
                sub(num,t);    
                sgn=-sgn ;    
            }    
            else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;    
        }    
        else if    
            (!sgn)sgn=-SGN(a),add(num,ABS(a));    
        return*this ;    
    }    
    inline bignum operator-(const bignum&a)    
    {    
        bignum ret ;    
        memcpy(ret.num,num,sizeof(bignum_t));    
        ret.sgn=sgn ;    
        ret-=a ;    
        return ret ;    
    }    
    inline bignum operator-(const int a)    
    {    
        bignum ret ;    
        memcpy(ret.num,num,sizeof(bignum_t));    
        ret.sgn=sgn ;    
        ret-=a ;    
        return ret ;    
    }    
    inline bignum&operator*=(const bignum&a)    
    {    
        bignum_t t ;    
        mul(t,num,a.num);    
        memcpy(num,t,sizeof(bignum_t));    
        sgn*=a.sgn ;    
        return*this ;    
    }    
    inline bignum&operator*=(const int a)    
    {    
        mul(num,ABS(a));    
        sgn*=SGN(a);    
        return*this ;    
    }    
    inline bignum operator*(const bignum&a)    
    {    
        bignum ret ;    
        mul(ret.num,num,a.num);    
        ret.sgn=sgn*a.sgn ;    
        return ret ;    
    }    
    inline bignum operator*(const int a)    
    {    
        bignum ret ;    
        memcpy(ret.num,num,sizeof (bignum_t));    
        mul(ret.num,ABS(a));    
        ret.sgn=sgn*SGN(a);    
        return ret ;    
    }    
    inline bignum&operator/=(const bignum&a)    
    {    
        bignum_t t ;    
        div(t,num,a.num);    
        memcpy (num,t,sizeof(bignum_t));    
        sgn=(num[0]==1&&!num[1])?0:sgn*a.sgn ;    
        return*this ;    
    }    
    inline bignum&operator/=(const int a)    
    {    
        int t ;    
        div(num,ABS(a),t);    
        sgn=(num[0]==1&&!num [1])?0:sgn*SGN(a);    
        return*this ;    
    }    
    inline bignum operator/(const bignum&a)    
    {    
        bignum ret ;    
        bignum_t t ;    
        memcpy(t,num,sizeof(bignum_t));    
        div(ret.num,t,a.num);    
        ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn*a.sgn ;    
        return ret ;    
    }    
    inline bignum operator/(const int a)    
    {    
        bignum ret ;    
        int t ;    
        memcpy(ret.num,num,sizeof(bignum_t));    
        div(ret.num,ABS(a),t);    
        ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn*SGN(a);    
        return ret ;    
    }    
    inline bignum&operator%=(const bignum&a)    
    {    
        bignum_t t ;    
        div(t,num,a.num);    
        if(num[0]==1&&!num[1])sgn=0 ;    
        return*this ;    
    }    
    inline int operator%=(const int a)    
    {    
        int t ;    
        div(num,ABS(a),t);    
        memset(num,0,sizeof (bignum_t));    
        num[0]=1 ;    
        add(num,t);    
        return t ;    
    }    
    inline bignum operator%(const bignum&a)    
    {    
        bignum ret ;    
        bignum_t t ;    
        memcpy(ret.num,num,sizeof(bignum_t));    
        div(t,ret.num,a.num);    
        ret.sgn=(ret.num[0]==1&&!ret.num [1])?0:sgn ;    
        return ret ;    
    }    
    inline int operator%(const int a)    
    {    
        bignum ret ;    
        int t ;    
        memcpy(ret.num,num,sizeof(bignum_t));    
        div(ret.num,ABS(a),t);    
        memset(ret.num,0,sizeof(bignum_t));    
        ret.num[0]=1 ;    
        add(ret.num,t);    
        return t ;    
    }    
    inline bignum&operator++()    
    {    
        *this+=1 ;    
        return*this ;    
    }    
    inline bignum&operator--()    
    {    
        *this-=1 ;    
        return*this ;    
    }    
    ;    
    inline int operator>(const bignum&a)    
    {    
        return sgn>0?(a.sgn>0?comp(num,a.num)>0:1):(sgn<0?(a.sgn<0?comp(num,a.num)<0:0):a.sgn<0);    
    }    
    inline int operator>(const int a)    
    {    
        return sgn>0?(a>0?comp(num,a)>0:1):(sgn<0?(a<0?comp(num,-a)<0:0):a<0);    
    }    
    inline int operator>=(const bignum&a)    
    {    
        return sgn>0?(a.sgn>0?comp(num,a.num)>=0:1):(sgn<0?(a.sgn<0?comp(num,a.num)<=0:0):a.sgn<=0);    
    }    
    inline int operator>=(const int a)    
    {    
        return sgn>0?(a>0?comp(num,a)>=0:1):(sgn<0?(a<0?comp(num,-a)<=0:0):a<=0);    
    }    
    inline int operator<(const bignum&a)    
    {    
        return sgn<0?(a.sgn<0?comp(num,a.num)>0:1):(sgn>0?(a.sgn>0?comp(num,a.num)<0:0):a.sgn>0);    
    }    
    inline int operator<(const int a)    
    {    
        return sgn<0?(a<0?comp(num,-a)>0:1):(sgn>0?(a>0?comp(num,a)<0:0):a>0);    
    }    
    inline int operator<=(const bignum&a)    
    {    
        return sgn<0?(a.sgn<0?comp(num,a.num)>=0:1):(sgn>0?(a.sgn>0?comp(num,a.num)<=0:0):a.sgn>=0);    
    }    
    inline int operator<=(const int a)    
    {    
        return sgn<0?(a<0?comp(num,-a)>=0:1):    
        (sgn>0?(a>0?comp(num,a)<=0:0):a>=0);    
    }    
    inline int operator==(const bignum&a)    
    {    
        return(sgn==a.sgn)?!comp(num,a.num):0 ;    
    }    
    inline int operator==(const int a)    
    {    
        return(sgn*a>=0)?!comp(num,ABS(a)):0 ;    
    }    
    inline int operator!=(const bignum&a)    
    {    
        return(sgn==a.sgn)?comp(num,a.num):1 ;    
    }    
    inline int operator!=(const int a)    
    {    
        return(sgn*a>=0)?comp(num,ABS(a)):1 ;    
    }    
    inline int operator[](const int a)    
    {    
        return digit(num,a);    
    }    
    friend inline istream&operator>>(istream&is,bignum&a)    
    {    
        read(a.num,a.sgn,is);    
        return  is ;    
    }    
    friend inline ostream&operator<<(ostream&os,const bignum&a)    
    {    
        if(a.sgn<0)    
            os<<'-' ;    
        write(a.num,os);    
        return os ;    
    }    
    friend inline bignum sqrt(const bignum&a)    
    {    
        bignum ret ;    
        bignum_t t ;    
        memcpy(t,a.num,sizeof(bignum_t));    
        sqrt(ret.num,t);    
        ret.sgn=ret.num[0]!=1||ret.num[1];    
        return ret ;    
    }    
    friend inline bignum sqrt(const bignum&a,bignum&b)    
    {    
        bignum ret ;    
        memcpy(b.num,a.num,sizeof(bignum_t));    
        sqrt(ret.num,b.num);    
        ret.sgn=ret.num[0]!=1||ret.num[1];    
        b.sgn=b.num[0]!=1||ret.num[1];    
        return ret ;    
    }    
    inline int length()    
    {    
        return :: length(num);    
    }    
    inline int zeronum()    
    {    
        return :: zeronum(num);    
    }    
    inline bignum C(const int m,const int n)    
    {    
        combination(num,m,n);    
        sgn=1 ;    
        return*this ;    
    }    
    inline bignum P(const int m,const int n)    
    {    
        permutation(num,m,n);    
        sgn=1 ;    
        return*this ;    
    }    
};   
int main()    
{       
    bignum a,b,c;       
    cin>>a>>b;      
    cout<<"加法:"<<a+b<<endl;    
    cout<<"减法:"<<a-b<<endl;    
    cout<<"乘法:"<<a*b<<endl;    
    cout<<"除法:"<<a/b<<endl;       
    c=sqrt(a);    
    cout<<"平方根:"<<c<<endl;    
    cout<<"a的长度:"<<a.length()<<endl;    
    cout<<"a的末尾0个数:"<<a.zeronum()<<endl<<endl;    
    cout<<"组合: 从10个不同元素取3个元素组合的所有可能性为"<<c.C(10,3)<<endl;    
    cout<<"排列: 从10个不同元素取3个元素排列的所有可能性为"<<c.P(10,3)<<endl;    
    return 0 ;    
}