LeetCode989. 数组形式的整数加法

题目描述

对于非负整数 X 而言，X 的数组形式是每位数字按从左到右的顺序形成的数组。例如，如果 X = 1231，那么其数组形式为 [1,2,3,1]。

给定非负整数 X 的数组形式 A，返回整数 X+K 的数组形式。
示例 1：

输入：A = [1,2,0,0], K = 34
输出：[1,2,3,4]
解释：1200 + 34 = 1234
示例 2：

输入：A = [2,7,4], K = 181
输出：[4,5,5]
解释：274 + 181 = 455
示例 3：

输入：A = [2,1,5], K = 806
输出：[1,0,2,1]
解释：215 + 806 = 1021
示例 4：

输入：A = [9,9,9,9,9,9,9,9,9,9], K = 1
输出：[1,0,0,0,0,0,0,0,0,0,0]
解释：9999999999 + 1 = 10000000000

提示：

1 <= A.length <= 10000
0 <= A[i] <= 9
0 <= K <= 10000
如果 A.length > 1，那么 A[0] != 0

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/add-to-array-form-of-integer
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
来源：力扣（LeetCode）
题目链接: link.

解题思路

把输入的数组A,首先进行一个元素的翻转，然后将其存入一个List list_A当中，例如，A=[2,1,5],list_A={5,1,2} 然后将整数K,按位数从小到大将元素存入List list_K,例如，K = 806，list_K={6, 0, 8}.然后我们通过比较两个List大小得到两个List中size的最大值length_max,size的最小值length_min，同时将较大size的list赋值给List res。

然后我们for循环到下标length_min，当两个List中元素相加小于10，就直接将对应下标的值去res的值；当元素相加的值大于10，则将个位数值去更新对应下标res的值。

如果还有进位，当res中元素+1小于10，就直接将对应下标的值去res的值；当元素相加的值大于10，则将个位数值去更新对应下标res的值，同时继续进位，知道后续不发生进位，不再更新res对应下标的值。
最后再将res做一个翻转，最后返回res。

代码块

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class LeetCode989 {
    public static List<Integer> addToArrayForm(int[] A, int K) {
        List<Integer> list_K=new ArrayList<Integer>();
        List<Integer> list_A=new ArrayList<Integer>();
        List<Integer> res=new ArrayList<Integer>();
        Stack<Integer> stack =new Stack<Integer>();
        int val=0;
        while(K!=0){
            list_K.add(K%10);
            K = K / 10;
        }

        for (int i=0; i<A.length/2; i++){
            int temp=A[i];
            A[i]=A[A.length-1-i];
            A[A.length-1-i] = temp;
        }

        for(int i=0; i<A.length;i++){
            list_A.add(A[i]);

        }
        int length_max = 0;
        int length_min =0;

        if(list_K.size()>=list_A.size()){
            length_max=list_K.size();
            length_min=list_A.size();
            res=list_K;
        }else {
            length_min=list_K.size();
            length_max=list_A.size();
            res=list_A;
        }

        boolean flag=false;
        for(int i=0; i<length_min; i++){

            if(flag==false){
                val=list_K.get(i)+list_A.get(i);
            }else {
                val = list_K.get(i) + list_A.get(i) + 1;
            }
            if(i<length_min-1){
                if(val>=10){
                    res.set(i,val-10);
                    flag = true;
                }else{
                    res.set(i, val);
                    flag = false;
                }
            }else {
                if(val>=10 ){
                    if(length_max==length_min){
                        res.set(i, val-10);
                        res.add(1);
                        flag = false;
                    }else{
                        res.set(i, val-10);
                        flag = true;
                    }
                }else {
                    res.set(i,val);
                    flag = false;
                }
            }
        }

         for (int i=length_min; i<length_max;i++){
             if(flag == true){
                 val = res.get(i) + 1;
                 if(i<length_max-1){
                     if(val<10){
                         res.set(i, val);
                         flag=false;
                     }else{
                         res.set(i,val-10);
                         flag = true;
                     }
                 }else{
                     if(val<10){
                         res.set(i, val);
                         flag=false;
                     }else{
                         res.set(i, val-10);
                         res.add(val/10);
                         flag = true;
                     }
                 }

             }
         }
         for(int i=0; i<res.size()/2; i++){
             int temp=res.get(i);
             res.set(i, res.get(res.size()-1-i));
             res.set(res.size()-1-i, temp);
         }
        return res;

    }
 }