0066 - Plus One

大意

有一個整數陣列，求裡面數值 +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].

或是

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].

總之需要考慮到進位的狀況。

個人想法

說真的沒很難，但會卡在陣列操作上：

• 把個位數拿出來 +1 看看，如果小於 10 那就放心 +1 後返回原本的陣列
• 如果有進位問題，那就要考量：
  • 多位數問題
  • 比目前的陣列位數還要多一位的狀況 -> 開新陣列，把內容通通丟進去

因為給的是原生型態，轉成 ArrayList 會怪怪的，那乾脆就用 new int[size + 1] 的方式開新陣列，然後把原本的數字通通倒過去最快：

class Solution {
    public int[] plusOne(int[] digits) {
        int lastIndex = digits.length - 1;
        int lastNum = digits[lastIndex];

        lastNum += 1;

        if(lastNum < 10){
            digits[lastIndex] = lastNum;
            return digits;
        } else {
            digits[lastIndex] = 0;
            int carry = 1;
            
            for(int i = lastIndex - 1; i >= 0; i--){
                lastNum = digits[i] + carry;

                if(lastNum < 10){
                    digits[i] = lastNum;
                    carry = 0;
                    break;
                } else {
                    digits[i] = 0;
                }
            }

            if(carry > 0){
                int[] newArr = new int[digits.length + 1];
                newArr[0] = carry;

                for(int i = 1; i < newArr.length; i++){
                    newArr[i] = digits[i - 1];
                }

                return newArr;
            } else {
                return digits;
            }
        }
    }
}