azl397985856 commented 1 year ago

989. 数组形式的整数加法

入选理由

暂无

题目地址

https://leetcode-cn.com/problems/add-to-array-form-of-integer/

前置知识

数组的遍历

题目描述


对于非负整数 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

acy925 commented 1 year ago

思路

两步：第一步：先把给的数组合成一个数；第二步：把合成的数加上给的数，再按上面的过程逆着一遍，变成数组。

代码

class Solution(object):
    def addToArrayForm(self, num, k):
        """
        :type num: List[int]
        :type k: int
        :rtype: List[int]
        """

        a = 0
        for i in num:
            a = a * 10 + i
        a = a + k

        ans = []
        while a != 0:
            ans.append(a % 10)
            a = a // 10

        return ans[::-1]

复杂度分析

时间复杂度：O(N)，其中 N 为数组num长度。
空间复杂度：O(1)

SoSo1105 commented 1 year ago

思路

通过字符串与int之间的转换形成

代码

class Solution:
    def addToArrayForm(self, num: List[int], k: int) -> List[int]:
        resStr = ""
        for i in num:
            resStr +=str(i)
        res = str(int(resStr)+k)
        reslist = []
        for i in res:
            reslist.append(int(i))
        return reslist

复杂度分析

- 时间复杂度：O(n) - 空间复杂度：O(n)

bi9potato commented 1 year ago

思路

从后遍历num和k每一位并相加，进位存在carry变量内

代码


class Solution {
    public List<Integer> addToArrayForm(int[] num, int k) {

        List<Integer> res = new LinkedList<>();
        int carry = 0;

        for( int i = num.length-1; i > -1 ; i-- ) {

            int new_digit = num[i] + k%10 + carry;

            if(new_digit > 9) carry = 1; // update carry
            else carry = 0;

            res.add(0, new_digit % 10); // eliminate carry

            k /= 10;

        }

        while( k != 0) {

            int new_digit = k%10 + carry;

            if(new_digit > 9) carry = 1; // update carry
            else carry = 0;

            res.add(0, new_digit % 10); // eliminate carry

            k /= 10;

        }

        if (carry == 1) res.add(0, 1);

        return res;

    }
}

复杂度分析

时间复杂度：O(N)
空间复杂度：O(N)

guangsizhongbin commented 1 year ago

题目地址(989. 数组形式的整数加法)

https://leetcode.cn/problems/add-to-array-form-of-integer/

题目描述

整数的 数组形式  num 是按照从左到右的顺序表示其数字的数组。

例如，对于 num = 1321 ，数组形式是 [1,3,2,1] 。

给定 num ，整数的 数组形式 ，和整数 k ，返回 整数 num + k 的 数组形式 。

 

示例 1：

输入：num = [1,2,0,0], k = 34
输出：[1,2,3,4]
解释：1200 + 34 = 1234

示例 2：

输入：num = [2,7,4], k = 181
输出：[4,5,5]
解释：274 + 181 = 455

示例 3：

输入：num = [2,1,5], k = 806
输出：[1,0,2,1]
解释：215 + 806 = 1021

 

提示：

1 <= num.length <= 104
0 <= num[i] <= 9
num 不包含任何前导零，除了零本身
1 <= k <= 104

前置知识

公司

暂无

思路

关键点

代码

语言支持：Go

Go Code:


func addToArrayForm(array []int, num int) []int {
    // 1. plus two array 
    anotherArray :=  plusTwoArray(array, num)

    // 2. reverseArray
    return reverseArray(anotherArray)
}

func plusTwoArray(arr1 []int, num int)(res []int){

    i := len(arr1) - 1
    carry := 0
    for i >= 0 || num > 0 {   // 
        a, b := 0, 0
        if i >= 0 {
            a = arr1[i]
            i--
        }

        if num >= 0 {
            b = num % 10
            num /= 10
        }

        sum := a + b + carry

        res = append(res, sum % 10)
        carry = sum / 10
    }

    if carry > 0 {
        res = append(res, carry)
    }

    return res
}

func reverseArray(array []int) []int {

    i, j := 0, len(array) - 1

    for i < j {
        array[i], array[j] = array[j], array[i]
        i++
        j--
    }

    return array
}

复杂度分析

令 n 为数组长度。

时间复杂度：$O(n)$
空间复杂度：$O(n)$

zhaoygcq commented 1 year ago

思路

将数字转化为一个数组;之后将两个数组进行逐位相加.

代码

/**
 * @param {number[]} num
 * @param {number} k
 * @return {number[]}
 */
var addToArrayForm = function(num, k) {
    let len = num.length;
    let kSplitArr = String(k).split("").map(item => Number(item));
    let kSplitLen = kSplitArr.length;
    if(len < kSplitLen) {
        let temp = num;
        num = kSplitArr;
        kSplitArr = temp;
    }

    // 逐位相加
    let flag = 0;
    len = num.length - 1;
    while(kSplitArr.length || flag) {
        let kVal = kSplitArr.pop();
        let val;
        if(kVal >= 0) {
            val = num[len] + kVal + flag;
        } else {
            val = num[len] + flag;
        }
        flag = Math.floor(val / 10);
        num[len] = val % 10;
        if(flag && len - 1 < 0) {
           num.unshift(flag)
        }
        len--;
    }
    // console.log(num)
    return num;
};

复杂度分析

时间复杂度：O(N)，其中 N 为数组长度。
空间复杂度：O(1)

cyk1337 commented 1 year ago

BF:

class Solution(object):
    def addToArrayForm(self, num, k):
        """
        :type num: List[int]
        :type k: int
        :rtype: List[int]
        """
        a = "".join([str(x) for x in num])
        b = str(int(a)+k)
        return [int(x) for x in b]

snmyj commented 1 year ago

class Solution {
public:
    vector<int> addToArrayForm(vector<int>& num, int k) {
        vector<int> b,ans;
          while(k>0){
               b.push_back(k%10);
               k/=10;
          }
        reverse(b.begin(),b.end());
        int d=0;
        for(int i=num.size()-1,j=b.size()-1;i>=0&&j>=0;i--,j--){
               int add=num[i]+b[j]+d;
               ans.push_back(add%10);
                d=add/10;
               if(i==0) {
                   j--;
                   while(j>=0){
                       int add1=b[j]+d;  
                       ans.push_back((b[j]+d)%10);
                       d=add1/10;
                       j--;
                    }
                     if(d!=0) ans.push_back(d);
               }
                if(j==0) {
                   i--;
                   while(i>=0){
                       int add1=num[i]+d;  
                       ans.push_back((num[i]+d)%10);
                       d=add1/10;
                       i--;
                    }
                     if(d!=0) ans.push_back(d);
               }

        }
        reverse(ans.begin(),ans.end());
        return ans;
    }
};

t：o(n)

yfu6 commented 1 year ago

class Solution: def addToArrayForm(self, num: List[int], k: int) -> List[int]: for i in range(len(num) - 1, -1, -1): if not k: break k, num[i] = divmod(num[i] + k, 10) while k: k, a = divmod(k, 10) num = [a] + num return num

xixiao51 commented 1 year ago

题目地址(989. 数组形式的整数加法)

https://leetcode.cn/problems/add-to-array-form-of-integer/

题目描述

整数的 数组形式  num 是按照从左到右的顺序表示其数字的数组。

例如，对于 num = 1321 ，数组形式是 [1,3,2,1] 。

给定 num ，整数的 数组形式 ，和整数 k ，返回 整数 num + k 的 数组形式 。

 

示例 1：

输入：num = [1,2,0,0], k = 34
输出：[1,2,3,4]
解释：1200 + 34 = 1234

示例 2：

输入：num = [2,7,4], k = 181
输出：[4,5,5]
解释：274 + 181 = 455

示例 3：

输入：num = [2,1,5], k = 806
输出：[1,0,2,1]
解释：215 + 806 = 1021

 

提示：

1 <= num.length <= 104
0 <= num[i] <= 9
num 不包含任何前导零，除了零本身
1 <= k <= 104

前置知识

数组

公司

暂无

思路

We iterate over num and k, performing the addition digit by digit, and storing the result in the result list. The carry is calculated by dividing the sum by 10. After the addition loop, we reverse the result list and return it.

