Movement of Robots

Movement of Robots - Problem

Some robots are standing on an infinite number line with their initial coordinates given by a 0-indexed integer array nums and will start moving once given the command to move. The robots will move a unit distance each second.

You are given a string s denoting the direction in which robots will move on command. 'L' means the robot will move towards the left side or negative side of the number line, whereas 'R' means the robot will move towards the right side or positive side of the number line.

If two robots collide, they will start moving in opposite directions.

Return the sum of distances between all the pairs of robots d seconds after the command. Since the sum can be very large, return it modulo 10⁹ + 7.

Note:

For two robots at the index i and j, pair (i,j) and pair (j,i) are considered the same pair.
When robots collide, they instantly change their directions without wasting any time.
Collision happens when two robots share the same place in a moment.

Input & Output

Example 1 — Basic Movement

$ Input: nums = [1,0], s = "RL", d = 1

› Output: 3

💡 Note: Robot 0 starts at position 1 moving right (R), robot 1 starts at position 0 moving left (L). After 1 second: robot 0 would be at position 2, robot 1 would be at position -1. Distance = |2 - (-1)| = 3.

Example 2 — Multiple Robots

$ Input: nums = [-2,0,2], s = "LRR", d = 3

› Output: 20

💡 Note: After 3 seconds without considering collisions: robot 0 at -2-3=-5, robot 1 at 0+3=3, robot 2 at 2+3=5. Sorted: [-5,3,5]. Distances: |3-(-5)|=8, |5-(-5)|=10, |5-3|=2. Total = 8+10+2 = 20.

Example 3 — No Movement

$ Input: nums = [1,2,3], s = "LLL", d = 0

› Output: 4

💡 Note: No time passes (d=0), so robots stay at [1,2,3]. Distances: |2-1|=1, |3-1|=2, |3-2|=1. Total = 1+2+1 = 4.

Constraints

2 ≤ nums.length ≤ 10⁵
-2 × 10⁹ ≤ nums[i] ≤ 2 × 10⁹
1 ≤ d ≤ 10⁹
s.length == nums.length
s[i] is either 'L' or 'R'

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

The key insight is that colliding robots behave exactly as if they pass through each other. Instead of complex collision simulation, we can calculate final positions directly by ignoring collisions, then sort and compute pairwise distances. Best approach uses prefix sums for O(n log n) time complexity. Time: O(n log n), Space: O(n)

Common Approaches

✓ Key Insight: Ignore Collisions

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

The key insight is that when robots collide and bounce, the final positions are the same as if they had passed through each other. We can calculate final positions directly.

Prefix Sum Optimization

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

After sorting final positions, use prefix sums to calculate the sum of all pairwise distances efficiently instead of the O(n²) nested loop approach.

Simulation with Collision Detection

⏱️ Time: O(d × n²) Space: O(n)

Track each robot's position and direction, simulate movement second by second, detect collisions and reverse directions when they occur.

Key Insight: Ignore Collisions — Algorithm Steps

Calculate where each robot would be if no collisions occurred
Sort these final positions
Calculate sum of pairwise distances using sorted array optimization

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Direct

Find where each robot would be without collisions

Sort Positions

Sort final positions for efficient distance calculation

Sum Distances

Calculate pairwise distances from sorted array

Code -

solution.c — C

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

#define MOD 1000000007

int compare(const void* a, const void* b) {
    long long x = *(long long*)a;
    long long y = *(long long*)b;
    if (x < y) return -1;
    if (x > y) return 1;
    return 0;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int solution(int* nums, int numsSize, char* s, int d) {
    long long* final_positions = (long long*)malloc(numsSize * sizeof(long long));
    
    // Calculate final positions ignoring collisions
    for (int i = 0; i < numsSize; i++) {
        int direction = (s[i] == 'R') ? 1 : -1;
        long long final_pos = nums[i] + (long long)direction * d;
        final_positions[i] = final_pos;
    }
    
    // Sort positions for efficient distance calculation
    qsort(final_positions, numsSize, sizeof(long long), compare);
    
    // Calculate sum of all pairwise distances
    long long total = 0;
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            total = (total + final_positions[j] - final_positions[i]) % MOD;
        }
    }
    
    free(final_positions);
    return (int)total;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[100];
    int numsSize;
    parseArray(line, nums, &numsSize);
    
    char s[100];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int d;
    scanf("%d", &d);
    
    printf("%d\n", solution(nums, numsSize, s, d));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting n positions dominates, distance calculation is O(n²) but can be optimized with prefix sums

⚠ Quadratic Growth

Space Complexity

O(n)

Store final positions array

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

847 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

Key Insight: Ignore Collisions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler