**source:**https://leetcode.com/problems/plus-one/**C/C++**

**Solution to LeetCode**problem

**66**.

**Plus One**.

## Problem

You are given a **large integer** represented as an integer array `digits`

, where each `digits[i]`

is the `i`

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 ^{th}`0`

’s.

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

## Examples

**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

We iterate through the array from right to left.

- If the number is
`9`

, change it to`0`

. - If the number is less than
`9`

we add`1`

and return the array. - If we iterate through the whole array, we add a
`0`

to the end, and the first numbers becomes a`1`

.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class Solution {
public:
vector<int> plusOne(vector<int>& digits) {
int i = digits.size() - 1;
while (i >= 0) {
if (digits[i] == 9)
digits[i] = 0;
else {
digits[i] += 1;
return digits;
}
i--;
}
digits.push_back(0);
digits[0] = 1;
return digits;
}
};