小米OJ之倔强青铜

大数相减

• 描述：两个长度超出常规整形变量上限的大数相减，请避免使用各语言内置大数处理库，如 Java.math.BigInteger 等。
• 输入：有 N 行测试数据，每一行有两个代表整数的字符串 a 和 b，长度超过百位。规定 a>=b，a, b > 0。
• 输出：返回表示结果整数的字符串。
• 输入样例：

1231231237812739878951331231231237812739878951331231231237812739878951331231231237812739878951331231231237812739878951331231231237812739870-89513312312312378127398789513312312312378127398789513312312312378127398789513
1231231237812739878951331231231237812739878951331231231237812739878951331230000000000000000000000001-331231231237812739878951331231231

• 输出样例：

1231231237812739878951331231231237812739878951331231231237812650365639018918853110413950365639018918853110413950365639018918853110413950357
1231231237812739878951331231231237812739878951331231231237812739878620099998762187260121048668768770

• 难度：☆☆两颗星
  　　
  　　这道题要把数字符串反转后(保证高位在数组的末尾)，再转换成字符数组，将字符数组按位计算。首先判断两个大数相减的符号位，其次分别将按位计算的结果存储，判断结果的是否发生进位，并将其转换，最后将结果拼接成数字字符串并输出。整个程序运行时间为114.41 ms

import java.util.*;
import java.lang.StringBuilder;
//@Java - OpenJDK 1.8.0
public class Main {
    public static void main(String args[]) {
        Scanner scan = new Scanner(System.in);
        String line;
        
        while (scan.hasNextLine()) {
            line = scan.nextLine().trim();
            String[] arr = line.split("-");
            char[] numA = new StringBuilder(arr[0]).reverse().toString().toCharArray();
        	char[] numB = new StringBuilder(arr[1]).reverse().toString().toCharArray();

                //2.判断符号位
            boolean isPositive = true;
            if(numA.length < numB.length){
                isPositive = false;
            }else if(numA.length == numB.length){
                int i = numA.length - 1 ;
                while (i > 0 && numA[i] == numB[i]){
                    i--;
                }
                if(numA[i] < numB[i]){
                    isPositive = false;
                }
            }

            //3.开始计算
            int maxLen = numA.length > numB.length ? numA.length : numB.length;
            int result[] = new int[maxLen];
            for(int i = 0 ; i < maxLen ; i++){
                int intA = i < numA.length ?(numA[i] - '0') : 0;
                int intB = i < numB.length ?(numB[i] - '0') : 0;
                if(isPositive){
                    result[i] = intA - intB;
                }else{
                    result[i] = intB - intA;
                }
            }
            
            //4.进位装换
            for(int i = 0; i < result.length; i++){
                if(result[i] < 0){
                    result[i+1] -=1;
                    result[i] += 10;
                }
            }

            //5.输出结果
            StringBuilder re = isPositive ? new StringBuilder() : new StringBuilder("-");
           
            boolean flag = true;  // 追踪高位为零的标签
            for(int i = result.length - 1 ; i >= 0 ; i--){
                if(result[i] == 0 && flag){
                    continue;
                }else{  
                    flag = false;
                }
               re.append(result[i]);
            }
            System.out.println(re);
        }
    }
}