Robot Collisions

Robot Collisions - Problem

There are n robots positioned on a line, each with a unique position, health value, and movement direction.

You are given three inputs:

positions: array of robot positions (0-indexed, unsorted)
healths: array of robot health values
directions: string where each character is 'L' (left) or 'R' (right)

All robots move simultaneously at the same speed. When two robots collide:

The robot with lower health is removed
The surviving robot's health decreases by 1
If both have equal health, both are removed

Return the final health values of surviving robots in their original input order. If no robots survive, return an empty array.

Input & Output

Example 1 — Basic Collision

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

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

💡 Note: All robots move right in same direction, so no collisions occur. All survive with original health.

Example 2 — Head-on Collision

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

› Output: [14]

💡 Note: After sorting by position: R(H:15) at pos 2, L(H:10) at pos 3, R(H:10) at pos 5, L(H:12) at pos 6. Multiple collisions result in one survivor with health 14.

Example 3 — No Survivors

$ Input: positions = [1,2,3,4,5], healths = [1,1,1,1,1], directions = "RLRLR"

› Output: []

💡 Note: Alternating directions with equal health cause all robots to destroy each other in collisions.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ positions[i] ≤ 10⁹
1 ≤ healths[i] ≤ 10⁹
directions[i] is either 'L' or 'R'
All values in positions are distinct

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Facebook 18

The key insight is that only robots moving toward each other can collide - specifically right-moving robots meeting left-moving robots. The optimal stack-based approach sorts robots by position and processes collisions efficiently in a single pass. Time: O(n log n), Space: O(n)

Common Approaches

✓ Stack-Based Collision Detection

⏱️ Time: O(n log n) Space: O(n)

Sort robots by position, then process from left to right. Use a stack to track right-moving robots and handle collisions when encountering left-moving robots. This eliminates the need for repeated simulation rounds.

Brute Force Simulation

⏱️ Time: O(n³) Space: O(n)

Keep simulating robot movements and handle collisions one by one until no more collisions occur. Track positions and repeatedly check for overlapping robots moving toward each other.

Stack-Based Collision Detection — Algorithm Steps

Step 1: Sort robots by their positions on the line
Step 2: Process robots left to right using a stack
Step 3: Handle collisions between R and L robots immediately
Step 4: Collect survivors and return in original order

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by Position

Arrange robots left to right on the line

Process with Stack

Right-moving robots go on stack, left-moving cause collisions

Handle Collisions

Stack top vs current robot battles

Collect Survivors

Remaining robots in original order

Code -

solution.c — C

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

typedef struct {
    int pos, health, origIndex;
    char dir;
} Robot;

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

int* solution(int* positions, int* healths, char* directions, int n, int* returnSize) {
    Robot* robots = malloc(n * sizeof(Robot));
    for (int i = 0; i < n; i++) {
        robots[i] = (Robot){positions[i], healths[i], i, directions[i]};
    }
    
    qsort(robots, n, sizeof(Robot), compareRobots);
    
    Robot* stack = malloc(n * sizeof(Robot));
    int stackSize = 0;
    
    for (int i = 0; i < n; i++) {
        if (robots[i].dir == 'R') {
            stack[stackSize++] = robots[i];
        } else {
            int currentHealth = robots[i].health;
            while (stackSize > 0 && currentHealth > 0) {
                Robot* rightRobot = &stack[stackSize - 1];
                if (rightRobot->health < currentHealth) {
                    stackSize--;
                    currentHealth--;
                } else if (rightRobot->health > currentHealth) {
                    rightRobot->health--;
                    currentHealth = 0;
                } else {
                    stackSize--;
                    currentHealth = 0;
                }
            }
            
            if (currentHealth > 0) {
                stack[stackSize++] = (Robot){robots[i].pos, currentHealth, robots[i].origIndex, robots[i].dir};
            }
        }
    }
    
    int* survivors = calloc(n, sizeof(int));
    for (int i = 0; i < stackSize; i++) {
        survivors[stack[i].origIndex] = stack[i].health;
    }
    
    int* result = malloc(n * sizeof(int));
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (survivors[i] > 0) {
            result[count++] = survivors[i];
        }
    }
    
    *returnSize = count;
    free(robots);
    free(stack);
    free(survivors);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int positions[1000], posCount = 0;
    char* token = strtok(line + 1, ",]");
    while (token) {
        positions[posCount++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    int healths[1000], healthCount = 0;
    token = strtok(line + 1, ",]");
    while (token) {
        healths[healthCount++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    char directions[1001];
    fgets(directions, sizeof(directions), stdin);
    directions[strcspn(directions, "\n")] = 0;
    
    int returnSize;
    int* result = solution(positions, healths, directions, posCount, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), stack operations are O(n) total

⚡ Linearithmic

Space Complexity

O(n)

Stack stores up to n robots, plus sorting space

⚡ Linearithmic Space

32.4K Views

Medium-High Frequency

~35 min Avg. Time

892 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 Detection — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler