题解 | #高精度整数加法#

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

#define MAX_LEN (10002)
#define ADDITIONAL_LEN (4)
#define LEFT_OFFSET (1)

static void add(const char* s1, int len1, const char* s2, int len2, char* ans, int len);

static void sub(const char* s1, int len1, const char* s2, int len2, char* ans, int len);

char * long_integer_add(char * s1,int len1, char * s2,int len2)
{
    char* ans; int real_len;
    int len = len1 > len2 ? len1 : len2;
    int max_len = len + ADDITIONAL_LEN;
    ans = (char*)malloc(max_len * sizeof(char));
    memset(ans, 0, max_len * sizeof(char));

    char s1_ch = *(s1); char s2_ch = *(s2);
    // decide to use add or use sub 
    if (s1_ch == '-' && s2_ch == '-')
    {
        // two negative numbers
        s1 = s1 + 1; len1 = len1 - 1;
        s2 = s2 + 1; len2 = len2 - 1;
        add(s1, len1, s2, len2, ans, max_len);
        int i = 0;
        for (; i < max_len; i++) {
            if (*(ans + i) != '\0') {
                *(ans + i - 1) = '-';
                break;
            }
        }
    }
    else if(s1_ch == '-' && s2_ch != '-')
    {
        // negative number(s1) + positive number(s2)
        s1 = s1 + 1; len1 = len1 - 1;
        sub(s2, len2, s1, len1, ans, max_len);
    }
    else if(s1_ch != '-' && s2_ch == '-')
    {
        // positive number(s1) + negative number(s2)
        s2 = s2 + 1; len2 = len2 - 1;
        sub(s1, len1, s2, len2, ans, max_len);
    }
    else
    {
        // positive number(s1) + positive number(s2)
        add(s1, len1, s2, len2, ans, max_len);
    }
    
    return ans;
}



int main(){
    char s1[MAX_LEN] = {0};
    char s2[MAX_LEN] = {0};
    fgets(s1,MAX_LEN,stdin);
    fgets(s2,MAX_LEN,stdin);
    int len1 = strlen(s1) - 1;
    int len2 = strlen(s2) - 1;
    char* ans =long_integer_add(s1, len1, s2, len2);
    int i = 0;
    while(*(ans+i) == '\0'){
        i++;
    }
    printf("%s\n",ans+i);
    return 0;
}

void add(const char * s1, int len1, const char * s2, int len2, char * ans, int len)
{
    // 1.compare two numbers to find the longer
    int short_len, long_len;
    char* short_s; char* long_s;
    if (len1 >= len2) {
        long_len = len1; long_s = s1;
        short_len = len2; short_s = s2;
    }
    else
    {
        long_len = len2; long_s = s2;
        short_len = len1; short_s = s1;
    }

    // 2.use the longer add the shorter
    char sch, lch;
    int flag = 0; int sum = 0;
    for (int i = 0; i < long_len; i++) {
        lch = *(long_s + long_len - 1 - i);
        if (i < short_len) { 
            sch = *(short_s + short_len - 1 - i);
        }
        else
        {
            sch = '0';
        }
        sum = lch - '0' + sch - '0' + flag;
        flag = 0; //reserve 0 after adding flag

        if (sum / 10 > 0) {
            flag = 1;
        }
        *(ans + len - 1 - LEFT_OFFSET - i) = sum % 10 + '0';
    }

    if (flag == 1) {
        *(ans + len - 1 - LEFT_OFFSET - long_len) = '1';
    }
}

void sub(const char * s1, int len1, const char * s2, int len2, char * ans, int len)
{
    // 1.compare two numbers to find the bigger
    int flag = 0;
    int short_len, long_len;
    char* short_s; char* long_s;

    long_len = len1; long_s = s1;
    short_len = len2; short_s = s2;
    if (len1 < len2) {
        long_len = len2; long_s = s2;
        short_len = len1; short_s = s1;
        flag = 1;
    }
    else if (len1 == len2) {
        for (int i = 0; i < len1; i++) {
            if(*(s1 + i) < *(s2 + i))
            {
                long_len = len2; long_s = s2;
                short_len = len1; short_s = s1;
                flag = 1;
                break;
            }
            else if (*(s1 + i) > *(s2 + i)) {
                break;
            }
        }
    }

    // 2.use the bigger minus the smaller 
    char subch, minch, ch;
    int minuend, subtrahend;
    int flag2 = 0;
    for (int i = 0; i < long_len; i++) {
        minch = *(long_s + long_len - 1 - i);
        if (i < short_len) {
            subch = *(short_s + short_len - 1 - i);
        }
        else
        {
            subch = '0';
        }

        minuend = minch - '0' - flag2;
        flag2 = 0; //reserve 0 after minusing flag
        subtrahend = subch - '0';

        if (minuend >= subtrahend) {
            ch = minuend - subtrahend + '0';
            *(ans + len - 1 - LEFT_OFFSET - i) = ch;
        }
        else {
            flag2 = 1;
            ch = 10 - subtrahend + minuend + '0';
            *(ans + len - 1 - LEFT_OFFSET - i) = ch;
        }

    }
    if (flag) {
        for (int i = 0; i < long_len; i++) {
            if (*(ans + i) != '\0') {
                *(ans + i - 1) = '-';
                break;
            }
        }
    }
}