989. Add to Array-Form of Integer

Description

The array-form of an integer num is an array representing its digits in left to right order.

For example, for num = 1321, the array form is [1,3,2,1].

Given num, the array-form of an integer, and an integer k, return the array-form of the integer num + k.

Example 1:

Input: num = [1,2,0,0], k = 34
Output: [1,2,3,4]
Explanation: 1200 + 34 = 1234

Example 2:

Input: num = [2,7,4], k = 181
Output: [4,5,5]
Explanation: 274 + 181 = 455

Example 3:

Input: num = [2,1,5], k = 806
Output: [1,0,2,1]
Explanation: 215 + 806 = 1021

Constraints:

1 <= num.length <= 10⁴
0 <= num[i] <= 9
num does not contain any leading zeros except for the zero itself.
1 <= k <= 10⁴

Solutions

Solution 1: Simulation

We can start from the last digit of the array and add each digit of the array to \(k\). Then, divide \(k\) by \(10\), and use the remainder as the current digit's value, with the quotient as the carry. Continue this process until the array is fully traversed and \(k = 0\). Finally, reverse the answer array.

The time complexity is \(O(n)\), where \(n\) is the length of \(\textit{num}\). Ignoring the space consumption of the answer array, the space complexity is \(O(1)\).

Python3JavaC++GoTypeScriptRust

class Solution:
    def addToArrayForm(self, num: List[int], k: int) -> List[int]:
        ans = []
        i = len(num) - 1
        while i >= 0 or k:
            k += 0 if i < 0 else num[i]
            k, x = divmod(k, 10)
            ans.append(x)
            i -= 1
        return ans[::-1]

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

class Solution {
public:
    vector<int> addToArrayForm(vector<int>& num, int k) {
        vector<int> ans;
        for (int i = num.size() - 1; i >= 0 || k > 0; --i) {
            k += (i >= 0 ? num[i] : 0);
            ans.push_back(k % 10);
            k /= 10;
        }
        ranges::reverse(ans);
        return ans;
    }
};

func addToArrayForm(num []int, k int) (ans []int) {
    for i := len(num) - 1; i >= 0 || k > 0; i-- {
        if i >= 0 {
            k += num[i]
        }
        ans = append(ans, k%10)
        k /= 10
    }
    slices.Reverse(ans)
    return
}

function addToArrayForm(num: number[], k: number): number[] {
    const ans: number[] = [];
    for (let i = num.length - 1; i >= 0 || k > 0; --i) {
        k += i >= 0 ? num[i] : 0;
        ans.push(k % 10);
        k = Math.floor(k / 10);
    }
    return ans.reverse();
}

impl Solution {
    pub fn add_to_array_form(num: Vec<i32>, k: i32) -> Vec<i32> {
        let mut ans = Vec::new();
        let mut k = k;
        let mut i = num.len() as i32 - 1;

        while i >= 0 || k > 0 {
            if i >= 0 {
                k += num[i as usize];
            }
            ans.push(k % 10);
            k /= 10;
            i -= 1;
        }

        ans.reverse();
        ans
    }
}

989. Add to Array-Form of Integer

Description

Solutions

Solution 1: Simulation

Comments