[技术交流] C/C++仿高山每周一练（难度增加）

#include<iostream>
#include<cstring>
using namespace std;
int a[200], b[200], c[200];
int a_len, b_len, c_len;
void in() {
        string tempa, tempb;
        cin>>tempa>>tempb;
        a_len = tempa.length();
        b_len = tempb.length();
        for(int i=0; i<a_len; ++i) {
                a[a_len-1-i] = tempa[i] - '0';
        }
        for(int i=0; i<b_len; ++i) {
                b[b_len-1-i] = tempb[i] - '0';
        }
}
void add() {
        for(int i=0; i<max(a_len, b_len); ++i) {
                c[i] += (a[i] + b[i]);
                c[i+1] += c[i] / 10;
                c[i] %= 10;
        }
        if(c[max(a_len, b_len)]) c_len = max(a_len, b_len) + 1;
        else c_len = max(a_len, b_len);
}
void out() {
        //cout<<c_len<<endl;
        for(int i=c_len-1; i>=0; --i) {
                cout<<c[i];
        }
}
int main()
{
        in();
        add();
        out();
        return 0;
}

#include <bits/stdc++.h>
using namespace std;

int l, la, lb;
string f, s;
char op;

short a[1001], b[1001], ans[1002];

void read(string va, string vb){
    memset(a, 0, sizeof(a)); memset(b, 0, sizeof(b)); memset(ans, 0, sizeof(ans));
    la = va.size(); lb = vb.size(); l = la > lb ? la : lb;
    for(int i = la - 1; i >= 0; i--) a[la-i-1] = va[i] - '0';
    for(int i = lb - 1; i >= 0; i--) b[lb-i-1] = vb[i] - '0';
}

void print(short x[]){
    for(int i = l-1; i >= 0; i--) cout << x[i];
    cout << endl;
}

void add(short x[], short y[]){
    int c = 0;
    for(int i = 0; i < l; i++){
        ans[i] = x[i] + y[i] + c;
        c = ans[i] / 10;
        ans[i] %= 10;
    }
    if(c){ans[l] = c; l++;}
}

int main(){
    ios::sync_with_stdio(0);

    cin >> f >> s;
    read(f, s);
    add(a, b);
    print(ans);
    return 0;
}

#include <iostream>
#include <boost/multiprecision/cpp_int.hpp>

using std::cin, std::cout, std::endl;
using boost::multiprecision::cpp_int;

int main() {
    cpp_int a, b;
    cin >> a >> b;
    cout << a + b << endl;
    return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
typedef struct{
    uint32_t* data;
    uint8_t blocks;
}BigInteger;
void BigInteger_init(BigInteger* integer){
    integer->blocks = 0;
    integer->data = NULL;
}
void BigInteger_release(BigInteger* integer){
    if(integer->data != NULL) free(integer->data);
    BigInteger_init(integer);
}
void BigInteger_read(BigInteger* integer){
    static char buffer[2048];
    BigInteger_release(integer);
    scanf("%s", buffer);
    int length = strlen(buffer);
    integer->blocks = ceil(length / 9.0);
    integer->data = (uint32_t*)malloc(sizeof(uint32_t) * integer->blocks);
    for(int i = 0; length > 0; ++i){
        int start = length - 9;
        if(start < 0) start = 0;
        sscanf(buffer + start, "%9u", integer->data + i);
        length = start;
        buffer[length] = '\0';
    }
}
void BigInteger_write(const BigInteger* integer){
    for(int i = integer->blocks - 1; i >= 0; --i){
        if(i != integer->blocks - 1) printf("%09u", integer->data[i]);
        else printf("%u", integer->data[i]);
    }
    putchar('\n');
}
void BigInteger_add(const BigInteger* lhs, const BigInteger* rhs, BigInteger* result){
    BigInteger_release(result);
    int predict_blocks = (lhs->blocks > rhs->blocks ? lhs->blocks : rhs->blocks) + 1;
    result->data = (uint32_t*)malloc(sizeof(uint32_t) * predict_blocks);
    int carry = 0;
    for(int i = 0; i < predict_blocks; ++i){
        if(i < lhs->blocks && i < rhs->blocks){
            result->data[i] = carry + lhs->data[i] + rhs->data[i];
        }else if(i < lhs->blocks){
            result->data[i] = carry + lhs->data[i];
        }else if(i < rhs->blocks){
            result->data[i] = carry + rhs->data[i];
        }else{
            if(carry){
                result->data[i] = carry;
                result->blocks = predict_blocks;
            }else{
                result->blocks = predict_blocks - 1;
                result->data = (uint32_t*)realloc(result->data, sizeof(uint32_t) * result->blocks);
            }
            break;
        }
        carry = result->data[i] > 999999999u ? 1 : 0;
        result->data[i] = carry ? result->data[i] - 1000000000u : result->data[i];
    }
}
int main(){
    BigInteger a, b, result;
    BigInteger_init(&a);
    BigInteger_init(&b);
    BigInteger_init(&result);
    BigInteger_read(&a);
    BigInteger_read(&b);
    BigInteger_add(&a, &b, &result);
    BigInteger_write(&result);
    BigInteger_release(&a);
    BigInteger_release(&b);
    BigInteger_release(&result);
    return 0;
}

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

int main()
{
        char a[1024];
        char b[1024];
        scanf("%s%s",a,b);
        char res[strlen(a)>strlen(b)?strlen(a)+2:strlen(b)+2];
        memset(res,0,sizeof(res)-1);
        int i,j,k;
        int flag=0;
        i=strlen(a)-1;
        j=strlen(b)-1;
        for (int l=0;a[l]!='\0';l++) a[l] = a[l] - '0';
        for (int l=0;b[l]!='\0';l++) b[l] = b[l] - '0';
        for (k=sizeof(res)-2;i>=0 || j>=0 || k>=0;j--,i--,k--)
        {
                if ((i<0?0:a[i])+(j<0?0:b[j])+flag >= 10)
                {
                        res[k] = (i<0?0:a[i])+(j<0?0:b[j])-10+flag;
                        flag = 1;
                }
                else
                {
                        res[k] = (i<0?0:a[i])+(j<0?0:b[j])+flag;
                        flag = 0;
                }
        }
        res[sizeof(res)-1] = '\0';
        for (int l=0;l<sizeof(res)-1;l++) res[l] = res[l] + '0';
        if (res[0] == '0') res[0] = '\b';
        printf("%s\n",res);
        return 0;
}