关键点

Reverse the list before return the result
k % 10 as result digit, k /10 as carry

代码

语言支持：Java

Java Code:


class Solution {
    public List<Integer> addToArrayForm(int[] num, int k) {
        List<Integer> result = new ArrayList<>();
        int i = num.length - 1;

        while(i >= 0 || k > 0) {
            if(i >= 0) {
                k += num[i--];
            }
            result.add(k % 10);
            k /= 10;
        }

        Collections.reverse(result);
        return result;
    }
}

复杂度分析

令 n 为数组长度。

时间复杂度：$O(n)$
空间复杂度：$O(n)$

catkathy commented 1 year ago

思路

将整数数组 num 转换为一个整数，然后将整数 k 加到这个整数上，再将得到的和转换回整数数组

Python Code

class Solution:
    def addToArrayForm(self, num: List[int], k: int) -> List[int]:

        n = 0
        for i in num:
            n = n * 10 + i

        n = n + k
        num = []

        while n != 0:
            num.append(n % 10)
            n //= 10

        return num[::-1]

复杂度分析

Time: O(N)
Space: O(1)

YQYCS commented 1 year ago

思路：

将K逐位分解，加入到A中。具体实现方式是将 K 从末位开始依次加到 A 中对应位置上，若相加后的结果大于等于 10，则将进位部分加到下一位上；若 K 加完后仍有进位，则在 A 的最前面插入一个 0。

代码：

class Solution:
  def addToArrayForm(self, A: List[int], K: int) -> List[int]:
        i = len(A) - 1
        while K:
            A[i] += K
            K, A[i] = A[i] // 10, A[i] % 10
            i -= 1
            if i < 0 and K:
                A.insert(0,0)
                i = 0
        return A

复杂度：

 时间复杂度为 O(n)，其中 n 为数组 A 的长度。因为需要遍历整个数组 A，所以时间复杂度与数组 A 的长度成正比。

zhuxinyu-znb commented 1 year ago

思路：

将k和num全都转化为num数组，倒叙排列后逐位相加，因为如果直接都转为数字相加的话，有可能会溢出。逐位相加后如果超过9了说明需要进位，将进位符置1，如不满则为0，将保留各位后的数字push进结果数组。依次相加后直到某个长度更短的数组全部遍历完后结束相加过程。再将两数组剩余的部分进行遍历填充，这里要注意的是记得将之前的进位符进行处理，防止遗漏。都遍历完之后再处理一遍进位符最后将数组倒序回来就可以得到最终的结果

代码：

/**
 * @param {number[]} num
 * @param {number} k
 * @return {number[]}
 */
var addToArrayForm = function(num, k) {
    let k_num = String(k).split('').map((num) => Number(num)).reverse()
    num = num.reverse()
    let temp = 0;
    const k_len = k_num.length;
    const num_len = num.length;
    let i = 0;
    let res_num = []
    while(i < k_len && i< num_len) {
        let res = k_num[i] + num[i] + temp
        if (res > 9) {
            temp = 1
            res = res - 10
        } else {
            temp = 0
        }
        res_num.push(res)
        i++
    }
    while(i < k_len) {
        let res = k_num[i] + temp
        if (res > 9) {
            temp = 1
            res = res - 10
        } else {
            temp = 0
        }
        res_num.push(res)
        i++
    }
    while(i < num_len) {
        let res = num[i] + temp
        if (res > 9) {
            temp = 1
            res = res - 10
        } else {
            temp = 0
        }
        res_num.push(res)
        i++
    }
    if (temp > 0) {
        res_num.push(temp)
    }
    return res_num.reverse()
};

复杂度：

时间复杂度为O(n) 空间复杂度为O(n)

freesan44 commented 1 year ago

思想:

通过小数组大数组分别pop来实现

代码:

