大数加法

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 计算两个数之和
     * @param s string字符串 表示第一个整数
     * @param t string字符串 表示第二个整数
     * @return string字符串
     */
    public String solve (String s, String t) {
        // write code here

        // 0.处理特殊情况
        if (s.length() == 0) {
            return t;
        }
        if (t.length() == 0) {
            return s;
        }

        // 1.按位加，注意进位
        StringBuilder sb = new StringBuilder();
        int i = 0;
        int sl = s.length();
        // 字符串s的实际下标，从后往前
        int si = sl - 1 - i;
        int tl = t.length();
        // 字符串t的实际下标，从后往前
        int ti = tl - 1 - i;
        // 进位
        int add = 0;
        while (si >= 0 || ti >= 0) {
            // si和ti有一个大于等于0即继续运算
            int sn = 0;
            if (si >= 0) {
                sn = s.charAt(si) - '0';
            }
            int tn = 0;
            if (ti >= 0) {
                tn = t.charAt(ti) - '0';
            }
            // 运算
            int sum = sn + tn + add;
            int res = sum % 10;
            add = sum / 10;
            // 使用StringBuilder的insert方法进行前插 - sb.insert(0, "前插的内容")
            // 使用String的静态方法valueOf进行字符串化（序列化） - String.valueOf(数字)
            sb.insert(0, String.valueOf(res));
            // 更新si和ti
            i++;
            si = sl - 1 - i;
            ti = tl - 1 - i;
        }
        // 此时si和ti全小于0，若进位还有值，则将其加到前面
        if (add > 0) {
            sb.insert(0, String.valueOf(add));
        }
        return sb.toString();
    }
}

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 计算两个数之和
     * @param s string字符串 表示第一个整数
     * @param t string字符串 表示第二个整数
     * @return string字符串
     */
    public String solve (String s, String t) {
        // write code here
        StringBuilder res = new StringBuilder();
        int carry = 0;  // 处理进位
        int i = s.length() - 1, j = t.length() - 1;
        while (i >= 0 && j >= 0) {
            int si = s.charAt(i) - '0';
            int ti = t.charAt(j) - '0';

            int sum = si + ti + carry;
            res.append(sum % 10);
            carry = sum / 10;
            i--;
            j--;
        }
        while (i >= 0) {
            int sum = s.charAt(i) - '0' + carry;
            carry = sum / 10;
            res.append(sum % 10);
            i--;
        }
        while (j >= 0) {
            int sum =  t.charAt(j) - '0' + carry;
            carry = sum / 10;
            res.append(sum % 10);
            j--;
        }
        if(carry!=0){
           res.append(carry); 
        }
        return new StringBuilder(res).reverse().toString();
    }
}

public String solve (String s, String t) {
    // write code here
    StringBuilder res=new StringBuilder();
    int sum=0 ,sl=s.length()-1 ,tl=t.length()-1;
    while(sl>=0 || tl>=0 || sum>0){
        if(sl>=0){
            sum+=(s.charAt(sl--)-'0');
        }
        if(tl>=0){
            sum+=(t.charAt(tl--)-'0');
        }
        res.append(sum%10);
        sum/=10;
    }
    return res.reverse().toString();
}

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 计算两个数之和
     * @param s string字符串 表示第一个整数
     * @param t string字符串 表示第二个整数
     * @return string字符串
     */
    public String solve (String s, String t) {
        // write code here
        if (s == null || s.length() == 0) return t;
        if (t == null || t.length() == 0) return s;
        int lenS = s.length();
        int lenT = t.length();
        // 用于拼接计算过程中产生的结果
        StringBuilder sb = new StringBuilder();
        // 记录进位数
        int car = 0;
        // 记录s、t和car相加的和
        int temp = 0;
        // s、t任意一个字符串未遍历结束时，不断循环,从尾部开始遍历
        while (lenS - 1 >= 0 || lenT - 1 >= 0) {
            // 分别记录s、t的字符
            char ch1 = '0', ch2 = '0';
            // 进行判断防止越界
            if (lenS - 1 >= 0) ch1 = s.charAt(lenS - 1);
            if (lenT - 1 >= 0) ch2 = t.charAt(lenT - 1);
            // 两串都未遍历至首字符时,将遍历过程中得到的字符转换成数字后相加,并加上进位数
            if (lenS - 1 >= 0 && lenT - 1 >= 0) temp = (ch1 - '0') + (ch2 - '0') + car;
            // t遍历遍历结束,s未遍历结束时,只需要考虑s的当前字符与进位数相加
            else if (lenS - 1 >= 0) temp = (ch1 - '0')  + car;
            // s遍历遍历结束,t未遍历结束时,只需要考虑t的当前字符与进位数相加
            else if (lenT - 1 >= 0) temp = (ch2 - '0')  + car;
            // 获取进位数，用于下轮循环相加，或循环结束后的拼接
            car = temp / 10;
            // 拼接进位相加后的个位数
            sb.append(temp % 10);
            lenS--;
            lenT--;
        }
        // 如1+99，循环结束时sb=00，car=1，应拼接car，拼接后sb=001
        if (car != 0) sb.append(car);
        // 反转，因为拼接结果是反向的
        return sb.reverse().toString();
    }
}

