Plus One

Problem Statement

Given a large integer represented as an array of digits, increment it by one.

You need to solve this problem efficiently.

What to notice first

• Key insight 1 for Plus One
• Key insight 2 for solving this problem
• Key insight 3 specific to the approach

Examples

Input	Output	Explanation
Example 1	Result 1	Explanation for example 1
Example 2	Result 2	Explanation for example 2

Constraints

• Constraint 1 for Plus One
• Constraint 2
• Constraint 3

Real-World Applications

Where this pattern appears

• Database indexing and query optimization
• Buffer management in system memory
• Time-series data analysis and sliding windows
• Image pixel manipulation and batch processing

Complexity Comparison

Approach	Time	Space	Best When
Iterate	O(n)	O(1)	When applicable
Recursive	O(n)	O(1)	When applicable
Math	O(n)	O(1)	When applicable

Approach 1: Iterate

★ Recommended

This approach provides an efficient solution for plus one.

⏱ Time O(n) Single pass 💾 Space O(1) Minimal storage

Solution Code

Python

plus_one_iterate.py

from typing import List

def plus_one_iterate(digits: List[int]) -> List[int]:
    """Increment number by one using iteration."""
    carry = 1
    for i in range(len(digits) - 1, -1, -1):
        digits[i] += carry
        if digits[i] < 10:
            return digits
        digits[i] = 0

    return [1] + digits

# Test cases
print(plus_one_iterate([1, 2, 3]))  # [1, 2, 4]
print(plus_one_iterate([9, 9, 9]))  # [1, 0, 0, 0]

C++

plus_one_iterate.cpp

#include <vector>
using namespace std;

vector<int> plusOneIterate(vector<int>& digits) {
    int carry = 1;
    for (int i = digits.size() - 1; i >= 0; i--) {
        digits[i] += carry;
        if (digits[i] < 10) {
            return digits;
        }
        digits[i] = 0;
    }

    digits.insert(digits.begin(), 1);
    return digits;
}

int main() {
    vector<int> digits = {1, 2, 3};
    vector<int> result = plusOneIterate(digits);
    return 0;
}

Java

plus_one_iterate.java

import java.util.Arrays;

public class PlusOneIterate {
    public static int[] plusOneIterate(int[] digits) {
        int carry = 1;
        for (int i = digits.length - 1; i >= 0; i--) {
            digits[i] += carry;
            if (digits[i] < 10) {
                return digits;
            }
            digits[i] = 0;
        }

        int[] result = new int[digits.length + 1];
        result[0] = 1;
        return result;
    }

    public static void main(String[] args) {
        int[] digits = {1, 2, 3};
        System.out.println(Arrays.toString(plusOneIterate(digits)));
    }
}

JavaScript

plus_one_iterate.js

function plusOneIterate(digits) {
    let carry = 1;
    for (let i = digits.length - 1; i >= 0; i--) {
        digits[i] += carry;
        if (digits[i] < 10) {
            return digits;
        }
        digits[i] = 0;
    }

    return [1, ...digits];
}

console.log(plusOneIterate([1, 2, 3]));  // [1, 2, 4]
console.log(plusOneIterate([9, 9, 9]));  // [1, 0, 0, 0]

Rust

plus_one_iterate.rs

fn plus_one_iterate(mut digits: Vec<i32>) -> Vec<i32> {
    let mut carry = 1;
    for i in (0..digits.len()).rev() {
        digits[i] += carry;
        if digits[i] < 10 {
            return digits;
        }
        digits[i] = 0;
    }

    let mut result = vec![1];
    result.extend(digits);
    result
}

fn main() {
    println!("{:?}", plus_one_iterate(vec![1, 2, 3]));  // [1, 2, 4]
    println!("{:?}", plus_one_iterate(vec![9, 9, 9]));  // [1, 0, 0, 0]
}

Go

plus_one_iterate.go

package main

import "fmt"

func plusOneIterate(digits []int) []int {
  carry := 1
  for i := len(digits) - 1; i >= 0; i-- {
    digits[i] += carry
    if digits[i] < 10 {
      return digits
    }
    digits[i] = 0
  }

  result := make([]int, len(digits)+1)
  result[0] = 1
  copy(result[1:], digits)
  return result
}

func main() {
  fmt.Println(plusOneIterate([]int{1, 2, 3}))  // [1 2 4]
  fmt.Println(plusOneIterate([]int{9, 9, 9}))  // [1 0 0 0]
}

Approach 2: Recursive

🎯 Interview Favourite

This approach provides an efficient solution for plus one.

⏱ Time O(n) Single pass 💾 Space O(1) Minimal storage

Solution Code

Python

plus_one_recursive.py

# Python Solution
# Problem: plus-one
# Approach: recursive

# Implementation placeholder for plus_one_recursive
# This file is auto-generated and should contain the solution code.

def plus_one_recursive():
    pass

if __name__ == "__main__":
    pass

C++

plus_one_recursive.cpp

# C++ Solution
# Problem: plus-one
# Approach: recursive

# Implementation placeholder for plus_one_recursive
# This file is auto-generated and should contain the solution code.

def plus_one_recursive():
    pass

if __name__ == "__main__":
    pass

Java

plus_one_recursive.java

# Java Solution
# Problem: plus-one
# Approach: recursive

# Implementation placeholder for plus_one_recursive
# This file is auto-generated and should contain the solution code.

def plus_one_recursive():
    pass

if __name__ == "__main__":
    pass

JavaScript

plus_one_recursive.js

# JavaScript Solution
# Problem: plus-one
# Approach: recursive

# Implementation placeholder for plus_one_recursive
# This file is auto-generated and should contain the solution code.

def plus_one_recursive():
    pass

if __name__ == "__main__":
    pass

Rust

plus_one_recursive.rs

# Rust Solution
# Problem: plus-one
# Approach: recursive

# Implementation placeholder for plus_one_recursive
# This file is auto-generated and should contain the solution code.

def plus_one_recursive():
    pass

if __name__ == "__main__":
    pass

Go

plus_one_recursive.go

# Golang Solution
# Problem: plus-one
# Approach: recursive

# Implementation placeholder for plus_one_recursive
# This file is auto-generated and should contain the solution code.

def plus_one_recursive():
    pass

if __name__ == "__main__":
    pass

Approach 3: Math

✓ Simple

This approach provides an efficient solution for plus one.

⏱ Time O(n) Single pass 💾 Space O(1) Minimal storage

Solution Code

Python

plus_one_math.py

# Python Solution
# Problem: plus-one
# Approach: math

# Implementation placeholder for plus_one_math
# This file is auto-generated and should contain the solution code.

def plus_one_math():
    pass

if __name__ == "__main__":
    pass

C++

plus_one_math.cpp

# C++ Solution
# Problem: plus-one
# Approach: math

# Implementation placeholder for plus_one_math
# This file is auto-generated and should contain the solution code.

def plus_one_math():
    pass

if __name__ == "__main__":
    pass

Java

plus_one_math.java

# Java Solution
# Problem: plus-one
# Approach: math

# Implementation placeholder for plus_one_math
# This file is auto-generated and should contain the solution code.

def plus_one_math():
    pass

if __name__ == "__main__":
    pass

JavaScript

plus_one_math.js

# JavaScript Solution
# Problem: plus-one
# Approach: math

# Implementation placeholder for plus_one_math
# This file is auto-generated and should contain the solution code.

def plus_one_math():
    pass

if __name__ == "__main__":
    pass

Rust

plus_one_math.rs

# Rust Solution
# Problem: plus-one
# Approach: math

# Implementation placeholder for plus_one_math
# This file is auto-generated and should contain the solution code.

def plus_one_math():
    pass

if __name__ == "__main__":
    pass

Go

plus_one_math.go

# Golang Solution
# Problem: plus-one
# Approach: math

# Implementation placeholder for plus_one_math
# This file is auto-generated and should contain the solution code.

def plus_one_math():
    pass

if __name__ == "__main__":
    pass

Related Problems

• Two Sum ↗ Easy #1
• Palindrome Number ↗ Easy #9

Interview Tips

Key trade-offs to discuss

• Time vs. space trade-offs between approaches
• Handling edge cases (empty inputs, single elements, duplicates)
• Optimization opportunities and when they matter
• Follow-up variations and constraint changes

← Previous
Next
→