Powerful Calculator

a = int(input())
b = int(input())
print(a+b)
print(a-b)
print(a*b)

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String a = sc.nextLine();
        String b = sc.nextLine();

        if (a.charAt(0) != '-' && b.charAt(0) != '-') {//a b均为正
            String addResult = addfun(a, b);
            System.out.println(addResult);
            String subResult = subfun(a, b);
            System.out.println(subResult);
            String mulResult = mulfun(a, b);
            System.out.println(mulResult);
        }
        if (a.charAt(0) == '-' && b.charAt(0) != '-') {//a负 b正
            String a1 = a.substring(1);
            String addResult = subfun(b, a1);
            System.out.println(addResult);
            String subResult = addfun(a1, b);
            System.out.println("-" + subResult);
            String mulResult = mulfun(a1, b);
            System.out.println("-" + mulResult);
        }
        if (a.charAt(0) != '-' && b.charAt(0) == '-') {//a正 b负
            String b1 = b.substring(1);
            String addResult = subfun(a, b1);
            System.out.println(addResult);
            String subResult = addfun(a, b1);
            System.out.println(subResult);
            String mulResult = mulfun(a, b1);
            System.out.println("-" + mulResult);
        }
        if (a.charAt(0) == '-' && b.charAt(0) == '-') {//a负 b负
            String a1 = a.substring(1);
            String b1 = b.substring(1);
            String addResult = addfun(a1, b1);
            System.out.println("-" + addResult);
            String subResult = subfun(b1, a1);
            System.out.println(subResult);
            String mulResult = mulfun(a1, b1);
            System.out.println(mulResult);
        }
    }

    //两个正数相加
    public static String addfun(String a, String b) {
        //加法
        StringBuilder result = new StringBuilder();
        int i, j;
        int flag = 0;

        for (i = a.length() - 1, j = b.length() - 1; i >= 0 && j >= 0; i--, j--) {
//            char-->String-->int
//            int sum = Integer.parseInt(String.valueOf(a.charAt(i))) + Integer.parseInt(String.valueOf(b.charAt(j)));
            int sum = (a.charAt(i) - '0') + (b.charAt(j) - '0');
            if (flag != 0) {
                sum += 1;     //检查到进了一位，还要加1
                flag = 0;     //刷新
            }
            if (sum > 9) {
                flag = 1;   //此时需要进位，记录一下
                sum = sum - 10; //取个位
            }
            result.append(sum);
        }

        if (i == -1 && j == -1 && flag == 1) result.append('1');//a b一起结束，且有进位
        else {
            if (i != -1) haves(a, result, i, flag);
            if (j != -1) haves(b, result, j, flag);
        }

        String addResult = String.valueOf(result.reverse());

        return addResult;
    }

    //两个正数相减
    private static String subfun(String a, String b) {
        String subResult;
        StringBuilder result = new StringBuilder();
        int i, j;
        int flag = 0;
        int mark = 0;

        if (a.length() < b.length() || (a.length() == b.length() && a.compareTo(b) < 0)) {//使a大 b小
            mark = 1;
            String temp = a;
            a = b;
            b = temp;
        }

        for (i = a.length() - 1, j = b.length() - 1; i >= 0 && j >= 0; i--, j--) {
            int sub;
//            char-->String-->int
            int aint = Integer.parseInt(String.valueOf(a.charAt(i)));
            int bint = Integer.parseInt(String.valueOf(b.charAt(j)));
            if (flag != 0) {
                if (aint > 0) {
                    aint--; //检查到之前借走一位
                    flag = 0;//算过了借的位，刷新
                } else
                    aint = 9;
            }

            if (aint >= bint) {
                sub = aint - bint;
            } else {//需要借一位
                sub = aint + 10 - bint;
                flag = 1;
            }

            result.append(sub);
        }
        while (i >= 0) {
            int aint = Integer.parseInt(String.valueOf(a.charAt(i)));
            if (flag == 1) {

                if (aint > 0) {
                    aint--;
                    flag = 0;
                } else {
                    aint = 9;
                }

                if (aint == 0 && i == 0) break;
                else result.append(aint);

            } else
                result.append(aint);

            i--;
        }

        int k;
        for (k = result.length() - 1; k >= 0; k--) {//从后往前找到最后一个0字符的索引，此时result还是逆序状态
            char m = result.charAt(k);
            if (m != '0') break;
        }

        String res = result.substring(0, k + 1);//修建掉多余的0
        result = new StringBuilder(res);//修改回StringBudil

        if (mark == 1) {
            result.append("-").reverse();
        } else {
            result.reverse();
        }
        subResult = String.valueOf(result);
        return subResult;

    }

    //两个正数相乘
    private static String mulfun(String a, String b) {//a=12345,b=6789

        String mulResult;
        if (a.length() < 5 && b.length() < 5) {
            int aint, bint;

            if (a.isEmpty()) aint = 0;
            else aint = Integer.parseInt(a);

            if (b.isEmpty()) bint = 0;
            else bint = Integer.parseInt(b);

            int result = aint * bint;
            mulResult = String.valueOf(result);
        } else {
            int n;
            if (a.length() < b.length()) n = a.length() / 2;
            else n = b.length() / 2;//n=2
            String A = a.substring(0, a.length() - n - 1);//12
            String B = a.substring(a.length() - n - 1);//345
            String C = b.substring(0, b.length() - n - 1);//6
            String D = b.substring(b.length() - n - 1);//789

            StringBuilder zero1 = new StringBuilder();
            for (int i = 0; i < (n + 1) * 2; i++) {
                zero1.append('0');
            }//zero1:000000
            StringBuilder zero2 = new StringBuilder();
            for (int i = 0; i < n + 1; i++) {
                zero2.append('0');
            }//zero2:000


            String elem1 = mulfun(A, C).concat(String.valueOf(zero1));
            String elem21 = mulfun(A, D);
            String elem22 = mulfun(B, C);
            String elem2 = addfun(elem21, elem22).concat(String.valueOf(zero2));

            String elem3 = mulfun(B, D);

            mulResult = addfun(addfun(elem1, elem2), elem3);
        }

        return mulResult;
    }

    //处理剩余的
    public static void haves(String s, StringBuilder result, int index, int flag) {
        //s是剩余的那个字符串
        while (index >= 0) {
            if (flag == 1) {
                int t = Integer.parseInt(String.valueOf(s.charAt(index--))) + 1;
                if (t > 9) {
                    t = t - 10;
                } else {
                    flag = 0;
                }
                result.append(String.valueOf(t));
            } else {
                result.append(s.charAt(index--));
            }
        }
        if (index == -1 && flag == 1) result.append('1');
    }

}

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

string add(string a, string b);
string sub(string a, string b);
string mup(string a, string b);

int main() {
	string a = "20000000000000000";
	string b = "4000000000000000";
	cin >> a;
	cin >> b;
	cout << add(a,b) << endl;
	cout << sub(a,b) << endl;
	cout << mup(a,b) << endl;

}

string add(string a, string b) {
	string result = "";
	char plusPosition = '0'; // 进位
	int a_index = a.size()-1;
	int b_index = b.size()-1;
	while(a_index>=0 || b_index>=0 || plusPosition!='0') {
		char ca,cb;
		if(a_index>=0) ca = a[a_index--];
		else ca = '0';
		if(b_index>=0) cb = b[b_index--];
		else cb = '0';
		int currentNum = plusPosition + ca + cb - 3*'0';
		plusPosition = currentNum/10 + '0';
		result += currentNum%10 + '0';
	}
	reverse(result.begin(),result.end());
	return result;
}

string sub(string a, string b) {
	string result = "";
	string temp = "0";
	int isBorrow = 0; // 是否借位
	int isChange = 0; // 是否换位
	int a_index = a.size()-1;
	int b_index = b.size()-1;
	
	if(a_index<b_index ) {
		isChange = 1;
		string temp = a;
		a = b;
		b = temp;
		a_index = a.size()-1;
		b_index = b.size()-1;
	}
	if(a_index==b_index){
		
		for(int i=0; i<a.size() && a[i]<=b[i]; i++){
			if(a[i]<b[i]){
				isChange = 1;
				string temp = a;
				a = b;
				b = temp;
				a_index = a.size()-1;
				b_index = b.size()-1;
				break;
			}
		}
	}
	while(a_index>=0 || b_index>=0) {
		char ca,cb;
		temp = "0";
		if(a_index>=0) ca = a[a_index];
		else ca = '0';
		if(b_index>=0) cb = b[b_index];
		else cb = '0';
		int tempNum = ca - cb - isBorrow;
		isBorrow = tempNum>=0 ? 0 : 1;
		tempNum = tempNum>=0 ? tempNum : tempNum+10;
		temp[0] = tempNum+'0'; 
		result += temp;
		a_index--;
		b_index--;
	}
	while( result[result.size()-1] == '0' ){
		result.erase(result.end()-1);
	}
	if(isChange==1) {
		result += '-';
	}
	reverse(result.begin(),result.end());
//	cout << "result = " << result << endl;
	return result;
}

string mup(string a, string b) {
	string result = "";
	int plusPosition = 0; 	// 进位
	string numZero = "";		// 每算一轮，就多加个0
	int a_index = a.size()-1;
	int b_index = b.size()-1;

	for(int i=a_index; i>=0; i--) {
		string sum = "";
		plusPosition = 0;
		string numZeroInner = "";
		for(int j=b_index; j>=0; j--) {	// a的每一个数，×b中的第i个数
			string tempStr = "0";
			int ia = a[i] - '0';
			int ib = b[j] - '0';
			int currentNum = ia * ib + plusPosition;
			char geWei = currentNum%10+'0';		// 当前乘法过后的个位
			tempStr[0] = geWei;
			// 拼接
			tempStr += numZeroInner;
			numZeroInner += "0";
            sum = add(sum, tempStr);
            plusPosition = currentNum/10;	    // 进位
			
		}
		// 完成上步循环未完成的最后一步，加上最高位
		if(plusPosition!=0){
			char c = plusPosition + '0';
			numZeroInner.push_back(c);
			reverse(numZeroInner.begin(),numZeroInner.end());
			sum = add(sum, numZeroInner);
		} 
		// 最终的求和 
		sum += numZero;
		result = add(result, sum);
		numZero += "0";
	}
	return result;
}

#include <iostream>
#include <istream>
#include <ostream>
#include <string>
using namespace std;

const int MAXN = 800;

struct BigInteger {
    int* digit;     //数组存储数值
    int length;     //数组有效长度（数值部分位数）
    int sign;       //符号位，0表示非负数，1表示负数
    BigInteger();
    BigInteger operator=(string str);
    bool operator<(const BigInteger& b);
    BigInteger operator+(const BigInteger& b);
    BigInteger operator-(BigInteger& b);
    BigInteger operator*(const BigInteger& b);
    friend istream& operator>>(istream& in, BigInteger& x);
    friend ostream& operator<<(ostream& out, const BigInteger& x);
};

istream& operator>>(istream& in, BigInteger& x) {
    string str;
    in >> str;
    x = str;
    return in;
}

ostream& operator<<(ostream& out, const BigInteger& x) {
    if (x.sign == 1) {
        out << "-";
    }
    for (int i = x.length - 1; i >= 0; i--) {
        out << x.digit[i];
    }
    return out;
}

BigInteger::BigInteger() {
    digit = new int[MAXN]();
    sign = 0;
    length = 0;
}

BigInteger BigInteger::operator=(string str) {
    length = str.size();
    for (int i = 0; i < length; i++) {
        digit[i] = str[length - i - 1] - '0';
    }
    return *this;
}

bool BigInteger::operator<(const BigInteger& b) {
    if (length < b.length) {
        return true;
    } else if (b.length < length) {
        return false;
    } else {
        for (int i = length - 1; i >= 0; i--) {
            if (digit[i] == b.digit[i]) {
                continue;
            } else {
                return digit[i] < b.digit[i];
            }
        }
    }
    return false;
}

BigInteger BigInteger::operator+(const BigInteger& b) {
    BigInteger answer;
    int carry = 0;
    for (int i = 0; i < length || i < b.length; i++) {
        int current = digit[i] + b.digit[i] + carry;
        carry = current / 10;
        answer.digit[answer.length++] = current % 10;
    }
    if (carry != 0) {
        answer.digit[answer.length++] = carry;
    }
    return answer;
}

BigInteger BigInteger::operator-(BigInteger& b) {
    BigInteger answer;
    if (*this < b) {
        answer = b - *this;
        answer.sign = 1;
        return answer;
    }
    int carry = 0;
    for (int i = 0; i < length || i < b.length; i++) {
        int current = digit[i] - b.digit[i] - carry;
        current < 0 ? current += 10, carry = 1 : carry = 0;
        answer.digit[answer.length++] = current;
    }
    while (answer.digit[answer.length - 1] == 0 && answer.length > 1) {
        answer.length--;
    }
    return answer;
}

