chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2026-05-02-788-Rotated-Digits/explanation.md

@@ -0,0 +1,40 @@
+# Rotated Digits (Medium)
+
+**Problem ID:** 788  
+**Date:** 2026-05-02  
+**Link:** https://leetcode.com/problems/rotated-digits/
+
+## Approach
+
+To solve the "Rotated Digits" problem, we need to determine how many integers in the range [1, n] are "good" based on the rotation rules provided. A number is classified as "good" if, after rotating each of its digits by 180 degrees, it results in a valid number that is different from the original number.
+
+### Approach:
+
+1. **Understanding Digit Rotation**:
+   - We first identify which digits are valid after rotation:
+     - Valid digits: 0, 1, 8 (remain the same)
+     - Valid pairs: 2 ↔ 5, 6 ↔ 9
+     - Invalid digits: 3, 4, 7 (become invalid)
+   - A "good" number must contain at least one of the digits that change (2, 5, 6, or 9) and must not consist solely of valid digits that remain unchanged (0, 1, 8).
+
+2. **Iterate Through the Range**:
+   - We will iterate through each number from 1 to n and check its digits.
+   - For each number, we will convert it to its string representation to easily access each digit.
+
+3. **Check Each Digit**:
+   - For each digit in the number:
+     - If any digit is invalid (3, 4, 7), we can skip to the next number.
+     - If we encounter a digit that changes (2, 5, 6, or 9), we mark this number as "good".
+
+4. **Count Good Numbers**:
+   - Maintain a counter to keep track of how many "good" numbers we find during our iteration.
+
+### Data Structures:
+- We primarily use a simple integer counter to track the number of good numbers.
+- String representation of numbers allows for easy digit access and checking.
+
+### Complexity:
+- **Time Complexity**: O(n * d), where n is the input number and d is the number of digits in n. In the worst case, d is log10(n), making the complexity effectively O(n) for the upper limit of n (10,000).
+- **Space Complexity**: O(1), as we only use a few variables to store counts and check digits.
+
+By following this structured approach, we can efficiently determine the count of good integers in the specified range.

Medium/2026-05-02-788-Rotated-Digits/solution.java

@@ -0,0 +1,26 @@
+class Solution {
+    public int rotatedDigits(int n) {
+        int count = 0;
+        for (int i = 1; i <= n; i++) {
+            if (isGood(i)) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    private boolean isGood(int num) {
+        boolean good = false;
+        while (num > 0) {
+            int digit = num % 10;
+            if (digit == 3 || digit == 4 || digit == 7) {
+                return false;
+            }
+            if (digit == 2 || digit == 5 || digit == 6 || digit == 9) {
+                good = true;
+            }
+            num /= 10;
+        }
+        return good;
+    }
+}

Medium/2026-05-02-788-Rotated-Digits/solution.js

@@ -0,0 +1,28 @@
+var rotatedDigits = function(n) {
+    const goodDigits = new Set(['2', '5', '6', '9']);
+    const validDigits = new Set(['0', '1', '8', '2', '5', '6', '9']);
+    
+    let count = 0;
+
+    for (let i = 1; i <= n; i++) {
+        const strNum = i.toString();
+        let isGood = false;
+        let isValid = true;
+
+        for (const char of strNum) {
+            if (!validDigits.has(char)) {
+                isValid = false;
+                break;
+            }
+            if (goodDigits.has(char)) {
+                isGood = true;
+            }
+        }
+
+        if (isValid && isGood) {
+            count++;
+        }
+    }
+
+    return count;
+};

Medium/2026-05-02-788-Rotated-Digits/solution.py

@@ -0,0 +1,8 @@
+class Solution:
+    def rotatedDigits(self, n: int) -> int:
+        good_count = 0
+        for i in range(1, n + 1):
+            s = str(i)
+            if all(c in '0125689' for c in s) and any(c in '2569' for c in s):
+                good_count += 1
+        return good_count

README.md

@@ -441,3 +441,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-04-29 — [Maximum Score From Grid Operations](https://leetcode.com/problems/maximum-score-from-grid-operations/) (Hard) → `Hard/2026-04-29-3225-Maximum-Score-From-Grid-Operations`
 - 2026-04-30 — [Maximum Path Score in a Grid](https://leetcode.com/problems/maximum-path-score-in-a-grid/) (Medium) → `Medium/2026-04-30-3742-Maximum-Path-Score-in-a-Grid`
 - 2026-05-01 — [Rotate Function](https://leetcode.com/problems/rotate-function/) (Medium) → `Medium/2026-05-01-396-Rotate-Function`
+- 2026-05-02 — [Rotated Digits](https://leetcode.com/problems/rotated-digits/) (Medium) → `Medium/2026-05-02-788-Rotated-Digits`