solve problem

leet-code/66-plus-one/README.md

@@ -0,0 +1,48 @@
+# 66-plus-one
+
+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.

leet-code/66-plus-one/index.js

@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} digits
+ * @return {number[]}
+ */
+var plusOne = function(digits) {
+    let newDigits = []
+    // Initialize carry to represent the '+1' operation
+    let carry = 1;
+    // iterate from least significant digit to most
+    for(var i = digits.length-1; i >= 0; i--) {
+        // add the current digit and the carry
+        const sum = digits[i] + carry
+        // extract the current digit
+        const newDigit = sum % 10
+        // update carry for next iteration
+        carry = Math.floor(sum / 10)
+        // record the next digit
+        newDigits.push(newDigit)
+    }
+    // If carray remains, add as most significant digit
+    if (carry > 0) newDigits.push(carry)
+    // reverse to preserve most significant to least significant order
+    return newDigits.reverse()
+};