chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Easy/2026-01-01-66-Plus-One/explanation.md

@@ -0,0 +1,33 @@
+# Plus One (Easy)
+
+**Problem ID:** 66  
+**Date:** 2026-01-01  
+**Link:** https://leetcode.com/problems/plus-one/
+
+## Approach
+
+To solve the "Plus One" problem, we need to increment a large integer represented as an array of its digits. The main idea is to simulate the process of addition, starting from the least significant digit (the rightmost element of the array) and moving towards the most significant digit (the leftmost element).
+
+### Approach:
+
+1. **Initialization**: Start from the last digit of the array. This is where the increment will first take effect.
+
+2. **Increment and Carry**: 
+   - Add one to the last digit.
+   - If this results in a value less than 10, simply update the digit and return the array, as no further carry is needed.
+   - If the result is 10, set the current digit to 0 (because we have a carry) and move to the next digit to the left.
+
+3. **Handling Carry**: Continue this process for each digit:
+   - If a digit becomes 0 after adding the carry, repeat the carry operation for the next digit.
+   - If you reach the most significant digit and it also results in a carry (e.g., from 9 to 10), you will need to insert a new digit at the beginning of the array (i.e., prepend 1).
+
+4. **Return Result**: Once all digits are processed, return the modified array.
+
+### Data Structures:
+- The solution primarily uses an array to represent the digits of the number. No additional complex data structures are needed.
+
+### Complexity:
+- **Time Complexity**: O(n), where n is the number of digits in the array. In the worst case, we may need to traverse the entire array if there are multiple carries.
+- **Space Complexity**: O(1) if we ignore the output array, as we are modifying the input array in place. If a new digit is added, it can be considered O(n) in terms of the output size.
+
+This approach efficiently handles the addition while respecting the constraints of the problem, ensuring that the solution is both straightforward and optimal.

Easy/2026-01-01-66-Plus-One/solution.java

@@ -0,0 +1,15 @@
+class Solution {
+    public int[] plusOne(int[] digits) {
+        int n = digits.length;
+        for (int i = n - 1; i >= 0; i--) {
+            if (digits[i] < 9) {
+                digits[i]++;
+                return digits;
+            }
+            digits[i] = 0;
+        }
+        int[] result = new int[n + 1];
+        result[0] = 1;
+        return result;
+    }
+}

Easy/2026-01-01-66-Plus-One/solution.js

@@ -0,0 +1,11 @@
+var plusOne = function(digits) {
+    for (let i = digits.length - 1; i >= 0; i--) {
+        if (digits[i] < 9) {
+            digits[i]++;
+            return digits;
+        }
+        digits[i] = 0;
+    }
+    digits.unshift(1);
+    return digits;
+};

Easy/2026-01-01-66-Plus-One/solution.py

@@ -0,0 +1,9 @@
+class Solution:
+    def plusOne(self, digits: List[int]) -> List[int]:
+        n = len(digits)
+        for i in range(n - 1, -1, -1):
+            if digits[i] < 9:
+                digits[i] += 1
+                return digits
+            digits[i] = 0
+        return [1] + digits

README.md

@@ -322,3 +322,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-12-29 — [Pyramid Transition Matrix](https://leetcode.com/problems/pyramid-transition-matrix/) (Medium) → `Medium/2025-12-29-756-Pyramid-Transition-Matrix`
 - 2025-12-30 — [Magic Squares In Grid](https://leetcode.com/problems/magic-squares-in-grid/) (Medium) → `Medium/2025-12-30-840-Magic-Squares-In-Grid`
 - 2025-12-31 — [Last Day Where You Can Still Cross](https://leetcode.com/problems/last-day-where-you-can-still-cross/) (Hard) → `Hard/2025-12-31-1970-Last-Day-Where-You-Can-Still-Cross`
+- 2026-01-01 — [Plus One](https://leetcode.com/problems/plus-one/) (Easy) → `Easy/2026-01-01-66-Plus-One`