Count Collisions on a Road - Practice Coding Problems

Count Collisions on a Road - Problem

Count Collisions on a Road

Imagine a busy highway with n cars positioned at unique points along an infinitely long road. Each car has one of three behaviors:

'L' - Moving left at constant speed
'R' - Moving right at constant speed
'S' - Stationary (parked)

When cars collide, they create traffic chaos! The collision rules are:

Moving car vs Moving car: +2 collisions (both cars involved)
Moving car vs Stationary car: +1 collision (only moving car counts)

After any collision, all involved cars become stationary and remain at the collision point forever.

Goal: Calculate the total number of collisions that will occur on this chaotic road!

Input & Output

example_1.py — Basic Collision

$ Input: directions = "RLRSLL"

› Output: 5

💡 Note: Cars at positions 0(R) and 1(L) collide head-on (+2). Car at 0 becomes S. Car at 2(R) hits the now-stationary car at 1 (+1). Car at 4(L) hits stationary car at 3(S) (+1). Car at 5(L) hits the now-stationary car at 4 (+1). Total: 2+1+1+1=5

example_2.py — No Collisions

$ Input: directions = "LLRR"

› Output: 0

💡 Note: Left-moving cars (LL) move away from right-moving cars (RR). No cars are moving toward each other, so no collisions occur.

example_3.py — Complex Scenario

$ Input: directions = "SSRSSRLLRSLS"

› Output: 20

💡 Note: Multiple collision zones form barriers. Cars between positions 2 and 11 are trapped in collision zones. Each moving car (R or L) in this zone contributes 1 collision: R(3)+R(5)+L(6)+L(7)+R(8)+S(9)+L(10) = 6 moving cars = 6 collisions. Wait, let me recalculate properly using the optimal approach...

Constraints

1 ≤ directions.length ≤ 10⁵
directions[i] is either 'L', 'R', or 'S'
Each car has a unique position on the road
All moving cars travel at the same constant speed

Visualization

Tap to expand

Understanding the Visualization

Identify Escape Routes

Cars at the start moving left can escape. Cars at the end moving right can escape.

Find Collision Zone

The area between the first barrier (left) and last barrier (right) traps cars.

Count Trapped Cars

Every moving car in the collision zone will crash and contribute 1 collision.

Calculate Total

Sum up all the individual collisions in the trapped zone.

Key Takeaway

🎯 Key Insight: Cars only collide when trapped between barriers. By finding the collision zone boundaries, we can count all collisions in O(n) time without simulating actual movement!

Asked in

G Google 45 a Amazon 38 f Meta 22 ⊞ Microsoft 18

The optimal solution uses the key insight that cars only get involved in collisions when trapped between 'barriers'. By identifying the collision zone (between the leftmost barrier and rightmost barrier), we can count all collisions in O(n) time with a single pass. Every moving car ('R' or 'L') in this zone contributes exactly 1 collision.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation (Brute Force)	O(n²)	O(1)	Simulate the actual movement of cars step by step until no more collisions occur
Single Pass Analysis (Optimal)	O(n)	O(1)	Count collisions in one pass by identifying collision zones and barriers

Simulation (Brute Force) — Algorithm Steps

Create a mutable copy of the directions string
Repeat until no changes occur in one full pass:
Scan left to right for 'R' followed by 'L' or 'S'
Scan right to left for 'L' followed by 'R' or 'S'
Update collision counts and mark involved cars as 'S'
Return total collision count

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Cars are positioned with their initial directions: R, L, S

First Pass

Scan for adjacent collisions (R-L, R-S, L-R, L-S)

Update State

Mark collided cars as 'S' and increment collision counter

Repeat

Continue until no more collisions occur in a full pass

Code -

solution.c — C

int countCollisions(char* directions) {
    int len = strlen(directions);
    char* dirs = (char*)malloc((len + 1) * sizeof(char));
    strcpy(dirs, directions);
    
    int collisions = 0;
    int changed = 1;
    
    while (changed) {
        changed = 0;
        // Check for collisions from left to right
        for (int i = 0; i < len - 1; i++) {
            if (dirs[i] == 'R' && (dirs[i + 1] == 'L' || dirs[i + 1] == 'S')) {
                if (dirs[i + 1] == 'L') {
                    collisions += 2;
                } else {
                    collisions += 1;
                }
                dirs[i] = dirs[i + 1] = 'S';
                changed = 1;
            }
        }
        
        // Check for collisions from right to left
        for (int i = len - 1; i > 0; i--) {
            if (dirs[i] == 'L' && (dirs[i - 1] == 'R' || dirs[i - 1] == 'S')) {
                if (dirs[i - 1] == 'R') {
                    collisions += 2;
                } else {
                    collisions += 1;
                }
                dirs[i] = dirs[i - 1] = 'S';
                changed = 1;
            }
        }
    }
    
    free(dirs);
    return collisions;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we might need O(n) passes, each taking O(n) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space besides input modification

✓ Linear Space

73.2K Views

Medium Frequency

~18 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Simulation (Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler