Add to Array-Form of Integer - Practice Coding Problems

Add to Array-Form of Integer - Problem

Array Math Easy

In computer science, we often need to work with numbers in different representations. The array-form of an integer is one such representation where each digit of the number becomes an element in an array, ordered from left to right.

For example:

The number 1321 becomes [1, 3, 2, 1]
The number 999 becomes [9, 9, 9]

Your task is to implement addition in this array format. Given an array num representing a number and an integer k, you need to compute num + k and return the result in array-form.

The challenge lies in handling carries properly, just like when you add numbers by hand!

Input & Output

example_1.py — Basic Addition

$ Input: num = [1,2,0,0], k = 34

› Output: [1,2,3,4]

💡 Note: The array [1,2,0,0] represents 1200, and 1200 + 34 = 1234, which in array form is [1,2,3,4]

example_2.py — Carry Propagation

$ Input: num = [2,7,4], k = 181

› Output: [4,5,5]

💡 Note: 274 + 181 = 455. Notice how the addition creates carries that propagate through multiple digits

example_3.py — Result Longer Than Input

$ Input: num = [9,9,9], k = 1

› Output: [1,0,0,0]

💡 Note: 999 + 1 = 1000. The result has more digits than the original array due to carry overflow

Visualization

Tap to expand

Understanding the Visualization

Initialize

Set pointer to rightmost digit, k becomes our initial carry

Add Current

Add carry to current digit (or 0 if past array start)

Extract & Carry

Take remainder as result digit, quotient as new carry

Move Left

Continue until no more digits and no carry remains

Reverse

Since we built the result backwards, reverse it

Key Takeaway

🎯 Key Insight: By treating k as an initial carry and processing from right to left, we naturally handle all carries without needing to convert to integers, making this approach both elegant and overflow-safe.

Time & Space Complexity

Time Complexity

⏱️

O(max(n, log k))

We process each digit of the input array once, plus additional digits from k if k is larger than the array represents

⚡ Linearithmic

Space Complexity

O(max(n, log k))

Space for the result array, which can be at most one digit longer than the larger of the two inputs

⚡ Linearithmic Space

Constraints

1 ≤ num.length ≤ 10⁴
0 ≤ num[i] ≤ 9
num does not contain any leading zeros except for the zero itself
1 ≤ k ≤ 10⁴
No leading zeros in the result array

Asked in

G Google 25 Apple 18 a Amazon 15 ⊞ Microsoft 12

The optimal approach treats k as an initial carry and processes digits from right to left, simulating manual addition. This avoids integer overflow issues and handles arbitrarily large numbers with O(max(n, log k)) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Digit-by-Digit Addition (Optimal)	O(max(n, log k))	O(max(n, log k))	Simulate manual addition by processing digits from right to left with carry

Digit-by-Digit Addition (Optimal) — Algorithm Steps

Start from the rightmost digit of the array
Add k to the current digit (k acts as carry initially)
If sum ≥ 10, keep remainder and carry quotient to next digit
Continue until no more carries and no more digits
Reverse the result since we built it backwards

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Right

Begin from rightmost digit, k becomes initial carry

Add & Carry

Add carry to current digit, propagate if ≥ 10

Continue Left

Move to next digit, repeat until done

Reverse Result

We built backwards, so reverse for final answer

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int* addToArrayForm(int* num, int numSize, int k, int* returnSize) {
    int* temp = (int*)malloc(10010 * sizeof(int)); // Temporary array
    int tempSize = 0;
    int i = numSize - 1;
    int carry = k;
    
    while (i >= 0 || carry > 0) {
        if (i >= 0) {
            carry += num[i];
        }
        
        temp[tempSize++] = carry % 10;
        carry /= 10;
        i--;
    }
    
    // Allocate result and reverse
    int* result = (int*)malloc(tempSize * sizeof(int));
    *returnSize = tempSize;
    
    for (int j = 0; j < tempSize; j++) {
        result[j] = temp[tempSize - 1 - j];
    }
    
    free(temp);
    return result;
}

int main() {
    int num[] = {1, 2, 0, 0};
    int k = 34;
    int returnSize;
    
    int* result = addToArrayForm(num, 4, k, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(max(n, log k))

We process each digit of the input array once, plus additional digits from k if k is larger than the array represents

⚡ Linearithmic

Space Complexity

O(max(n, log k))

Space for the result array, which can be at most one digit longer than the larger of the two inputs

⚡ Linearithmic Space

Constraints

1 ≤ num.length ≤ 10⁴
0 ≤ num[i] ≤ 9
num does not contain any leading zeros except for the zero itself
1 ≤ k ≤ 10⁴
No leading zeros in the result array

42.5K Views

Medium Frequency

~15 min Avg. Time

1.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Digit-by-Digit Addition (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler