Add to Array-Form of Integer

Add to Array-Form of Integer - Problem

Array Math Easy

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.

Input & Output

Example 1 — Basic Addition

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

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

💡 Note: Array [1,2,0,0] represents 1200. Adding 34 gives us 1234, which is [1,2,3,4] in array form.

Example 2 — Small Array

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

› Output: [4,5,5]

💡 Note: Array [2,7,4] represents 274. Adding 181 gives us 455, which is [4,5,5] in array form.

Example 3 — Carry Overflow

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

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

💡 Note: Array [9,9,9] represents 999. Adding 1 gives us 1000, which requires expanding to [1,0,0,0].

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 🍎 Apple 12 M Microsoft 8

The key insight is to add k directly to the array using digit-by-digit addition with carry propagation, avoiding integer overflow. The optimal approach processes digits from right to left, handling carries like manual addition. Time: O(max(n, log k)), Space: O(1)

Common Approaches

✓ Convert to Integer and Back

⏱️ Time: O(n) Space: O(1)

First convert the array digits to an actual integer, add k to it, then convert the result back to an array of digits. This is straightforward but may overflow for very large numbers.

Digit-by-Digit Addition with Carry

⏱️ Time: O(max(n, log k)) Space: O(1)

Instead of converting to integer, we add k directly to the array starting from the rightmost digit. We handle carries just like manual addition, extending the array if needed.

Convert to Integer and Back — Algorithm Steps

Convert array [1,2,0,0] to integer 1200
Add k: 1200 + 34 = 1234
Convert 1234 back to array [1,2,3,4]

Visualization

Tap to expand

Step-by-Step Walkthrough

Array to Integer

Convert [1,2,0,0] to 1200

Add K

1200 + 34 = 1234

Back to Array

Convert 1234 to [1,2,3,4]

Code -

solution.c — C

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

int* solution(int* num, int numSize, int k, int* returnSize) {
    // Convert array to long long
    long long number = 0;
    for (int i = 0; i < numSize; i++) {
        number = number * 10 + num[i];
    }
    
    // Add k
    long long resultNum = number + k;
    
    // Convert back to array
    if (resultNum == 0) {
        int* result = (int*)malloc(sizeof(int));
        result[0] = 0;
        *returnSize = 1;
        return result;
    }
    
    // Count digits
    long long temp = resultNum;
    int count = 0;
    while (temp > 0) {
        count++;
        temp /= 10;
    }
    
    int* result = (int*)malloc(count * sizeof(int));
    *returnSize = count;
    
    // Fill array in reverse order
    for (int i = count - 1; i >= 0; i--) {
        result[i] = resultNum % 10;
        resultNum /= 10;
    }
    
    return result;
}

int main() {
    int num[10000];
    int numSize = 0;
    int k;
    
    // Parse array input
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    // Remove whitespace and parse array
    char* ptr = strchr(line, '[');
    if (ptr) ptr++; // Skip '['
    
    char* end = strchr(ptr, ']');
    if (end) *end = '\0'; // Null terminate before ']'
    
    // Parse numbers
    char* token = strtok(ptr, ",");
    while (token != NULL) {
        // Skip whitespace
        while (*token == ' ') token++;
        if (*token != '\0') {
            num[numSize++] = atoi(token);
        }
        token = strtok(NULL, ",");
    }
    
    scanf("%d", &k);
    
    int returnSize;
    int* result = solution(num, numSize, k, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Converting array to integer and back takes O(n) time

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for the integer variable

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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

Constraints

Visualization

Related Problems

Common Approaches

Convert to Integer and Back — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler