> [!META]- Inline Metadata
> [tags:: #career]
> [project group:: Neetcode 150]
> [difficulty:: easy]
> [status:: done]
> [link:: https://leetcode.com/problems/plus-one/]
> [up:: [[Leetcode MOC]]]
## Problem
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].
**Constraints:**
- `1 <= digits.length <= 100`
- `0 <= digits[i] <= 9`
- `digits` does not contain any leading `0`'s.
-
## Solution
### Mine
#### Python
```python
class Solution:
def plusOne(self, digits: List[int]) -> List[int]:
# This only occurs if the most significant digit needs to increment and is a 9
if not digits:
return [1]
elif digits[-1] == 9:
return self.plusOne(digits[:-1]) + [0]
else:
digits[-1] += 1
return digits
```
An imperative solution is more memory-efficient, I believe.
#### Rust
### LC's
## Things I Learned
## Scratchpad
This seems like it's worth a recursive solution, where the base case is any number that is not 9, recursive case is the number to be incremented is 9.
If not 9, increment last digit and return.
If 9, `return increment(input[:-1]) + input[-1]`