练手：大数运算

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#define MAX_LENGTH 1000

#define Char2Num(Char) (Char - '0')
#define Num2Char(Num) ((char)(Num + '0'))

char gacInput[MAX_LENGTH];
char gacResult[MAX_LENGTH];
char gacRemainder[MAX_LENGTH];

void GetInput()
{
    int wLoop = -1;
    while('\n' != (gacInput[++wLoop] = getchar()));
    gacInput[wLoop] = '\0';
}

void TurnResult(char *acArray)
{
    char tmp;
    int i = 0;
    int len = strlen(acArray);
    for(i=0; i<(int)(len/2); i++)
    {
        tmp = acArray[len-1-i];
        acArray[len-1-i] = acArray[i];
        acArray[i] = tmp;
    }
}

void KillZero(char *acArray)
{
    int i = strlen(acArray);
    while(acArray[i-1] == '0' && i>1)
    {
        acArray[i-1] = '\0';
        i--;
    }
}

void TidyResult()
{
    KillZero(gacResult);
    TurnResult(gacResult);
}

void Add(char *acArray, int wLength, int wLablePosition)
{
    char *Num1 = NULL;
    char *Num2 = NULL;
    int wNum1Length = wLablePosition;
    int wNum2Length = wLength - wLablePosition - 1;
    int wTmp = 0;

    if (wNum1Length > wNum2Length)
    {
       Num1 = &acArray[0];
       Num2 = &acArray[wLablePosition+1];
    }
    else
    {
        Num1 = &acArray[wLablePosition+1];
        Num2 = &acArray[0];
        wTmp = wNum1Length;
        wNum1Length = wNum2Length;
        wNum2Length = wTmp;
    }

    int wResult = 0;
    int wCarry = 0;
    int i = 0;
    char acTmpResult[MAX_LENGTH] = {0};

    while(i < wNum1Length || wCarry != 0)
    {
        wResult = ((i > wNum1Length-1)? 0 : Char2Num(Num1[wNum1Length-i-1]))
                + ((i > wNum2Length-1)? 0 : Char2Num(Num2[wNum2Length-i-1]))
                        + wCarry;
        wCarry = (int)(wResult / 10);
        acTmpResult[i] = Num2Char(wResult - wCarry * 10);
        i++;
    }
    memset(gacResult, 0, sizeof(gacResult));
    strcpy(gacResult, acTmpResult);
}

void Minus(char *acArray, int wLength, int wLablePosition)
{
    char *Num1 = &acArray[0];
    char *Num2 = &acArray[wLablePosition+1];
    int wNum1Length = wLablePosition;
    int wNum2Length = wLength - wLablePosition - 1;

    int wResult = 0;
    int wBorrow = 0;
    int i = 0;
    int j = 0;
    char acTmpResult[MAX_LENGTH] = {0};

    while(i < wNum1Length || wBorrow != 0)
    {
        wBorrow = (i > wNum2Length-1 || Num1[wNum1Length-i-1] >= Num2[wNum2Length-i-1])? 0 : 1;
        if (wBorrow == 0)
        {
            wResult = Num1[wNum1Length-i-1] - ((i > wNum2Length-1)? '0' : Num2[wNum2Length-i-1]);
        }
        else
        {
            for(j=0; Num1[wNum1Length-i-2-j] == '0'; j++)
            {
                Num1[wNum1Length-i-2-j] = '9';
            }
            Num1[wNum1Length-i-2-j] = (char)(Num1[wNum1Length-i-2-j] - 1);
            wResult = Char2Num(Num1[wNum1Length-i-1]) + 10 - Char2Num((i > wNum2Length-1)? '0' : Num2[wNum2Length-i-1]);
        }
        acTmpResult[i] = Num2Char(wResult);
        i++;
    }
    memset(gacResult, 0, sizeof(gacResult));
    strcpy(gacResult, acTmpResult);
}

void Calc(char *acArray);