class Solution989 {
    func addToArrayForm(_ num: [Int], _ k: Int) -> [Int] {
//        var newK = Array<Int>()
//        var vk = k
//        var vNum: [Int] = num
//        var newRet = Array<Int>()
//
//        while vk>0 {
//            newK.insert(vk%10, at: 0)
//            vk = vk/10
//        }
//        var temp = 0
//        while vNum.count>0 || newK.count>0 || temp != 0{
//            var left = 0
//            var right = 0
//            if vNum.count>0{
//                left = vNum.removeLast()
//            }
//            if newK.count>0{
//                right = newK.removeLast()
//            }
//            print(right,left)
//            var ret = left + right + temp
//            temp = 0
//            if ret>9{
//                temp = ret/10
//                ret = ret%10
//            }
//            newRet.insert(ret, at: 0)
////            print(newRet)
//        }
//        return newRet
        var res = [Int]()
        var n = num.count
        var vk = k

        for i in stride(from: n - 1, through: 0, by: -1) {
            if i >= 0 {
                vk += num[i]
            }
            res.append(vk % 10)
            vk /= 10
        }

        while vk > 0 {
            res.append(vk % 10)
            vk /= 10
        }

        return res.reversed()
    }

    func test() {
//        var num = [2,7,4]
//        var k = 983
        var num = [1,2,0,0]
        var k = 34
        let ret = addToArrayForm(num,k);
        print(ret);
    }
}

Diana21170648 commented 1 year ago

思路

低位到高位遍历，注意进位

代码

class Solution:
    def addToArrayForm(self, num: List[int], k: int) -> List[int]:
        n=len(num)-1
        carry=0
        ans=[]
        for i in range(n,-1,-1):#从后往前遍历
              num[i], carry=(carry+num[i]+k%10)%10,(carry+num[i]+k%10)//10
              k//=10
        #考虑998+2还需要进位
        carry=carry+k
        while carry:
            ans=[(carry)%10]+ans
            carry//=10
        return ans+num

复杂度分析

时间复杂度：O(N)，其中 N 为数组长度。
空间复杂度：O(N)

yetfan commented 1 year ago

思路反向遍历，处理进位。如果数组num处理完，还有k没处理，直接把k加上进位，完成剩余的new_k的处理。

代码

class Solution:
    def addToArrayForm(self, num: List[int], k: int) -> List[int]:
        ans = []
        c = 0 

        for i in num[::-1]:
            nk = k % 10 if k>0 else 0
            k = k // 10

            new = i + nk + c
            ans.append(new % 10)
            c = new // 10

        k += c
        while k > 0:
            nk = k % 10
            k = k // 10
            ans.append(nk)

        return ans[::-1]

复杂度 时间 O(N) 空间 O(N)

mo660 commented 1 year ago

思路

将数组反向与数字余数相加，记录进位。处理完数组后，k与进位相加，再遍历k值，求%10以及/10，最后res数组反序

代码

class Solution {
public:
    vector<int> addToArrayForm(vector<int>& num, int k) {
        vector<int>res;
        int carryNum = 0;
        for(int i = num.size() - 1; i >= 0; i--)
        {
            int tmpSum = num[i] + carryNum;
            if (k)
                tmpSum += (k%10);
            res.push_back(tmpSum%10);
            carryNum = tmpSum/10;
            if (k)
                k = k/10;
        }
        k += carryNum;
        while (k)
        {
            res.push_back(k % 10);
            k = k/10;
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

复杂度

时间 O(N)
空间 O(N)

Erjian96 commented 1 year ago

思路从最后一位开始相加，每次记录进位。

def solution(num, k):

    res = k
    list_a = num
    output = []
    i = 0
    while i < len(num):
        sum = k + num[len(num)-i-1] 
        out = sum % 10
        output.insert(0, out)
        k = sum // 10
        i=i+1
    if k == 0:
         return output
    else: 
        while k != 0:
            k_res = k % 10
            k = k//10
            output.insert(0, k_res)
        return output

Sencc commented 1 year ago

思路将数字列表 num 转换为数字字符串，再将数字与k相加，最后返回一个列表

代码 class Solution(object): def addToArrayForm(self, num, k): """ :type num: List[int] :type k: int :rtype: List[int] """ list_str = "".join(str(x) for x in num) number = int(list_str)+k return [int(x) for x in str(number)]

复杂度空间复杂度O(n) 时间复杂度O(n)

Fuku-L commented 1 year ago

思路

从最后一位开始相加，每次记录进位。

代码

class Solution {
    public List<Integer> addToArrayForm(int[] num, int k) {
        List<Integer> res = new ArrayList<Integer>();
        int sum = 0;
        int carry = 0;
        int idx = num.length-1;
        while(idx >=0 || k !=0){
            int a = idx >= 0 ? num[idx]:0;
            int b = k!=0 ? k%10:0;
            sum = a+b+carry;
            res.add(0,sum%10);
            carry = sum/10;
            idx--;
            k/=10;
        }
        if(carry!=0) res.add(0, carry);
        return res;
    }
}

复杂度分析

时间复杂度：O(N)，其中 N 为数组长度。
空间复杂度：O(1)

joemonkeylee commented 1 year ago


function addToArrayForm(num: number[], k: number): number[] {
  let res: number[] = [];
  let carry: number = 0;
  let N: number = num.length - 1;
  let temp: number = 0;
  while (k / 10 != 0 || N >= 0) {
    if (N >= 0) {
      temp = num[N];
    } else {
      temp = 0;
    }
    if ((k % 10) + temp + carry >= 10) {
      res.push((k % 10) + temp + carry - 10);
      carry = 1;
    } else {
      res.push((k % 10) + temp + carry);
      carry = 0;
    }
    N--;
    k = (k - (k % 10)) / 10;
  }
  if (carry == 1) {
    res.push(carry);
  }
  return res.reverse();
}

RanDong22 commented 1 year ago

解题思路

整体思路还是逐位计算，麻烦的点在于使用原地算法完成，时间复杂度为 max(n.length, k的位数)中较大的一个，具体细节写在代码注释中，关键点在于如何不重置k对k进行计算和处理

代码

var addToArrayForm = function (num: number[], k: number) {
  let add = false; // 存储当前位数计算结果是否超过 10,需要进位
  let i = 1; // 存储当前循环到的位数
  let l = num.length; // 存储 num 的长度,后续用的时候方便点
  while (10 ** (i - 1) <= k || add) {
    // 截止条件为 k 遍历完成10 ** (i - 1) <= k 例如当k === 9的时候 10 ** (1 - 1) <= 9 证明还需要一次,10 ** (2 - 1) > 9 就证明遍历完成了,的同时进位也处理完成
    let ki = ~~((k % 10 ** i) / 10 ** (i - 1)) + (add ? 1 : 0); // 计算当前 k 的值是多少, k % 10 ** i去除超过当前位数的,例如 134 计算第二位 = 134 % 10 ** 2 = 34,  / 10 ** (i - 1) 去除小于当前为的,例如 34 / 10 ** (2 - 1) = 3.4, ~~(3.4) = 3 这样即可获取当前数字第二位为 3这如果不想这么麻烦可以每次重置 k 的值,向下去除一位取整即可, add 为上一次计算是够有进位
    let numi = num[l - i] ?? 0; // 存储当前 num 的位数上是什么,由于可能有 k 的总长度 > num 的长度的情况,这需要做 undefined 判断
    let tari = numi + ki; // 计算当前位数的和
    if (tari >= 10) {
      // 如果当前位数和超过 10 了,更改 add 状态, 更改当前位置和的值
      add = true;
      tari -= 10;
    } else {
      add = false;
    }
    if (i === l + 1) {
      // 如果当前位数已经超过 num 了,要像 num 之前 push,否则直接原地更改 num 即可
      num.unshift(tari);
      l = num.length;
    } else {
      num[l - i] = tari;
    }
    i++;
  }
  return num;
};

61hhh commented 1 year ago

思路

逐位求和并考虑进位问题，求和需要判断 num、k 是否没有取完，每次计算更新值

代码

class Solution {
    public List<Integer> addToArrayForm(int[] num, int k) {
        List<Integer> res = new ArrayList<>();
        int n = num.length;
        int carry = 0;
        for (int i = n - 1; i >= 0 || k > 0 || carry > 0; i--) {
            int sum = carry;
            if (i >= 0) {
                sum += num[i];
            }
            if (k > 0) {
                sum += k % 10;
                k /= 10;
            }
            res.add(sum % 10);
            carry = sum / 10;
        }
        Collections.reverse(res);
        return res;
    }
}

复杂度分析

时间复杂度：O(N)
空间复杂度：O(N)

jamjid commented 1 year ago

思路使用逐位相加的思路解决，同时考虑A和K的长度比较

代码 class Solution: def addToArrayForm(self, A: List[int], K: int) -> List[int]: n = len(A) ans = []

    for i in range(n-1, -1, -1):
        total = A[i] + K % 10

        K //= 10

        if total >= 10:
            #当前位相加结果大于 10 时，进位 1 加入下一位计算
            K += 1

        ans.append(total % 10)

    # 这里考虑数组 A 的长度小于整数 K 位数个数的情况
    while K > 0:
        ans.append(K % 10)
        K //= 10
    # 因为添加进来是由低位往高位，输出时进行逆序输出
    return ans[::-1]

复杂度时间复杂度O(n) 空间复杂度O(n)

yzhyzhyzh123 commented 1 year ago

思路

将k和num全都转化为num数组，倒叙排列后逐位相加，逐位相加后如果超过9了说明需要进位，将进位符置1，如不满则为0，将保留各位后的数字添加进结果数组。依次相加后直到某个长度更短的数组全部遍历完后结束相加过程。最后将数组倒序回来就可以得到最终的结果

代码

class Solution {
    public List<Integer> addToArrayForm(int[] num, int k) {
        List<Integer> res = new ArrayList<Integer>();
        int n = num.length;
        // 1. 从后往前逐位相加
        for(int i = n - 1; i >= 0; i--){
            // 逐位相加
            int sum = num[i] + k % 10;         
            k /= 10;    
            // 两位相加 进位
            if(sum >= 10){
                k++;                        // 进位到k的末尾
                sum -= 10;                  // 进位清掉
            }
            // 1.2 当前相加的结果 添加到结果集
            res.add(sum);
        }

        // 2. k的数字长度大于数组的数字长度
        for(; k > 0; k /= 10){               
            res.add(k % 10);               
        }

        // 3. 结果集翻转
        Collections.reverse(res);
        return res;
    }
}

复杂度

时间复杂度为O(n) 空间复杂度为O(n)

SunStrongChina commented 1 year ago

思路：先将列表转化为整数，加起来，然后再将最终结果展开为列表

class Solution:
    def addToArrayForm(self, num: List[int], k: int) -> List[int]:
        ##对k进行展开
        num_val = 0
        for i in range(1,len(num)+1):
            num_val += num[-i] * (10 ** (i-1))
        num_val += k
        ex_vals = []
        while num_val > 9:
            v1 = num_val % 10
            ex_vals= [v1] + ex_vals
            num_val -= v1
            num_val  = num_val // 10
        ex_vals = [num_val] + ex_vals
        return ex_vals

时间复杂度：O(n) 空间复杂度：O(n)

dongzegithub commented 1 year ago

 public List<Integer> addToArrayForm(int[] num, int k) {
        List<Integer> res = new ArrayList<>();
        int i = num.length - 1;
        int carry = 0;
        int sum = 0;
        while (i >= 0 || k > 0) {
            int n = i >= 0 ? num[i] : 0;
            int m = k > 0 ? k % 10 : 0;
            k = k/10;
            i--;

            sum = n + m + carry;
            carry = sum / 10;
            res.add(sum % 10);
        }
        if (carry != 0) {
            res.add(carry);
        }
        Collections.reverse(res);
        return res;
    }

zcytm3000 commented 1 year ago

class Solution: def addToArrayForm(self, A: List[int], K: int) -> List[int]: n=len(A) ans = []

    for i in range(n-1, -1, -1):
        total = A[i] + K % 10

        K //= 10

        if total >= 10:

            K += 1

        ans.append(total % 10)

    while K > 0:
        ans.append(K % 10)
        K //= 10
    return ans[::-1]

yaya-bb commented 1 year ago

/**
 * @param {number[]} num
 * @param {number} k
 * @return {number[]}
 */
var addToArrayForm = function(num, k) {
    let res = [];
    let n = num.length;
    for(let i = n -1; i >= 0; i--)
    {
        let sum = num[i] + k%10;
        k = Math.floor(k/10);
        if(sum>=10)
        {
            k++;
            sum = sum -10;
        }
        res.push(sum);
    }
    for(;k>0;k = Math.floor(k/10))
    {
        res.push(k%10);
    }
    res.reverse();
    return res;

};

C2tr commented 1 year ago

class Solution { public List addToArrayForm(int[] num, int k) { List res = new ArrayList<>(); int n = num.length; int carry = 0; for (int i = n - 1; i >= 0 || k > 0 || carry > 0; i--) { int sum = carry; if (i >= 0) { sum += num[i]; } if (k > 0) { sum += k % 10; k /= 10; } res.add(sum % 10); carry = sum / 10; } Collections.reverse(res); return res; } }

MetSystem commented 1 year ago

public int AddToArrayForm(int[] num, int k) { int result = k;

        for (int i = 0; i > num.Length; i++) {
          result = result + num[i] * Math.Pow(10,num.Length-i);
        }

        return result;
}

GuitarYs commented 1 year ago

public int AddToArrayForm(int[] num, int k) { int result = k;

    for (int i = 0; i > num.Length; i++) {
      result = result + num[i] * Math.Pow(10,num.Length-i);
    }

    return result;

}

sosdogecoin commented 1 year ago

public int AddToArrayForm(int[] num, int k) { int result = k; for (int i = 0; i > num.Length; i++) { result = result + num[i] * Math.Pow(10,num.Length-i);} return result;}

Alexno1no2 commented 1 year ago

class Solution:
    def addToArrayForm(self, num: List[int], k: int) -> List[int]:
        i = len(num) - 1
        while k:
            num[i] += k
            k, num[i] = num[i] // 10, num[i] % 10
            i -= 1

            if i < 0 and k:
                num.insert(0,0)
                i = 0
        return num

jameswangxin commented 1 year ago

class Solution {
    public List<Integer> addToArrayForm(int[] num, int k) {
      List<Integer> result = new ArrayList<>();
        for(int i = num.length - 1; i >= 0; i--){
            int sum = num[i] + k % 10;         
            k /= 10;    
            if(sum >= 10){
                k++;                        
                sum -= 10;                
            }
            result.add(sum);
        }

        for(; k > 0; k /= 10){               
            result.add(k % 10);               
        }
        Collections.reverse(result);
        return result;
    }
}

时间复杂度 O(n)

空间复杂度 O(n)

Miller-em commented 1 year ago

思路

直接在数组最后的元素进行相加，将k得到最后一位数，放在数组的末尾，再取高位，从num的末尾指针从后到前，得到原数组相加

代码

class Solution:
    def addToArrayForm(self, num: List[int], k: int) -> List[int]:
        i = len(num) - 1
        while k:
            num[i] += k
            k, num[i] = num[i] // 10, num[i] % 10
            i -= 1

            if i < 0 and k:
                num.insert(0,0)
                i = 0
        return num

dorian-byte commented 1 year ago

思路：

给定一个整数数组num和一个非负整数k，将k加到数组num的表示形式上，返回相加后的新数组。我们可以从数组num的最后一位开始，将k的个位数与num的最后一位相加，并记录进位。然后依次将k的十位数、百位数等与num的前一位相加，并考虑进位。如果num已经遍历完而k还有剩余位数，可以将剩余的位数与进位相加。最后，将剩余的进位加入结果数组中。

代码：

def addToArrayForm(num, k):
    kstr = list(map(int, str(k)))  # 将k转换为整数数组
    res = []  # 结果数组
    carry = 0  # 进位
    while kstr or num or carry:
        kp = kstr.pop() if kstr else 0  # 获取k的当前位数，若已经遍历完则为0
        np = num.pop() if num else 0  # 获取num的当前位数，若已经遍历完则为0
        mod = (kp + np + carry) % 10  # 当前位数相加并考虑进位后的结果
        carry = (kp + np + carry) // 10  # 计算进位
        res.insert(0, mod)  # 将当前位数的结果插入到结果数组的最前面
    return res

复杂度分析：

时间复杂度：假设num的长度为n，k的位数为m，则时间复杂度为O(max(n, m))，需要遍历num和k的位数。空间复杂度：除了返回的结果数组外，额外使用了kstr、res和carry这些辅助变量，空间复杂度为O(max(n, m))。

Beanza commented 1 year ago

var addToArrayForm = function(num, k) { let len = num.length; let kSplitArr = String(k).split("").map(item => Number(item)); let kSplitLen = kSplitArr.length; if(len < kSplitLen) { let temp = num; num = kSplitArr; kSplitArr = temp; }

// 逐位相加
let flag = 0;
len = num.length - 1;
while(kSplitArr.length || flag) {
    let kVal = kSplitArr.pop();
    let val;
    if(kVal >= 0) {
        val = num[len] + kVal + flag;
    } else {
        val = num[len] + flag;
    }
    flag = Math.floor(val / 10);
    num[len] = val % 10;
    if(flag && len - 1 < 0) {
       num.unshift(flag)
    }
    len--;
}
// console.log(num)
return num;

}; 复杂度分析

时间复杂度：O(N)，其中 N 为数组长度。空间复杂度：O(1)

wzbwzt commented 1 year ago

/* 思路：逐位相加: 再反转

复杂度：空间复杂度:O(N) 时间复杂度:O(N) */

func addToArrayForm(num []int, k int) []int {
    out := make([]int, 0)
    for i := len(num) - 1; i >= 0; i-- {
        v := k % 10
        k /= 10
        sum := num[i] + v
        if sum >= 10 {
            k += 1
        }
        out = append(out, sum%10)
    }

    for ; k > 0; k /= 10 {
        out = append(out, k%10)
    }

    reverse(out)
    return out
}

func reverse(a []int) {
    n := len(a)
    for i := 0; i < n/2; i++ {
        a[i], a[n-i-1] = a[n-i-1], a[i]
    }
}

954545647 commented 1 year ago

js code


var addToArrayForm = function (num, k) {
  let i = num.length - 1;
  let res = [];
  let carry = 0;
  while (i >= 0 || k !== 0) {
    const a = i >= 0 ? num[i] : 0;
    const b = k !== 0 ? k % 10 : 0;
    k = Math.floor(k / 10);
    const sum = a + b + carry;
    res.push(sum % 10);
    carry = sum >= 10 ? 1 : 0;
    i--;
  }
  if (carry) res.push(carry);
  return res.reverse();
};

Moin-Jer commented 1 year ago

class Solution {
    public List<Integer> addToArrayForm(int[] num, int k) {
        List<Integer> list = new ArrayList<>();
        int add = 0;
        num[num.length - 1] += k;
        for(int i = num.length - 1; i >= 0; --i) {
            num[i] = num[i] + add;
            add = num[i] / 10;
            list.add(num[i] % 10);
        }
        while (add != 0) {
            list.add(add % 10);
            add /= 10;
        }
        Collections.reverse(list);
        return list;
    }
}

RestlessBreeze commented 1 year ago

code

class Solution {
public:
    vector<int> addToArrayForm(vector<int>& num, int k) {
        vector<int> res;
        int length = num.size();
        int i;
        for (i = 0; i < length && k > 0; i++)
        {
            int temp = num[length - 1 - i] + k % 10;
            res.push_back(temp % 10);
            k = k / 10 + temp / 10;
        }
        while (i < length)
        {
            res.push_back(num[length - 1 - i]);
            i++;
        }
        while (k > 0)
        {
            res.push_back(k % 10);
            k /= 10;
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

leetcode-pp / 91alg-11-daily-check

【Day 1 】2023-06-10 - 989. 数组形式的整数加法 #2

989. 数组形式的整数加法

入选理由

题目地址

前置知识

题目描述

思路

代码

思路

代码

思路

代码

题目地址(989. 数组形式的整数加法)

题目描述

前置知识

公司

思路

关键点

代码

思路

代码

题目地址(989. 数组形式的整数加法)

题目描述

前置知识

公司

思路

关键点

代码

思路

Python Code

复杂度分析

思路：

代码：

复杂度：

思路：

代码：

复杂度：

思想:

代码:

思路

代码

思路

代码

复杂度

思路

代码

解题思路

代码

思路

代码

复杂度分析

思路

代码

复杂度

思路

代码

code