chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Easy/2025-11-18-717-1-bit-and-2-bit-Characters/explanation.md

@@ -0,0 +1,31 @@
+# 1-bit and 2-bit Characters (Easy)
+
+**Problem ID:** 717  
+**Date:** 2025-11-18  
+**Link:** https://leetcode.com/problems/1-bit-and-2-bit-characters/
+
+## Approach
+
+To solve the problem of determining whether the last character in a binary array can be a one-bit character, we can use a straightforward approach by iterating through the array from the end towards the beginning. The key points of the solution are as follows:
+
+### Main Idea:
+1. **Understanding Character Representation**: We know that:
+   - A one-bit character is represented by `0`.
+   - A two-bit character is represented by either `10` or `11`.
+   - The array always ends with `0`, which means the last character is guaranteed to be a one-bit character if it is not preceded by a valid two-bit character.
+
+2. **Iterative Backtracking**: Starting from the second last element of the array (since the last element is always `0`):
+   - If we encounter a `1`, it indicates the start of a two-bit character. We then skip the next bit (i.e., move back two positions).
+   - If we encounter a `0`, it indicates the end of a one-bit character, and we move back one position.
+   - Continue this process until we either reach the beginning of the array or determine the nature of the last character.
+
+3. **Decision Point**: If we finish the iteration and the pointer is at a position that allows for a one-bit character (i.e., we are at the start of the array or have only a `0` left), we can conclude that the last character must be a one-bit character.
+
+### Data Structures:
+- We primarily use a simple integer variable to track our position in the array, and no additional data structures are required.
+
+### Complexity:
+- **Time Complexity**: O(n), where n is the length of the input array. In the worst case, we might need to traverse the entire array once.
+- **Space Complexity**: O(1), as we only use a constant amount of extra space for our pointer.
+
+This approach efficiently determines whether the last character is a one-bit character by leveraging the properties of the binary representation and iterating through the array in a linear fashion.

Easy/2025-11-18-717-1-bit-and-2-bit-Characters/solution.java

@@ -0,0 +1,16 @@
+class Solution {
+    public boolean isOneBitCharacter(int[] bits) {
+        int n = bits.length;
+        int i = 0;
+        
+        while (i < n - 1) {
+            if (bits[i] == 1) {
+                i += 2; // Skip the next bit as it's part of a two-bit character
+            } else {
+                i++; // Move to the next bit
+            }
+        }
+        
+        return i == n - 1; // Check if we ended on a one-bit character
+    }
+}

Easy/2025-11-18-717-1-bit-and-2-bit-Characters/solution.js

@@ -0,0 +1,7 @@
+var isOneBitCharacter = function(bits) {
+    let i = 0;
+    while (i < bits.length - 1) {
+        i += bits[i] === 1 ? 2 : 1;
+    }
+    return i === bits.length - 1;
+};

Easy/2025-11-18-717-1-bit-and-2-bit-Characters/solution.py

@@ -0,0 +1,12 @@
+class Solution:
+    def isOneBitCharacter(self, bits: List[int]) -> bool:
+        n = len(bits)
+        i = 0
+        
+        while i < n - 1:
+            if bits[i] == 1:
+                i += 2
+            else:
+                i += 1
+        
+        return i == n - 1

README.md

@@ -282,3 +282,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-11-15 — [Count the Number of Substrings With Dominant Ones](https://leetcode.com/problems/count-the-number-of-substrings-with-dominant-ones/) (Medium) → `Medium/2025-11-15-3234-Count-the-Number-of-Substrings-With-Dominant-Ones`
 - 2025-11-16 — [Number of Substrings With Only 1s](https://leetcode.com/problems/number-of-substrings-with-only-1s/) (Medium) → `Medium/2025-11-16-1513-Number-of-Substrings-With-Only-1s`
 - 2025-11-17 — [Check If All 1's Are at Least Length K Places Away](https://leetcode.com/problems/check-if-all-1s-are-at-least-length-k-places-away/) (Easy) → `Easy/2025-11-17-1437-Check-If-All-1-s-Are-at-Least-Length-K-Places-Away`
+- 2025-11-18 — [1-bit and 2-bit Characters](https://leetcode.com/problems/1-bit-and-2-bit-characters/) (Easy) → `Easy/2025-11-18-717-1-bit-and-2-bit-Characters`