chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Hard/2026-04-03-3661-Maximum-Walls-Destroyed-by-Robots/explanation.md

@@ -0,0 +1,44 @@
+# Maximum Walls Destroyed by Robots (Hard)
+
+**Problem ID:** 3661  
+**Date:** 2026-04-03  
+**Link:** https://leetcode.com/problems/maximum-walls-destroyed-by-robots/
+
+## Approach
+
+To solve the problem of determining the maximum number of unique walls that can be destroyed by robots, we can adopt a systematic approach that involves sorting and a two-pointer technique.
+
+### Main Idea:
+The core idea is to simulate the firing of bullets from each robot in both left and right directions, while keeping track of the walls that can be destroyed. We need to ensure that we account for the distance each robot can shoot and the presence of other robots that may block the bullets.
+
+### Steps:
+1. **Data Preparation**:
+   - Combine the `robots` and `distance` arrays into a list of tuples, where each tuple contains the robot's position and its maximum firing distance.
+   - Sort this list based on robot positions to facilitate the simulation of bullet firing.
+
+2. **Simulate Bullet Firing**:
+   - For each robot, calculate the effective range of its bullet in both directions:
+     - **Left**: From `robot_position - distance` to `robot_position`.
+     - **Right**: From `robot_position` to `robot_position + distance`.
+   - Use a set to keep track of unique walls that can be destroyed.
+
+3. **Check for Walls**:
+   - For the left firing direction, iterate from the leftmost wall within the effective range up to the robot's position. If a wall is found, add it to the set of destroyed walls unless blocked by another robot.
+   - For the right firing direction, similarly check from the robot's position to the rightmost wall within the effective range.
+
+4. **Handle Blockages**:
+   - While checking for walls, if a robot is encountered within the effective range (either left or right), stop the firing simulation in that direction to prevent further wall destruction.
+
+5. **Count Unique Walls**:
+   - After processing all robots, the size of the set containing destroyed walls will give the maximum number of unique walls destroyed.
+
+### Data Structures:
+- A list of tuples for robots and their distances.
+- A set to store unique wall positions that have been destroyed.
+
+### Complexity:
+- Sorting the robots takes \(O(n \log n)\), where \(n\) is the number of robots.
+- The wall checking process involves iterating through the walls, which can be done in \(O(m)\), where \(m\) is the number of walls. 
+- Thus, the overall time complexity is \(O(n \log n + m)\), which is efficient given the constraints.
+
+This approach ensures that we efficiently track the walls that can be destroyed while considering the limitations imposed by the positions of the robots.

Hard/2026-04-03-3661-Maximum-Walls-Destroyed-by-Robots/solution.java

@@ -0,0 +1,43 @@
+import java.util.*;
+
+public class Solution {
+    public int maximumWallsDestroyed(int[] robots, int[] distance, int[] walls) {
+        Set<Integer> destroyedWalls = new HashSet<>();
+        Map<Integer, Integer> robotMap = new HashMap<>();
+        
+        for (int i = 0; i < robots.length; i++) {
+            robotMap.put(robots[i], distance[i]);
+        }
+        
+        Arrays.sort(walls);
+        Arrays.sort(robots);
+        
+        for (int robot : robots) {
+            int maxDistance = robotMap.get(robot);
+            int leftLimit = Math.max(0, robot - maxDistance);
+            int rightLimit = robot + maxDistance;
+            
+            // Destroy walls to the left
+            for (int wall : walls) {
+                if (wall < robot && wall >= leftLimit) {
+                    destroyedWalls.add(wall);
+                }
+                if (wall >= robot) {
+                    break;
+                }
+            }
+            
+            // Destroy walls to the right
+            for (int wall : walls) {
+                if (wall > robot && wall <= rightLimit) {
+                    destroyedWalls.add(wall);
+                }
+                if (wall > rightLimit) {
+                    break;
+                }
+            }
+        }
+        
+        return destroyedWalls.size();
+    }
+}

Hard/2026-04-03-3661-Maximum-Walls-Destroyed-by-Robots/solution.js

@@ -0,0 +1,30 @@
+var maximumWallsDestroyed = function(robots, distance, walls) {
+    const wallSet = new Set(walls);
+    const destroyedWalls = new Set();
+
+    const robotData = robots.map((pos, idx) => ({
+        pos,
+        leftLimit: pos - distance[idx],
+        rightLimit: pos + distance[idx]
+    }));
+
+    robotData.sort((a, b) => a.pos - b.pos);
+
+    for (const { pos, leftLimit, rightLimit } of robotData) {
+        // Check left direction
+        for (let wall = leftLimit; wall <= pos; wall++) {
+            if (wallSet.has(wall)) {
+                destroyedWalls.add(wall);
+            }
+        }
+        
+        // Check right direction
+        for (let wall = pos + 1; wall <= rightLimit; wall++) {
+            if (wallSet.has(wall)) {
+                destroyedWalls.add(wall);
+            }
+        }
+    }
+
+    return destroyedWalls.size;
+};

Hard/2026-04-03-3661-Maximum-Walls-Destroyed-by-Robots/solution.py

@@ -0,0 +1,22 @@
+class Solution:
+    def maximumRobots(self, robots: List[int], distance: List[int], walls: List[int]) -> int:
+        wall_set = set(walls)
+        max_walls_destroyed = 0
+        
+        # Create a list of robot positions with their effective ranges
+        robot_ranges = sorted((robots[i], robots[i] - distance[i], robots[i] + distance[i]) for i in range(len(robots)))
+        
+        # Set to track destroyed walls
+        destroyed_walls = set()
+        
+        for pos, left_limit, right_limit in robot_ranges:
+            # Check left direction
+            for wall in range(left_limit, pos + 1):
+                if wall in wall_set:
+                    destroyed_walls.add(wall)
+            # Check right direction
+            for wall in range(pos, right_limit + 1):
+                if wall in wall_set:
+                    destroyed_walls.add(wall)
+        
+        return len(destroyed_walls)

README.md

@@ -412,3 +412,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-03-31 — [Lexicographically Smallest Generated String](https://leetcode.com/problems/lexicographically-smallest-generated-string/) (Hard) → `Hard/2026-03-31-3474-Lexicographically-Smallest-Generated-String`
 - 2026-04-01 — [Robot Collisions](https://leetcode.com/problems/robot-collisions/) (Hard) → `Hard/2026-04-01-2751-Robot-Collisions`
 - 2026-04-02 — [Maximum Amount of Money Robot Can Earn](https://leetcode.com/problems/maximum-amount-of-money-robot-can-earn/) (Medium) → `Medium/2026-04-02-3418-Maximum-Amount-of-Money-Robot-Can-Earn`
+- 2026-04-03 — [Maximum Walls Destroyed by Robots](https://leetcode.com/problems/maximum-walls-destroyed-by-robots/) (Hard) → `Hard/2026-04-03-3661-Maximum-Walls-Destroyed-by-Robots`