Last updated on March 7th, 2025 at 07:47 pm
Here, we see a Plus One LeetCode Solution. This Leetcode problem is solved using different approaches in many programming languages, such as C++, Java, JavaScript, Python, etc.
List of all LeetCode Solution
Topics
Array
Companies
Level of Question
Easy
Plus One LeetCode Solution
Table of Contents
1. Problem Statement
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 0‘s.
Increment the large integer by one and return the resulting array of digits.
Example 1:
Input: digits = [1,2,3]
Output: [1,2,4]
Explanation: The array represents the integer 123.
Incrementing by one gives 123 + 1 = 124.
Thus, the result should be [1,2,4].
Example 2:
Input: digits = [4,3,2,1]
Output: [4,3,2,2]
Explanation: The array represents the integer 4321.
Incrementing by one gives 4321 + 1 = 4322.
Thus, the result should be [4,3,2,2].
Example 3:
Input: digits = [9]
Output: [1,0]
Explanation: The array represents the integer 9.
Incrementing by one gives 9 + 1 = 10.
Thus, the result should be [1,0].
2. Coding Pattern Used in Solution
The coding pattern used in all the provided implementations is “Digit Manipulation”. The problem involves incrementing a number represented as an array of digits by one, handling carry propagation, and potentially resizing the array if the most significant digit overflows.
3. Code Implementation in Different Languages
3.1 Plus One C++
class Solution {
public:
vector<int> plusOne(vector<int>& digits) {
bool carry = true;
for(int i=digits.size()-1; i >= 0 && carry; i--) {
carry = (++digits[i]%=10) == 0;
}
if(carry) {
digits.insert(digits.begin(), 1);
}
return digits;
}
};
3.2 Plus One Java
class Solution {
public int[] plusOne(int[] digits) {
for (int i = digits.length - 1; i >= 0; i--) {
if (digits[i] < 9) {
digits[i]++;
return digits;
}
digits[i] = 0;
}
digits = new int[digits.length + 1];
digits[0] = 1;
return digits;
}
}
3.3 Plus One JavaScript
var plusOne = function(digits) {
const fromArray = digits.join(''); // get Digits out of Array
const toInt = BigInt(fromArray) ; //Dont use parseInt, use BigInt instead :)
const addOne = toInt + 1n; // add one!
const result = Array.from(String(addOne), Number); // return digits to array
return result
};
3.4 Plus One Python
class Solution(object):
def plusOne(self, digits):
digits[-1] += 1
for i in range(len(digits)-1, 0, -1):
if digits[i] != 10:
break
digits[i] = 0
digits[i-1] += 1
if digits[0] == 10:
digits[0] = 0
return [1] + digits
return digits
4. Time and Space Complexity
| Time Complexity | Space Complexity | |
| C++ | O(n) | O(1) |
| Java | O(n) | O(n) |
| JavaScript | O(n) | O(n) |
| Python | O(n) | O(1) |
- The C++ and Python implementations are more space-efficient (O(1) space complexity) because they modify the input array in place.
- The Java and JavaScript implementations require additional space (O(n)) due to the creation of new arrays or intermediate strings.
- All implementations have a time complexity of O(n).