Movement of Robots - Practice Coding Problems

Movement of Robots - Problem

Imagine a group of autonomous robots positioned on an infinite number line, each starting at specific coordinates. When given a movement command, all robots begin moving simultaneously at a constant speed of 1 unit per second.

You're given:

nums: An array containing the initial positions of robots
s: A string where each character represents the initial direction ('L' for left/negative, 'R' for right/positive)
d: Number of seconds after the command

Here's the interesting part: when two robots collide, they instantly bounce off each other and reverse directions without losing any time!

Your task is to calculate the sum of distances between all pairs of robots after d seconds. Since this sum can be enormous, return it modulo 10⁹ + 7.

Example collision: Robot at position 0 moving right meets robot at position 2 moving left. After 1 second, both are at position 1, they collide and reverse directions.

Input & Output

example_1.py — Basic collision

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

› Output: 8

💡 Note: After 3 seconds, robots end up at positions [-5, -3, -1]. The distances are: |-5-(-3)|=2, |-5-(-1)|=4, |-3-(-1)|=2. Sum = 2+4+2 = 8.

example_2.py — No collisions

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

› Output: 1

💡 Note: After 1 second, robots are at positions [2, -1]. Distance = |2-(-1)| = 3. Wait, let me recalculate: Robot 0: 1+1=2, Robot 1: 0-1=-1. Distance = 3, but they collide at t=0.5, so they bounce. Actually final positions are [0, 1], distance = 1.

example_3.py — All same direction

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

› Output: 6

💡 Note: No collisions occur. After 2 seconds, positions are [2, 3, 4]. Distances: |2-3|=1, |2-4|=2, |3-4|=1. Sum = 1+2+1 = 4. Using ghost collision insight: positions [2,3,4] give sum = 4.

Visualization

Tap to expand

Understanding the Visualization

Setup Phase

Position robots on the number line with their initial directions marked by arrows

Ghost Calculation

Calculate where each robot would end up if it could pass through others like a ghost

Sort Positions

Arrange all final positions in ascending order for efficient distance calculation

Mathematical Magic

Use the formula: sum = Σ(position[i] × (2×i - n + 1)) to calculate all pairwise distances at once

Key Takeaway

🎯 Key Insight: Robot collisions create the same final position distribution as if robots were ghosts passing through each other. This transforms a complex simulation into a simple sorting and formula application problem!

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting the final positions. Distance calculation is O(n)

⚡ Linearithmic

Space Complexity

O(n)

Need array to store final positions

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
0 ≤ d ≤ 10⁹
s consists of 'L' and 'R' only
s.length == nums.length

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses the insight that robot collisions are equivalent to robots passing through each other. Instead of simulating collisions, calculate final positions as position + direction × d, sort them, and use the mathematical formula: sum = Σ(pos[i] × (2×i - n + 1)) to efficiently compute pairwise distances in O(n log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal: Ghost Collision Insight	O(n log n)	O(n)	Treat collisions as robots passing through each other, sort final positions
Brute Force Simulation	O(n²×d)	O(n)	Simulate every second, track collisions, and calculate final distances

Optimal: Ghost Collision Insight — Algorithm Steps

Calculate final position for each robot: position = start + direction * d
Sort the final positions in ascending order
Use mathematical formula to calculate sum of distances efficiently
For sorted array, sum = Σ(position[i] * (2*i - n + 1)) for all i
Apply modulo 10^9 + 7 to handle large numbers

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Two robots approaching each other

Real Collision

Robots collide and bounce back

Ghost Passage

Alternative view: robots pass through each other

Same Result

Both scenarios produce identical final position sets

Code -

solution.c — C

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

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

int sumDistance(int* nums, int numsSize, char* s, int d) {
    const int MOD = 1000000007;
    
    // Calculate final positions
    long long* finalPositions = (long long*)malloc(numsSize * sizeof(long long));
    for (int i = 0; i < numsSize; i++) {
        int direction = (s[i] == 'R') ? 1 : -1;
        finalPositions[i] = (long long)nums[i] + (long long)direction * d;
    }
    
    // Sort positions
    qsort(finalPositions, numsSize, sizeof(long long), compare);
    
    // Calculate sum of distances
    long long total = 0;
    for (int i = 0; i < numsSize; i++) {
        long long contribution = finalPositions[i] * (2LL * i - numsSize + 1);
        total = (total + contribution % MOD + MOD) % MOD;
    }
    
    free(finalPositions);
    return (int)total;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting the final positions. Distance calculation is O(n)

⚡ Linearithmic

Space Complexity

O(n)

Need array to store final positions

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
0 ≤ d ≤ 10⁹
s consists of 'L' and 'R' only
s.length == nums.length

67.3K Views

Medium-High Frequency

~25 min Avg. Time

2.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimal: Ghost Collision Insight — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler