Plus One - Practice Coding Problems

Plus One - Problem

Array Math Easy

Problem: You're given a large integer represented as an array of digits, where each element represents one digit of the number. The digits are ordered from most significant to least significant (left-to-right), just like how we normally write numbers.

Your task is to add 1 to this number and return the result as an array of digits.

Key Points:

The number has no leading zeros (except for the number 0 itself)
You need to handle carry-over when digits become 10
The most challenging case is when all digits are 9 (e.g., 999 + 1 = 1000)

Example: [1,2,3] represents 123, and adding 1 gives us 124, so return [1,2,4].

Input & Output

example_1.py — Simple Case

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

› Output: [1,2,4]

💡 Note: The number 123 + 1 = 124. No carry needed since last digit is less than 9.

example_2.py — Carry Required

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

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

💡 Note: The number 4321 + 1 = 4322. Simple increment of last digit.

example_3.py — All Nines Edge Case

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

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

💡 Note: The number 999 + 1 = 1000. Carry propagates through all digits, requiring an extra digit at the front.

Visualization

Tap to expand

Understanding the Visualization

Start at Rightmost

Begin with the least significant digit (rightmost), just like manual addition

Add One

Add 1 to this digit. If result < 10, we're done!

Handle Carry

If result = 10, set digit to 0 and carry 1 to the next position left

Propagate Left

Continue carrying left until no more carry needed

Extra Digit

If carry remains after all digits, prepend 1 (like 999 → 1000)

Key Takeaway

🎯 Key Insight: The right-to-left approach with carry propagation is optimal because most additions only affect the last digit, and when carries are needed, we handle them efficiently in a single pass.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all digits, where n is the number of digits

✓ Linear Growth

Space Complexity

O(1) or O(n)

O(1) if we modify input array, O(n) if we create new array for result

⚡ Linearithmic Space

Constraints

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

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 Apple 28

The optimal solution uses a right-to-left approach with carry propagation. Start from the last digit, add 1, and handle carries by setting digits to 0 and moving left. The key insight is that most cases only require incrementing the last digit, and the edge case of all 9s requires prepending a 1.

Common Approaches

Approach	Time	Space	Notes
✓ Right-to-Left with Carry (Optimal)	O(n)	O(1) or O(n)	Process digits from right to left, handling carry propagation efficiently

Right-to-Left with Carry (Optimal) — Algorithm Steps

Start from the rightmost digit and add 1
If the digit becomes 10, set it to 0 and carry 1 to the next position
Continue moving left, adding any carry to each digit
If we still have carry after processing all digits, prepend 1 to the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Add 1 to Last Digit

Start from rightmost digit and add 1

Check for Carry

If digit ≥ 10, set to 0 and carry 1 to next position

Propagate Left

Continue until no carry or reach the beginning

Code -

solution.c — C

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

int* plusOne(int* digits, int digitsSize, int* returnSize) {
    // Work from right to left
    for (int i = digitsSize - 1; i >= 0; i--) {
        // Add 1 to current digit
        digits[i]++;
        
        // If no carry needed, we're done
        if (digits[i] < 10) {
            *returnSize = digitsSize;
            int* result = (int*)malloc(digitsSize * sizeof(int));
            memcpy(result, digits, digitsSize * sizeof(int));
            return result;
        }
        
        // Handle carry: set current digit to 0
        digits[i] = 0;
    }
    
    // If we reach here, all digits were 9
    *returnSize = digitsSize + 1;
    int* result = (int*)malloc((digitsSize + 1) * sizeof(int));
    result[0] = 1;
    for (int i = 0; i < digitsSize; i++) {
        result[i + 1] = 0;
    }
    
    return result;
}

int main() {
    int digits[] = {1, 2, 3};
    int returnSize;
    int* result = plusOne(digits, 3, &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 all digits, where n is the number of digits

✓ Linear Growth

Space Complexity

O(1) or O(n)

O(1) if we modify input array, O(n) if we create new array for result

⚡ Linearithmic Space

Constraints

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

89.0K Views

High Frequency

~15 min Avg. Time

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

Right-to-Left with Carry (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler