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.

&nbsp;
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].


&nbsp;
Constraints:


	1 &lt;= digits.length &lt;= 100
	0 &lt;= digits[i] &lt;= 9
	digits does not contain any leading 0's.


class Solution(object):
    def plusOne(self, digits):
        for i in range(len(digits)-1, -1, -1):
            if digits[i] == 9:
                digits[i] = 0
            else:
                digits[i] += 1
                return digits
        return [1] + digits
class Solution {
    public int[] plusOne(int[] digits) {

        int len = digits.length;

        //last digit not a 9, just add 1 to it
        if(digits[len - 1] != 9){
            digits[len - 1] = digits[len - 1] + 1;
            return digits;
        }

        //last digit is a 9, find the closest digit that is not a 9
        else{
            int i = len - 1;
            while(i >= 0 && digits[i] == 9){
                digits[i] = 0;
                i--;
            }
            if(i == -1){
                int[] ret = new int[len + 1];
                for(int j = 0; j < len; j++){
                    ret[j+1] = digits[j];
                }
                ret[0] = 1;
                return ret;
            }
            digits[i] = digits[i] + 1;
        }

        return digits;
    }
}
class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        int len = digits.size(), carry = 0, temp = 0;
        
        vector<int> arr;
        
        for(int i=len-1; i>=0; i--) { // traverse from back to front
            temp = digits[i] + carry;
            
            if(i == len-1) {
                temp++;
            }
            
            arr.push_back(temp % 10);
            carry = temp/10;
        }
        
        if(carry) {
            arr.push_back(carry);
        }
        
        reverse(arr.begin(), arr.end());
        return arr;
    }
};
var plusOne = function(digits) {
    for(let i=digits.length-1; i>=0; i--){
        if(digits[i] === 9){
            digits[i] = 0
        }else{
            digits[i] += 1
            return digits
        }
    }
    digits.unshift(1)
    return digits
};
Plus One