竟然过不了，服了，感觉跟他们写的一样啊
public String solve (String s, String t) {
        // write code here
        Stack<Integer> stack=new Stack();
        int i=s.length()-1;
        int j=t.length()-1;
        int num=0;
        int num1=0;
        while(j>=0||i>=0){
            num+=(i<0?0:s.charAt(i)-'0');
            num1=(j<0?0:t.charAt(j)-'0');
            stack.push((num+num1)%10);
            num=(num+num1)/10;
            j--;
            i--;
        }
        if(num==1){
            stack.push(num);
        }
        
        String s1="";
        while(!stack.isEmpty()){
            s1+=stack.pop();
        }
        return s1;
    }

public String solve (String s, String t) {
        // write code here
        if (s == null || t == null) {
            return s == null ? t : s;
        }
        int carry = 0;
        int i = s.length() - 1;
        int j = t.length() - 1;
        StringBuilder sb = new StringBuilder();
        while (i >= 0 || j >= 0 || carry != 0) {
            int intI = i >= 0 ? s.charAt(i--) - '0' : 0;
            int intJ = j >= 0 ? t.charAt(j--) - '0' : 0;
            carry = carry + intI + intJ;
            sb.append(carry % 10);
            carry /= 10;
        }
        return sb.reverse().toString();
    }

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 计算两个数之和
     * @param s string字符串 表示第一个整数
     * @param t string字符串 表示第二个整数
     * @return string字符串
     */
    public String solve (String s, String t) {
        // 1. 参数判断
        if(s == null || s.length() == 0) {
            return t;
        }
        if(t == null || t.length() == 0) {
            return s;
        }

        // 2. 创建 carry 变量表示进位信息
        int carry = 0;

        // 3. 创建 StringBuilder 用来接收答案
        StringBuilder stringBuilder = new StringBuilder();


        // 4. 创建 i j 分别指向两个字符串
        // 因为我们是从后往前操作,所以让 i j 先都指向最后面
        int i = s.length() - 1;
        int j = t.length() - 1;

        // 5. i j 从最后面往前移动
        while(i >= 0 || j >= 0) {
            // 6. num1 就表示 s 这一位的值
            int num1 = i < 0 ? 0 : s.charAt(i) - '0';
            // 判断完这一位,i 要往前移动
            i--;

            // 7. num2 就表示 t 这一位的值
            int num2 = j < 0 ? 0 : t.charAt(j) - '0';
            // 判断完这一位,j 要往前移动
            j--;

            // 8. 将这两位的值相加
            // 注意:我们还应该添加进位信息
            int sum = num1 + num2 + carry;
            
            // 9. 将 sum 的结果添加到 stringBuilder 中
            stringBuilder.insert(0,sum % 10);

            // 10. 判断是否有进位
            carry = (sum / 10);
        }

        // 11. 判断最后是否还有进位
        if(carry != 0) {
            stringBuilder.insert(0,1);
        }
        
        return stringBuilder.toString();
    }
}

import java.math.BigInteger;
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 计算两个数之和
     * @param s string字符串 表示第一个整数
     * @param t string字符串 表示第二个整数
     * @return string字符串
     */
    public String solve (String s, String t) {
        // write code here
        BigInteger sBigInteger = new BigInteger(s);
        BigInteger tBigInteger = new BigInteger(t);
        BigInteger add = sBigInteger.add(tBigInteger);
        return add.toString();
    }
}

import java.util.*;


public class Solution {
    public String solve (String s, String t) {
        if (s == "") return t;
        if (t == "") return s;
        Stack<Integer> st = new Stack<>();
        int carry = 0;
        for (int i=s.length()-1,j=t.length()-1;i>=0&&j>=0;i--,j--) {
            char c1 = s.charAt(i);
            char c2 = t.charAt(j);
            int cur = (c1 - '0' + c2 - '0' + carry) % 10;
            carry = (c1 - '0' + c2 - '0' + carry) / 10;
            st.add(cur);
        }
        String temp = s.length() > t.length() ? s : t;
        for (int i = Math.abs(s.length()-t.length()) - 1; i >= 0; i--) {
            char c = temp.charAt(i);
            int cur = (c - '0' + carry) % 10;
            carry = (c - '0' + carry) / 10;
            st.add(cur);
        }
        if (carry == 1)
            st.add(carry);
        StringBuffer sb = new StringBuffer();
        while (!st.isEmpty()) {
            sb.append(st.pop());
        }
        return sb.toString();
    }
}

import java.util.*; 

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 计算两个数之和
     * @param s string字符串 表示第一个整数
     * @param t string字符串 表示第二个整数
     * @return string字符串
     */
    public String solve (String s, String t) {
        // write code here
        StringBuilder sb = new StringBuilder();
        char[] cs = s.toCharArray();
        char[] ct = t.toCharArray();
        int us = cs.length - 1, ut = ct.length - 1;
        int cout = 0, sum = 0;
        while (us >= 0 || ut >= 0) {
            sum = cout;
            if (us >= 0) sum += (cs[us--] - '0');
            if (ut >= 0) sum += (ct[ut--] - '0');
            if (sum >= 10) {
                sum -= 10;
                cout = 1;
            } else {
                cout = 0;
            }
            sb.append(sum);
        }
        if (cout > 0) sb.append(1);
        return sb.reverse().toString();

    }
}

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 计算两个数之和
     * @param s string字符串 表示第一个整数
     * @param t string字符串 表示第二个整数
     * @return string字符串
     */
    public String solve (String s, String t) {
        // write code here
        int n1 = s.length(), n2 = t.length();
        if (n1 == 0 || n2 == 0) {
            return n1 == 0 ? t : s;
        }
        StringBuilder ans = new StringBuilder();
        int carry = 0;
        int t1, t2, sum = 0;
        int p1 = n1 - 1, p2 = n2 - 1;
        while (p1 >= 0 || p2 >= 0 || carry > 0) {
            if (p1 < 0) {
                t1 = 0;
            } else {
                t1 = s.charAt(p1) - '0';
            }
            if (p2 < 0) {
                t2 = 0;
            } else {
                t2 = t.charAt(p2) - '0';
            }
            sum = t1 + t2 + carry;
            carry = sum / 10;
            sum = sum % 10;
            ans.append(Integer.toString(sum));
            p1--;
            p2--;
        }
        ans = ans.reverse();
        return ans.toString();
    }
}

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 计算两个数之和
     * @param s string字符串 表示第一个整数
     * @param t string字符串 表示第二个整数
     * @return string字符串
     */
    public String solve (String s, String t) {
        StringBuilder res = new StringBuilder();
        int i = s.length() - 1;
        int j = t.length() - 1;
        int carry = 0; // 进位数
        // 这层循环从个位开始往前计算两数相加的结果, 倒着拼接在 res 上
        while(i >= 0 && j >= 0) {
            int num1 = s.charAt(i) - '0';
            int num2 = t.charAt(j) - '0';
            int sum = num1 + num2 + carry;
            carry = sum / 10;
            res.append(sum % 10);
            i--;
            j--;
        }
        // 接下来就是三种情况: 
        // 1. s 字符串走完了, t 还未走完
        // 2. s 字符串还未走完, t 走完了
        // 3. s 和 t 都走完了
        while(i >= 0) {
            if(carry == 0) {
                StringBuilder str = new StringBuilder(s.substring(0, i + 1));
                res.append(str.reverse());
                break;
            }
            int sum = s.charAt(i) - '0' + carry;
            carry = sum / 10;
            res.append(sum % 10);
            i--;       
        }
        while(j >= 0) {
           if(carry == 0) {
                StringBuilder str = new StringBuilder(t.substring(0, j + 1));
                res.append(str.reverse());
                break;
            }
            int sum = t.charAt(j) - '0' + carry;
            carry = sum / 10;
            res.append(sum % 10);
            j--; 
        }
        // 记得处理最后一位进位数, 如果 t, s 都走完了, 还有进位, 那么要额外拼接上一个 1
        if(carry == 1) {
            res.append("1");
        }
        return new String(res.reverse());
    }
}

import java.util.*;
import java.math.BigDecimal;
public class Solution {
    public String solve (String s, String t) {
        return new BigDecimal(s.length()==0?"0":s).add(new BigDecimal(t.length()==0?"0":t)).toString();  
    }
}