void Multiply(char *acArray, int wLength, int wLablePosition)
{
    char *Num1 = &acArray[0];
    char *Num2 = &acArray[wLablePosition+1];
    int wNum1Length = wLablePosition;
    int wNum2Length = wLength - wLablePosition - 1;

    char acTmpResult[MAX_LENGTH] = {0};
    int wResult = 0;
    int wCarry = 0;
    int i = 0;
    int j = 0;
    memset(gacResult, 0, sizeof(gacResult));
    for(i=0; i<wNum2Length; i++)
    {
        if(i!=0)
        {
            gacResult[strlen(gacResult)] = '+';
        }
        for(j=0; j<wNum1Length || wCarry != 0; j++)
        {
            wResult = ((i > wNum2Length-1)? 0 : Char2Num(Num2[wNum2Length-i-1]))
                    * ((j > wNum1Length-1)? 0 : Char2Num(Num1[wNum1Length-j-1]))
                    + wCarry;
            wCarry = (int)(wResult / 10);
            acTmpResult[j] = Num2Char(wResult - wCarry * 10);
        }
        TurnResult(acTmpResult);
        for(j=0; j<i; j++)
        {
            acTmpResult[strlen(acTmpResult)] ='0';
        }
        strcat(gacResult, acTmpResult);
        memset(acTmpResult, 0, sizeof(acTmpResult));
        Calc(gacResult);
    }
}

int CmpStr(char *str1, char *str2)
{
    if(strlen(str1) == strlen(str2))
    {
        return strcmp(str1,str2);
    }
    else if(strlen(str1) > strlen(str2))
    {
        return 1;
    }
    else
        return -1;
}

void Div(char *acArray, int wLength, int wLablePosition)
{
    char *Num1 = &acArray[0];
    char *Num2 = &acArray[wLablePosition+1];
    int wNum1Length = wLablePosition;
    int wNum2Length = wLength - wLablePosition - 1;

    int i = 0;
    int wSP = wNum2Length-1;
    char acTmpNum3[MAX_LENGTH] = {0};
    char acTmpRemainder[MAX_LENGTH] = {0};
    char acTmpResult[MAX_LENGTH] = {0};
    char acTmpMulResult[MAX_LENGTH] = {0};
    for(i=0; i<2; i++)
    {
        wSP++;
        strncpy(acTmpNum3, Num1, wSP);
        if(strcmp(acTmpNum3, Num2) >= 0) break;
    };

    int j = 0;
    int k = 0;
    for(j=wSP; j<=wNum1Length; j++)
    {
        for(i=9; i>0; i--)
        {
            sprintf(acTmpMulResult, "%c*%s", Num2Char(i), Num2);
            Calc(acTmpMulResult);
            if(CmpStr(gacResult, acTmpNum3) <= 0)
            {
                memset(acTmpRemainder, 0, sizeof(acTmpRemainder));
                acTmpResult[k++] = Num2Char(i);
                sprintf(acTmpMulResult, "%s-%s", acTmpNum3, gacResult);
                Calc(acTmpMulResult);
                strcpy(acTmpRemainder, gacResult);
                if(gacResult[0] != '0')
                {
                    memset(acTmpNum3, 0, sizeof(acTmpNum3));
                    strcpy(acTmpNum3, gacResult);
                }
                else
                    memset(acTmpNum3, 0, sizeof(acTmpNum3));
                break;
            }
        }
        if(i == 0)
        {
            acTmpResult[k++] = '0';
            strcpy(acTmpRemainder, acTmpNum3);
        }
        TurnResult(acTmpNum3);
        KillZero(acTmpNum3);
        TurnResult(acTmpNum3);
        acTmpNum3[strlen(acTmpNum3)] = Num1[j];
    }
    TurnResult(acTmpRemainder);
    KillZero(acTmpRemainder);
    TurnResult(acTmpRemainder);
    strcpy(gacRemainder, acTmpRemainder);
    memset(gacResult, 0, sizeof(gacResult));
    strcpy(gacResult, acTmpResult);
}

void Calc(char *acArray)
{
    int i = 0;
    int wLength = strlen(acArray);
    while( acArray[i] != '\0' )
    {
        switch(acArray[i])
        {
        case '+':
            Add(acArray, wLength, i);
            TidyResult();
            return;
        case '-':
            Minus(acArray, wLength, i);
            TidyResult();
            return;
        case '*':
            Multiply(acArray, wLength, i);
            return;
        case '/':
            Div(acArray, wLength, i);
            return;
        default:
            i++;
        }
    }
}

int main(void)
{
    GetInput();
    Calc(gacInput);
    printf("%s = %s...%s \n length of gacInput: %d\n length of gacResult: %d\n length of gacRemainder: %d\n",
            gacInput, gacResult, gacRemainder, strlen(gacInput), strlen(gacResult), strlen(gacRemainder));

    return 0;
}

 说明：算法参见手工算法。仅支持整数运算。