Walking Robot Simulation

Walking Robot Simulation - Problem

A robot on an infinite XY-plane starts at point (0, 0) facing north. The robot receives an array of integers commands, which represents a sequence of moves that it needs to execute.

There are only three possible types of instructions the robot can receive:

-2: Turn left 90 degrees
-1: Turn right 90 degrees
1 <= k <= 9: Move forward k units, one unit at a time

Some of the grid squares are obstacles. The i-th obstacle is at grid point obstacles[i] = (xi, yi). If the robot runs into an obstacle, it will stay in its current location (on the block adjacent to the obstacle) and move onto the next command.

Return the maximum squared Euclidean distance that the robot reaches at any point in its path (i.e. if the distance is 5, return 25).

Note:

There can be an obstacle at (0, 0). If this happens, the robot will ignore the obstacle until it has moved off the origin. However, it will be unable to return to (0, 0) due to the obstacle.
North means +Y direction, East means +X direction, South means -Y direction, West means -X direction.

Input & Output

Example 1 — Basic Movement with Obstacles

$ Input: commands = [4,-1,4,-2,-1,-2,3], obstacles = [[2,1],[1,1]]

› Output: 25

💡 Note: Robot moves (0,0)→(0,1)→(0,2)→(0,3)→(0,4), turns right to face East, tries to move but hits obstacle at (1,1), continues with other commands. Maximum distance reached is √25 = 5, so return 25.

Example 2 — No Obstacles

$ Input: commands = [4,-1,3], obstacles = []

› Output: 25

💡 Note: Robot moves North 4 units to (0,4), turns right to face East, moves 3 units to (3,4). Max distance² = 3² + 4² = 9 + 16 = 25.

Example 3 — Blocked at Origin

$ Input: commands = [1,2,-2,5], obstacles = [[0,1]]

› Output: 0

💡 Note: Robot tries to move North but hits obstacle at (0,1) immediately. Stays at (0,0) and processes remaining commands but never moves. Max distance² = 0.

Constraints

1 ≤ commands.length ≤ 10⁴
commands[i] is either -2, -1, or in the range [1, 9]
0 ≤ obstacles.length ≤ 10⁴
-3 × 10⁴ ≤ xi, yi ≤ 3 × 10⁴

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 38 f Facebook 22 M Microsoft 18

The key insight is to use a hash set for O(1) obstacle lookup while simulating the robot's movement step by step. Convert obstacles to a hash set, then simulate each command by updating direction or position. Best approach is Hash Set Optimization with Time: O(C×S+O), Space: O(O).

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(C × S × O) Space: O(1)

For each movement command, simulate one step at a time and check if the new position exists in the obstacles array by linear search. Track the maximum squared distance throughout the simulation.

Hash Set Optimization

⏱️ Time: O(C × S + O) Space: O(O)

Convert obstacles array to a hash set for constant-time lookups. Simulate robot movement step by step, checking obstacles efficiently. Track maximum squared distance throughout the path.

Brute Force Simulation — Algorithm Steps

Initialize robot at (0,0) facing north
For each command, process turn or movement
For movement, check each step against all obstacles
Update maximum squared distance

Visualization

Tap to expand

Step-by-Step Walkthrough

Robot Position

Track robot at (x,y) with direction

Linear Obstacle Check

For each step, scan all obstacles

Update Maximum

Track max squared distance

Code -

solution.c — C

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

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);
    }
}

void parseObstacles(const char* str, int obstacles[][2], int* size) {
    *size = 0;
    const char* p = str;
    
    // Skip to first '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Check if empty array
    while (*p == ' ') p++;
    if (*p == ']') return;
    
    while (*p) {
        // Look for start of obstacle '['
        while (*p && *p != '[') p++;
        if (*p != '[') break;
        p++; // skip '['
        
        // Parse first coordinate
        obstacles[*size][0] = (int)strtol(p, (char**)&p, 10);
        
        // Skip comma
        while (*p && *p != ',') p++;
        if (*p == ',') p++;
        
        // Parse second coordinate
        obstacles[*size][1] = (int)strtol(p, (char**)&p, 10);
        
        (*size)++;
        
        // Skip to end of this obstacle ']'
        while (*p && *p != ']') p++;
        if (*p == ']') p++;
        
        // Skip comma between obstacles
        while (*p == ' ' || *p == ',') p++;
        
        // Check if we've reached the end
        if (*p == ']') break;
    }
}

int solution(int* commands, int commandsSize, int obstacles[][2], int obstaclesSize) {
    int x = 0, y = 0;
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    int directionIdx = 0;
    int maxDistSq = 0;
    
    for (int i = 0; i < commandsSize; i++) {
        int command = commands[i];
        if (command == -2) {
            directionIdx = (directionIdx - 1 + 4) % 4;
        } else if (command == -1) {
            directionIdx = (directionIdx + 1) % 4;
        } else {
            int dx = directions[directionIdx][0];
            int dy = directions[directionIdx][1];
            for (int j = 0; j < command; j++) {
                int newX = x + dx;
                int newY = y + dy;
                int isObstacle = 0;
                for (int k = 0; k < obstaclesSize; k++) {
                    if (obstacles[k][0] == newX && obstacles[k][1] == newY) {
                        isObstacle = 1;
                        break;
                    }
                }
                if (!isObstacle) {
                    x = newX;
                    y = newY;
                    int distSq = x*x + y*y;
                    if (distSq > maxDistSq) {
                        maxDistSq = distSq;
                    }
                } else {
                    break;
                }
            }
        }
    }
    
    return maxDistSq;
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int commands[1000];
    int commandsSize;
    parseArray(line1, commands, &commandsSize);
    
    int obstacles[1000][2];
    int obstaclesSize;
    parseObstacles(line2, obstacles, &obstaclesSize);
    
    int result = solution(commands, commandsSize, obstacles, obstaclesSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C × S × O)

C commands, up to S=9 steps per move, O obstacles to check each step

✓ Linear Growth

Space Complexity

O(1)

Only variables for position, direction, and maximum distance

✓ Linear Space

34.5K Views

Medium Frequency

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

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler