leecode刷题日记989

写在前边

今天的每日一题是一道简单的题目，我觉得简单在思路简单，但是具体去实现还是需要一点耐心和细心的。

问题描述：
对于非负整数 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

题目描述非常简单，无非是用一个数组和一个int的整数去相加，问题就是形式的转化，我的思路是把int也转变为数组，这样处理起来更加方便，当然把数组的数字转变为一个int可能也行，但是我没有尝试。

具体思路

先得出K这个数的位数，并且同时把他每一位的数字放到另一个vector B中，然后把数组A逆序，即reverse函数，这样两个数组都是低位在前高位在后。然后就可以依此处理每一位数字，首先是两个数组重叠的部分，先取int length为两个数组长度最小的那一个，把两个数组重叠的部分处理完，再处理剩下的部分，最后只剩下最高位是否有进位，如果有，就在整个数组后边push进去一个1就好了。

现在的问题便是如何处理数组中的数相加，由于数相加只可能产生1进位，所以设一个变量overflow来表示进位，初始化为0.然后对每一位进行相加的判断，如果进位和两个数组对应位数的数字相加之和大于等于10，要只取个位，所以直接把两个数组对应位数的数字加起来，然后把结果%10作为真正的结果就好了，同时还要判断进位，就这样循环判断，直至将较短的那一个判断完。

剩下部分就比较简单，只需要判断那个较长数组就可以了，思路是一样的。

最后如果全部判断完了，进位还为1，那么就在结果数组后边加一个1，说明位数增加了。

源代码

#include"iostream"
#include"vector"
#include"algorithm"

using namespace std;

class Solution {
public:
    vector<int> addToArrayForm(vector<int>& A, int K) {
        reverse(A.begin(),A.end());
        vector<int> B;
        int overflow=0;
        int bitNum=0;
        int n=1;
        while(K/n>0)
        {
            bitNum++;
            B.push_back(K%10);
            K=K/10;
        }
        int maxsize=min(A.size(),B.size());
        vector<int> C(max(A.size(),B.size()));
        for(int i=0;i<maxsize;i++)
        {
           int temp=overflow+A[i]+B[i]>=10?1:0;
           C[i]=(overflow+A[i]+B[i])%10;
           overflow=temp;
        }
        if(A.size()>B.size())
        {
                for(int i=maxsize;i<A.size();i++)
                {
                    int temp=overflow+A[i]>=10?1:0;
                    C[i]=(overflow+A[i])%10;
                    overflow=temp;  
                }
        }
        else if(A.size()<B.size())
        {
                for(int i=maxsize;i<B.size();i++)
                {
                    int temp=overflow+B[i]>=10?1:0;
                    C[i]=(overflow+B[i])%10;
                    overflow=temp;   
                }
        }
        if(overflow)
        {
            C.push_back(1);
        }
        reverse(C.begin(),C.end());
        return C;
    }
};
int main()
{
    vector<int> A={9,9,9,9,9,9,9,9,9,9,9,9};
    int K=1;
    Solution s;
    vector<int> nums(s.addToArrayForm(A,K));
    for(int i=0;i<nums.size();i++)
    {
        cout<<nums[i]<<endl;
    }
    system("pause");
    return 0;
}