chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Hard/2026-04-01-2751-Robot-Collisions/explanation.md

@@ -0,0 +1,38 @@
+# Robot Collisions (Hard)
+
+**Problem ID:** 2751  
+**Date:** 2026-04-01  
+**Link:** https://leetcode.com/problems/robot-collisions/
+
+## Approach
+
+To solve the "Robot Collisions" problem, we can utilize a stack-based approach to efficiently manage the interactions between robots as they move along a line.
+
+### Main Idea
+The key insight is to recognize that collisions only occur between robots moving towards each other: specifically, a robot moving right ('R') can collide with a robot moving left ('L'). Therefore, we can process the robots in the order of their positions, maintaining a stack to keep track of the surviving robots as we simulate their movements and collisions.
+
+### Approach
+1. **Sort Robots by Position**: First, we need to pair each robot's position, health, and direction, and then sort these pairs based on their positions. This allows us to process robots in the order they appear on the line.
+
+2. **Use a Stack for Collision Management**: We will use a stack to keep track of the robots that are still active:
+   - If a robot is moving to the right ('R'), we simply push it onto the stack.
+   - If a robot is moving to the left ('L'):
+     - We check the top of the stack (the last robot that moved to the right):
+       - If the stack is empty, the left-moving robot survives.
+       - If the top robot is moving right, a collision occurs. We compare their healths:
+         - If the left-moving robot has higher health, it survives, and the right-moving robot's health decreases by 1.
+         - If the right-moving robot has higher health, it survives, and the left-moving robot is discarded.
+         - If both have equal health, both are discarded.
+     - Continue this process until no more collisions can occur or the stack is empty.
+
+3. **Final Result Extraction**: After processing all robots, the stack will contain the surviving robots in the order they were originally input. We can extract their health values and return them as the result.
+
+### Data Structures
+- **Stack**: To manage the active robots and handle collisions efficiently.
+- **Array/List**: To store the initial robot attributes (positions, healths, directions) and to generate the final output.
+
+### Complexity
+- **Time Complexity**: O(n log n) due to the initial sorting of the robots by position. The subsequent processing of the robots using the stack is O(n) in the worst case, leading to an overall complexity of O(n log n).
+- **Space Complexity**: O(n) for storing the stack and the sorted list of robots.
+
+This approach efficiently simulates the robot movements and resolves collisions while maintaining the order of surviving robots, ensuring that we meet the problem's requirements within the given constraints.

Hard/2026-04-01-2751-Robot-Collisions/solution.java

@@ -0,0 +1,51 @@
+import java.util.*;
+
+class Solution {
+    public int[] robotCollisions(int[] positions, int[] healths, String directions) {
+        int n = positions.length;
+        List<int[]> robots = new ArrayList<>();
+        
+        for (int i = 0; i < n; i++) {
+            robots.add(new int[]{positions[i], healths[i], directions.charAt(i)});
+        }
+        
+        // Sort robots based on their positions
+        robots.sort(Comparator.comparingInt(a -> a[0]));
+        
+        Stack<int[]> stack = new Stack<>();
+        
+        for (int[] robot : robots) {
+            int pos = robot[0];
+            int health = robot[1];
+            char dir = robot[2];
+            
+            if (dir == 'R') {
+                stack.push(new int[]{pos, health});
+            } else {
+                while (!stack.isEmpty() && stack.peek()[1] > 0) {
+                    int[] lastRobot = stack.peek();
+                    if (lastRobot[1] > health) {
+                        health--;
+                    } else if (lastRobot[1] < health) {
+                        stack.pop();
+                        health--;
+                    } else {
+                        stack.pop();
+                        health--;
+                        break;
+                    }
+                }
+                if (health > 0) {
+                    stack.push(new int[]{pos, health});
+                }
+            }
+        }
+        
+        int[] result = new int[stack.size()];
+        for (int i = stack.size() - 1; i >= 0; i--) {
+            result[i] = stack.pop()[1];
+        }
+        
+        return result;
+    }
+}

Hard/2026-04-01-2751-Robot-Collisions/solution.js

@@ -0,0 +1,22 @@
+var surviveRobots = function(positions, healths, directions) {
+    const robots = positions.map((pos, i) => ({ pos, health: healths[i], dir: directions[i] }));
+    robots.sort((a, b) => a.pos - b.pos);
+    
+    const stack = [];
+    
+    for (const robot of robots) {
+        while (stack.length && robot.dir === 'L' && stack[stack.length - 1].dir === 'R') {
+            const top = stack.pop();
+            if (top.health > robot.health) {
+                robot.health--;
+            } else if (top.health < robot.health) {
+                continue;
+            }
+        }
+        if (robot.health > 0) {
+            stack.push(robot);
+        }
+    }
+    
+    return stack.map(robot => robot.health);
+};

Hard/2026-04-01-2751-Robot-Collisions/solution.py

@@ -0,0 +1,24 @@
+class Solution:
+    def surviveRobots(self, positions: List[int], healths: List[int], directions: str) -> List[int]:
+        robots = sorted(zip(positions, healths, directions))
+        stack = []
+        
+        for pos, health, direction in robots:
+            if direction == 'R':
+                stack.append([health])
+            else:
+                while stack and stack[-1][0] > 0:
+                    if stack[-1][0] < health:
+                        health -= 1
+                        stack.pop()
+                    elif stack[-1][0] == health:
+                        health = 0
+                        stack.pop()
+                        break
+                    else:
+                        health = 0
+                        break
+                if health > 0:
+                    stack.append([health])
+        
+        return [h[0] for h in stack if h[0] > 0]

README.md

@@ -410,3 +410,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-03-29 — [Check if Strings Can be Made Equal With Operations I](https://leetcode.com/problems/check-if-strings-can-be-made-equal-with-operations-i/) (Easy) → `Easy/2026-03-29-2839-Check-if-Strings-Can-be-Made-Equal-With-Operations-I`
 - 2026-03-30 — [Check if Strings Can be Made Equal With Operations II](https://leetcode.com/problems/check-if-strings-can-be-made-equal-with-operations-ii/) (Medium) → `Medium/2026-03-30-2840-Check-if-Strings-Can-be-Made-Equal-With-Operations-II`
 - 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`