chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2025-12-11-3531-Count-Covered-Buildings/explanation.md

@@ -0,0 +1,37 @@
+# Count Covered Buildings (Medium)
+
+**Problem ID:** 3531  
+**Date:** 2025-12-11  
+**Link:** https://leetcode.com/problems/count-covered-buildings/
+
+## Approach
+
+To solve the "Count Covered Buildings" problem, we need to determine how many buildings in a given 2D grid are "covered," meaning each covered building has at least one other building in each of the four cardinal directions (up, down, left, right).
+
+### Approach:
+
+1. **Data Structures**:
+   - Use a set to store the coordinates of the buildings for O(1) average-time complexity when checking if a building exists at a specific coordinate.
+   - Additionally, maintain four sets (or dictionaries) to track the presence of buildings in each direction for every building:
+     - `above`: stores buildings that can cover others from above.
+     - `below`: stores buildings that can cover others from below.
+     - `left`: stores buildings that can cover others from the left.
+     - `right`: stores buildings that can cover others from the right.
+
+2. **Processing the Buildings**:
+   - Iterate through each building's coordinates. For each building located at `(x, y)`, check:
+     - If there is a building at `(x-1, y)` (left).
+     - If there is a building at `(x+1, y)` (right).
+     - If there is a building at `(x, y-1)` (above).
+     - If there is a building at `(x, y+1)` (below).
+   - For each building, update the respective direction sets accordingly.
+
+3. **Counting Covered Buildings**:
+   - After processing all buildings, iterate through the original list of buildings again.
+   - For each building, check if it has at least one building in all four direction sets. If it does, increment the count of covered buildings.
+
+### Complexity:
+- **Time Complexity**: O(m), where m is the number of buildings, since we are iterating through the list of buildings a couple of times.
+- **Space Complexity**: O(m) as we store the coordinates in a set and potentially use additional sets for direction tracking.
+
+This approach efficiently checks for coverage by leveraging set operations, ensuring that the solution is optimal even for the upper limits of the constraints.

Medium/2025-12-11-3531-Count-Covered-Buildings/solution.java

@@ -0,0 +1,26 @@
+import java.util.HashSet;
+import java.util.Set;
+
+class Solution {
+    public int countCoveredBuildings(int n, int[][] buildings) {
+        Set<String> buildingSet = new HashSet<>();
+        for (int[] building : buildings) {
+            buildingSet.add(building[0] + "," + building[1]);
+        }
+
+        int coveredCount = 0;
+
+        for (int[] building : buildings) {
+            int x = building[0];
+            int y = building[1];
+            if (buildingSet.contains(x - 1 + "," + y) && 
+                buildingSet.contains(x + 1 + "," + y) && 
+                buildingSet.contains(x + "," + (y - 1)) && 
+                buildingSet.contains(x + "," + (y + 1))) {
+                coveredCount++;
+            }
+        }
+
+        return coveredCount;
+    }
+}

Medium/2025-12-11-3531-Count-Covered-Buildings/solution.js

@@ -0,0 +1,17 @@
+var countCoveredBuildings = function(n, buildings) {
+    const buildingSet = new Set(buildings.map(b => b.join(',')));
+    let coveredCount = 0;
+
+    for (const [x, y] of buildings) {
+        if (
+            buildingSet.has(`${x - 1},${y}`) &&
+            buildingSet.has(`${x + 1},${y}`) &&
+            buildingSet.has(`${x},${y - 1}`) &&
+            buildingSet.has(`${x},${y + 1}`)
+        ) {
+            coveredCount++;
+        }
+    }
+
+    return coveredCount;
+};

Medium/2025-12-11-3531-Count-Covered-Buildings/solution.py

@@ -0,0 +1,10 @@
+class Solution:
+    def countCoveredBuildings(self, n: int, buildings: List[List[int]]) -> int:
+        covered = set()
+        building_set = set(map(tuple, buildings))
+        
+        for x, y in buildings:
+            if (x - 1, y) in building_set and (x + 1, y) in building_set and (x, y - 1) in building_set and (x, y + 1) in building_set:
+                covered.add((x, y))
+        
+        return len(covered)

README.md

@@ -301,3 +301,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-12-08 — [Count Square Sum Triples](https://leetcode.com/problems/count-square-sum-triples/) (Easy) → `Easy/2025-12-08-1925-Count-Square-Sum-Triples`
 - 2025-12-09 — [Count Special Triplets](https://leetcode.com/problems/count-special-triplets/) (Medium) → `Medium/2025-12-09-3583-Count-Special-Triplets`
 - 2025-12-10 — [Count the Number of Computer Unlocking Permutations](https://leetcode.com/problems/count-the-number-of-computer-unlocking-permutations/) (Medium) → `Medium/2025-12-10-3577-Count-the-Number-of-Computer-Unlocking-Permutations`
+- 2025-12-11 — [Count Covered Buildings](https://leetcode.com/problems/count-covered-buildings/) (Medium) → `Medium/2025-12-11-3531-Count-Covered-Buildings`