BigInteger BigInteger::operator*(const BigInteger& b) {
    BigInteger answer;
    answer.length = length + b.length;
    for (int i = 0; i < length; i++) {
        for (int j = 0; j < b.length; j++) {
            answer.digit[i + j] += digit[i] * b.digit[j];
        }
    }
    for (int i = 0; i < answer.length; i++) {
        answer.digit[i + 1] += answer.digit[i] / 10;
        answer.digit[i] %= 10;
    }
    answer.length++;
    while (answer.digit[answer.length - 1] == 0 && answer.length > 1) {
        answer.length--;
    }
    return answer;
}

int main() {
    BigInteger a, b;
    while (cin >> a >> b) {
        cout << a + b << endl;
        cout << a - b << endl;
        cout << a * b << endl;
    }
    return 0;
}

#include<string>
#include<iostream>

using namespace std;

string addit(string a, string b){
    string ret;
    if(a.size()<b.size()){
        string temp(b.size()-a.size(), '0');
        a = temp + a;
    }
    else{
        string temp(a.size()-b.size(), '0');
        b = temp + b;
    }
    int adv=0, cur=0;
    char cur_char;
    for(int i=a.size()-1; i>=0; --i){
        cur = (a[i]-'0') + (b[i]-'0') + adv;
        cur_char = cur%10 + '0';
        ret = cur_char + ret;
        adv = cur/10;
    }
    if(adv>0){
        cur_char = adv%10 + '0';
        ret = cur_char + ret;
    }
    return ret;
}

string subst(string a, string b){
    string ret;
    if(a.size()<b.size()){
        string temp(b.size()-a.size(), '0');
        a = temp + a;
    }
    else{
        string temp(a.size()-b.size(), '0');
        b = temp + b;
    }
    int sig=1;
    for(int i=0; i<a.size(); ++i){
        if(a[i]>b[i]) break;
        else if(a[i]<b[i]){
            sig=-1;
            string temp;
            temp=a; a=b; b=temp;
            break;
        }
    }

    int adv=0, cur=0;
    char cur_char;
    for(int i=a.size()-1; i>=0; --i){
        cur = (a[i]-'0') - (b[i]-'0') + adv;
        if(cur>=0){
            cur_char = cur%10 + '0';
            adv = cur/10;
        }
        else{
            cur_char = (10+cur)%10 + '0';
            adv = -1;
        }
        ret = cur_char + ret;
    }
    int zero_index=0;
    for(int i=0; i<ret.size()-1; ++i){
        if(ret[i]=='0') zero_index++;
        else break;
    }
    ret = ret.substr(zero_index);
    if(sig==-1) ret = '-'+ret;
    return ret;
}

string single_multi(string a, char b){
    string ret;
    int adv=0, cur=0;
    char cur_char;
    for(int i=a.size()-1; i>=0; --i){
        cur = (a[i]-'0')*(b-'0') + adv;
        cur_char = cur%10 + '0';
        adv = cur/10;
        ret = cur_char+ret;
    }
    if(adv>0){
        cur_char = adv%10 + '0';
        ret = cur_char + ret;
    }
    return ret;
}

string multi(string a, string b){
    string ret, cur_zero;
    int adv=0, cur=0;
    string cur_char;
    ret='0';
    for(int i=b.size()-1; i>=0; --i, cur_zero+='0'){
        cur_char = single_multi(a, b[i]);
        ret = addit(cur_char+cur_zero, ret);
    }
    return ret;
}

int main(){
    string a, b;
    cin >> a >> b;
    string ret_add, ret_sub, ret_mul;
    // add
    if(a[0]=='-' && b[0]=='-') ret_add = '-'+addit(a.substr(1), b.substr(1));
    else if(a[0]=='-') ret_add = subst(b, a.substr(1));
    else if(b[0]=='-') ret_add = subst(a, b.substr(1));
    else ret_add = addit(a, b);

    // sub
    if(a[0]=='-' && b[0]=='-') ret_sub = subst(b.substr(1), a.substr(1));
    else if(a[0]=='-') ret_sub = '-'+addit(b, a.substr(1));
    else if(b[0]=='-') ret_sub = addit(a, b.substr(1));
    else ret_sub = subst(a, b);

    // mul
    if(a[0]=='-' && b[0]=='-') ret_mul = multi(b.substr(1), a.substr(1));
    else if(a[0]=='-') ret_mul = '-'+multi(b, a.substr(1));
    else if(b[0]=='-') ret_mul = '-'+multi(a, b.substr(1));
    else ret_mul = multi(a, b);

    cout << ret_add << endl << ret_sub << endl << ret_mul;

    return 0;
}