Robot Collisions - Practice Coding Problems

Robot Collisions - Problem

Imagine a futuristic battlefield where n robots are positioned on a straight line, each with their own health points, position, and movement direction. These robots start moving simultaneously at the same speed - some moving left ('L') and others moving right ('R').

When two robots collide at the same position:

The robot with lower health is destroyed
The surviving robot loses 1 health point and continues moving
If both robots have equal health, both are destroyed

Your mission: Determine which robots survive all collisions and return their final health values in the original input order.

Key Challenge: The positions array may be unsorted, but you need to simulate collisions based on actual spatial positions and movement patterns.

Input & Output

example_1.py — Basic Collision

$ Input: positions = [5,4,3,2,1], healths = [2,17,9,15,10], directions = "RRRLR"

› Output: [2,17,9,15,10] → [4,15]

💡 Note: Robots are sorted by position: [1,2,3,4,5]. Robot at pos 1 (health 10, R) moves right. Robots at pos 2,3,4 (health 15,9,17, all L) move left. Robot at pos 5 (health 2, R) moves right. The R robot at pos 1 will collide with L robots. After all collisions, only robots with health 4 and 15 survive in original order.

example_2.py — No Collisions

$ Input: positions = [3,5,2,6], healths = [10,10,15,12], directions = "RLRL"

› Output: [10,10,15,12]

💡 Note: After sorting by position: [2,3,5,6] with directions [L,R,L,R]. The L-moving robot at pos 2 and R-moving robot at pos 6 move away from others. The R at pos 3 and L at pos 5 move toward each other and will collide, but they have equal health (10 each), so both are destroyed. Wait - let me recalculate: they don't collide because they pass each other.

example_3.py — All Destroyed

$ Input: positions = [1,2,5,6], healths = [10,10,11,11], directions = "RLRL"

› Output: []

💡 Note: Robots at positions 1,2 have healths [10,10] moving [R,L] - they collide and both die (equal health). Robots at positions 5,6 have healths [11,11] moving [R,L] - they also collide and both die. No survivors remain.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ positions[i] ≤ 10⁹
1 ≤ healths[i] ≤ 10⁹
directions[i] is either 'L' or 'R'
All positions are unique
All robots move at the same speed

Visualization

Tap to expand

Understanding the Visualization

Deploy Forces

Position robots on the battlefield with their health and movement directions

Sort by Position

Arrange robots from left to right to process collisions systematically

Stack Right Army

Track right-moving robots using a stack as they advance

Process Left Army

When left-moving robots advance, they collide with the right army stack

Battle Resolution

Resolve each collision based on health, updating or removing robots

Count Survivors

Return surviving robots in their original formation order

Key Takeaway

🎯 Key Insight: The stack efficiently simulates collisions by recognizing that only right-moving robots can collide with left-moving robots, eliminating the need for step-by-step position tracking.

Asked in

G Google 45 a Amazon 38 f Meta 31 ⊞ Microsoft 25 Apple 18

The optimal solution uses a stack-based approach with O(n log n) time complexity. Key insight: only robots moving in opposite directions can collide. We sort robots by position, use a stack to track right-moving robots, and efficiently resolve collisions when encountering left-moving robots. Each robot is processed at most once, making the collision resolution O(n) after sorting.

Common Approaches

Approach	Time	Space	Notes
✓ Stack-Based Collision Simulation (Optimal)	O(n log n)	O(n)	Use stack to efficiently simulate collisions between right-moving and left-moving robots

Stack-Based Collision Simulation (Optimal) — Algorithm Steps

Combine robot data with original indices and sort by position
Initialize a stack to store right-moving robots
For each robot in position order:
If moving right, push to stack
If moving left, resolve collisions with stack robots
Continue until current robot dies or stack is empty
Collect surviving robots and sort by original index
Return health values in original input order

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by Position

Arrange robots from left to right by their positions

Stack Right-Moving

Push right-moving robots onto stack as we encounter them

Process Left-Moving

When we find a left-moving robot, resolve collisions with stack

Collision Chain

Continue collisions until current robot dies or stack is empty

Collect Survivors

Return surviving robots in original input order

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int pos, health, dir, origIdx;
} Robot;

int compare(const void* a, const void* b) {
    return ((Robot*)a)->pos - ((Robot*)b)->pos;
}

int compareOrig(const void* a, const void* b) {
    return ((Robot*)a)->origIdx - ((Robot*)b)->origIdx;
}

int* survivedRobotsHealth(int* positions, int positionsSize, int* healths, int healthsSize, char* directions, int* returnSize) {
    Robot* robots = (Robot*)malloc(positionsSize * sizeof(Robot));
    
    for (int i = 0; i < positionsSize; i++) {
        robots[i].pos = positions[i];
        robots[i].health = healths[i];
        robots[i].dir = directions[i] == 'R' ? 1 : 0;
        robots[i].origIdx = i;
    }
    
    qsort(robots, positionsSize, sizeof(Robot), compare);
    
    Robot* stack = (Robot*)malloc(positionsSize * sizeof(Robot));
    int stackSize = 0;
    
    for (int i = 0; i < positionsSize; i++) {
        if (robots[i].dir == 1) { // Moving right
            stack[stackSize++] = robots[i];
        } else { // Moving left
            int currentHealth = robots[i].health;
            int currentAlive = 1;
            
            while (stackSize > 0 && currentAlive) {
                Robot* stackRobot = &stack[stackSize - 1];
                
                if (currentHealth > stackRobot->health) {
                    currentHealth--;
                    stackSize--;
                } else if (currentHealth < stackRobot->health) {
                    stackRobot->health--;
                    currentAlive = 0;
                } else {
                    stackSize--;
                    currentAlive = 0;
                }
            }
            
            if (currentAlive) {
                robots[i].health = currentHealth;
                stack[stackSize++] = robots[i];
            }
        }
    }
    
    qsort(stack, stackSize, sizeof(Robot), compareOrig);
    
    int* result = (int*)malloc(stackSize * sizeof(int));
    for (int i = 0; i < stackSize; i++) {
        result[i] = stack[i].health;
    }
    
    *returnSize = stackSize;
    
    free(robots);
    free(stack);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting, O(n) for processing collisions since each robot is pushed/popped at most once

⚡ Linearithmic

Space Complexity

O(n)

Stack storage for right-moving robots and array for robot data

⚡ Linearithmic Space

78.6K Views

Medium-High Frequency

~25 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

Stack-Based Collision Simulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler