chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2025-12-04-2211-Count-Collisions-on-a-Road/explanation.md

@@ -0,0 +1,33 @@
+# Count Collisions on a Road (Medium)
+
+**Problem ID:** 2211  
+**Date:** 2025-12-04  
+**Link:** https://leetcode.com/problems/count-collisions-on-a-road/
+
+## Approach
+
+To solve the problem of counting collisions on a road with cars moving in different directions, we can use a straightforward linear traversal approach. The main idea is to iterate through the string of directions and keep track of the collisions based on the rules provided.
+
+### Approach:
+
+1. **Initialization**: Start with a collision counter set to zero.
+
+2. **Iterate through the string**: Loop through each character in the `directions` string:
+   - If you encounter a 'R' (car moving right), check the next character:
+     - If it's 'L' (car moving left), a collision occurs, contributing 2 to the collision count. Both cars will stop moving after this collision.
+     - If it's 'S' (stationary car), a collision occurs, contributing 1 to the collision count.
+   - If you encounter an 'L', simply continue as it won't cause any additional collisions unless followed by 'R'.
+   - If you encounter 'S', check the previous character:
+     - If it's 'R', it has already been counted in the previous step.
+     - If it's 'L', it will also not contribute to any new collisions.
+
+3. **Handle stationary cars**: When a stationary car ('S') is encountered, it can only collide with cars moving towards it (i.e., 'R' before it or 'L' after it). Thus, ensure that collisions are counted correctly based on the previous and next characters.
+
+### Data Structures:
+- A simple integer counter to keep track of the total number of collisions is sufficient. No additional data structures are required since we are processing the string in a single pass.
+
+### Complexity:
+- **Time Complexity**: O(n), where n is the length of the `directions` string, as we make a single pass through the string.
+- **Space Complexity**: O(1), since we are using a constant amount of space for the collision counter.
+
+This approach is efficient and directly addresses the problem requirements by leveraging the properties of the string and the rules of collision counting.

Medium/2025-12-04-2211-Count-Collisions-on-a-Road/solution.java

@@ -0,0 +1,38 @@
+class Solution {
+    public int countCollisions(String directions) {
+        int collisions = 0;
+        int n = directions.length();
+        
+        // Convert the string to a character array for easier manipulation
+        char[] cars = directions.toCharArray();
+        
+        // Process the cars from left to right
+        for (int i = 0; i < n; i++) {
+            if (cars[i] == 'R') {
+                // Check for collisions with 'L' or 'S'
+                while (i + 1 < n && cars[i + 1] == 'L') {
+                    collisions += 2; // R and L collide
+                    i++;
+                }
+                if (i + 1 < n && cars[i + 1] == 'S') {
+                    collisions += 1; // R and S collide
+                }
+            } else if (cars[i] == 'L') {
+                // Check for collisions with 'S'
+                if (i - 1 >= 0 && cars[i - 1] == 'S') {
+                    collisions += 1; // L and S collide
+                }
+            } else if (cars[i] == 'S') {
+                // Check for collisions with 'R' or 'L'
+                if (i - 1 >= 0 && cars[i - 1] == 'R') {
+                    collisions += 1; // R and S collide
+                }
+                if (i + 1 < n && cars[i + 1] == 'L') {
+                    collisions += 1; // S and L collide
+                }
+            }
+        }
+        
+        return collisions;
+    }
+}

Medium/2025-12-04-2211-Count-Collisions-on-a-Road/solution.js

@@ -0,0 +1,29 @@
+var countCollisions = function(directions) {
+    let collisions = 0;
+    let n = directions.length;
+    let i = 0;
+
+    while (i < n) {
+        if (directions[i] === 'R') {
+            let j = i + 1;
+            while (j < n && directions[j] === 'S') {
+                collisions++;
+                j++;
+            }
+            if (j < n && directions[j] === 'L') {
+                collisions += 2; // R and L collide
+                i = j + 1; // Move past the collision
+            } else {
+                i = j; // Move to the next car
+            }
+        } else if (directions[i] === 'L') {
+            // No need to check further as L cars won't collide with anything to the left
+            i++;
+        } else {
+            // If it's 'S', just count it and move on
+            i++;
+        }
+    }
+
+    return collisions;
+};

Medium/2025-12-04-2211-Count-Collisions-on-a-Road/solution.py

@@ -0,0 +1,26 @@
+class Solution:
+    def countCollisions(self, directions: str) -> int:
+        collisions = 0
+        n = len(directions)
+        
+        # Process from left to right
+        for i in range(n):
+            if directions[i] == 'R':
+                if i + 1 < n and directions[i + 1] == 'L':
+                    collisions += 2
+                    directions = directions[:i] + 'S' + directions[i + 1:i + 1] + 'S' + directions[i + 2:]
+                elif i + 1 < n and directions[i + 1] == 'S':
+                    collisions += 1
+                    directions = directions[:i] + 'S' + directions[i + 1:]
+        
+        # Process from right to left
+        for i in range(n - 1, -1, -1):
+            if directions[i] == 'L':
+                if i - 1 >= 0 and directions[i - 1] == 'R':
+                    collisions += 2
+                    directions = directions[:i] + 'S' + directions[i + 1:]
+                elif i - 1 >= 0 and directions[i - 1] == 'S':
+                    collisions += 1
+                    directions = directions[:i] + 'S' + directions[i + 1:]
+
+        return collisions

README.md

@@ -294,3 +294,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-12-01 — [Maximum Running Time of N Computers](https://leetcode.com/problems/maximum-running-time-of-n-computers/) (Hard) → `Hard/2025-12-01-2141-Maximum-Running-Time-of-N-Computers`
 - 2025-12-02 — [Count Number of Trapezoids I](https://leetcode.com/problems/count-number-of-trapezoids-i/) (Medium) → `Medium/2025-12-02-3623-Count-Number-of-Trapezoids-I`
 - 2025-12-03 — [Count Number of Trapezoids II](https://leetcode.com/problems/count-number-of-trapezoids-ii/) (Hard) → `Hard/2025-12-03-3625-Count-Number-of-Trapezoids-II`
+- 2025-12-04 — [Count Collisions on a Road](https://leetcode.com/problems/count-collisions-on-a-road/) (Medium) → `Medium/2025-12-04-2211-Count-Collisions-on-a-Road`