Plus One - Practice Coding Problems

Plus One - Problem

Array Math Easy

You are given a large integer represented as an integer array digits, where each digits[i] is the ith digit of the integer. The digits are ordered from most significant to least significant in left-to-right order. The large integer does not contain any leading zeros.

Increment the large integer by one and return the resulting array of digits.

Input & Output

Example 1 — Basic Case

$ Input: digits = [1,2,3]

› Output: [1,2,4]

💡 Note: The array represents 123, and 123 + 1 = 124. So we return [1,2,4].

Example 2 — Carry Required

$ Input: digits = [4,3,2,1,9]

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

💡 Note: The array represents 43219, and 43219 + 1 = 43220. The last digit 9 becomes 0 and we carry 1.

Example 3 — All Nines

$ Input: digits = [9,9,9]

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

💡 Note: The array represents 999, and 999 + 1 = 1000. We need an extra digit at the beginning.

Constraints

1 ≤ digits.length ≤ 100
0 ≤ digits[i] ≤ 9
digits does not contain any leading zeros

Visualization

Tap to expand

Understanding the Visualization

Input

Array [1,2,3] represents number 123

Process

Add 1 to the rightmost digit: 3 + 1 = 4

Output

Result [1,2,4] represents 124

Key Takeaway

🎯 Key Insight: Only digits equal to 9 create carries - most additions are simple!

Asked in

G Google 45 a Amazon 38 M Microsoft 32 Apple 25

The key insight is to process digits from right to left, handling carries naturally. When we encounter a digit less than 9, we can simply add 1 and return. The special case is when all digits are 9 - we need to create a new array with 1 followed by zeros. Best approach is the right-to-left carry method with Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Right-to-Left with Carry	O(n)	O(1)	Process digits from right to left, handling carries properly
Convert to Number	O(n)	O(1)	Convert array to number, add 1, convert back to array
All 9s Special Case	O(n)	O(1)	Optimize for the special case when all digits are 9

Right-to-Left with Carry — Algorithm Steps

Step 1: Start from rightmost digit
Step 2: Add 1 and handle carry
Step 3: Continue left until no carry needed
Step 4: If all digits were 9, prepend 1

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Right

Begin with rightmost digit [1,2,3]

Add One

3 + 1 = 4, no carry needed

Result

Return [1,2,4]

Code -

solution.c — C

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

int* solution(int* digits, int digitsSize, int* returnSize) {
    // Start from the rightmost digit
    for (int i = digitsSize - 1; i >= 0; i--) {
        // If current digit is less than 9, just add 1 and return
        if (digits[i] < 9) {
            digits[i] += 1;
            *returnSize = digitsSize;
            int* result = (int*)malloc(digitsSize * sizeof(int));
            memcpy(result, digits, digitsSize * sizeof(int));
            return result;
        }
        
        // If current digit is 9, set it to 0 and continue
        digits[i] = 0;
    }
    
    // If we reach here, all digits were 9
    // Need to add 1 at the beginning
    *returnSize = digitsSize + 1;
    int* result = (int*)malloc((digitsSize + 1) * sizeof(int));
    result[0] = 1;
    for (int i = 1; i <= digitsSize; i++) {
        result[i] = 0;
    }
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing - assumes format [1,2,3]
    int digits[100];
    int size = 0;
    char* ptr = strchr(line, '[') + 1;
    while (*ptr != ']') {
        if (*ptr >= '0' && *ptr <= '9') {
            digits[size++] = *ptr - '0';
        }
        ptr++;
    }
    
    int returnSize;
    int* result = solution(digits, size, &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)

Single pass through the digits array in worst case

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for carry variable

✓ Linear Space

89.5K Views

High Frequency

~15 min Avg. Time

2.8K 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

Right-to-Left with Carry — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler