Walking Robot Simulation II

Walking Robot Simulation II - Problem

Design Simulation Medium

A robot is placed on a rectangular grid of width × height cells, with the bottom-left corner at position (0, 0) and the top-right corner at (width - 1, height - 1). The robot initially starts at (0, 0) facing East.

The robot can be instructed to move a specific number of steps. For each step:

It attempts to move forward one cell in its current direction
If the next cell is out of bounds, the robot turns 90 degrees counterclockwise and retries the step

Implement the Robot class with the following methods:

Robot(int width, int height): Initialize the grid and robot position
void step(int num): Move the robot forward num steps
int[] getPos(): Return current position as [x, y]
String getDir(): Return current direction ("North", "East", "South", "West")

Input & Output

Example 1 — Basic Robot Operations

$ Input: Robot(2, 3), step(2), getPos(), getDir(), step(2), getPos(), getDir(), step(2), getPos(), getDir()

› Output: [null, null, [1,1], "North", null, [0,2], "West", null, [0,1], "South"]

💡 Note: Initialize 2×3 grid. Step 2: (0,0)→(1,0)→hit boundary→turn North→(1,1). Step 2: (1,1)→(1,2)→hit boundary→turn West→(0,2). Step 2: (0,2)→(0,1)→(0,0) would hit boundary→turn South→(0,1).

Example 2 — Single Cell Grid

$ Input: Robot(1, 1), step(2), getPos(), getDir()

› Output: [null, null, [0,0], "East"]

💡 Note: In a 1×1 grid, robot cannot move and stays at (0,0) facing East regardless of steps.

Example 3 — Large Step Count

$ Input: Robot(2, 2), step(100), getPos(), getDir()

› Output: [null, null, [0,0], "East"]

💡 Note: 2×2 grid has perimeter cycle of length 4. After 100 steps (100%4=0), robot returns to start position.

Constraints

2 ≤ width, height ≤ 100
1 ≤ num ≤ 10⁵
At most 10⁴ calls to step, getPos, and getDir

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6 A Apple 4

The key insight is recognizing that the robot follows a predictable cycle around the grid perimeter. The optimal approach pre-computes this cycle and uses modular arithmetic for O(1) position lookup. Time: O(w+h) for setup, O(1) per operation. Space: O(w+h) for cycle storage.

Common Approaches

✓ Cycle Detection with Modular Arithmetic

⏱️ Time: O(w + h) Space: O(w + h)

The robot follows a predictable cycle around the grid perimeter. Calculate the cycle length and use modular arithmetic to directly compute position after any number of steps.

Step-by-Step Simulation

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

For each step, try to move forward. If out of bounds, turn counterclockwise and retry. This directly follows the problem description.

Cycle Detection with Modular Arithmetic — Algorithm Steps

Calculate perimeter cycle length: 2*(width + height - 2)
Pre-compute all positions in the cycle
Use modular arithmetic to find final position

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Cycle

Pre-compute all positions in the perimeter cycle

Modular Arithmetic

Use position % cycle_length to find current location

Direct Lookup

Get position and direction from pre-computed arrays

Code -

solution.c — C

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

typedef struct {
    int width, height, x, y, dirIndex;
    char directions[4][10];
    int dx[4];
    int dy[4];
} Robot;

Robot* createRobot(int width, int height) {
    Robot* robot = (Robot*)malloc(sizeof(Robot));
    robot->width = width;
    robot->height = height;
    robot->x = 0;
    robot->y = 0;
    robot->dirIndex = 0;  // 0=East, 1=North, 2=West, 3=South
    
    strcpy(robot->directions[0], "East");
    strcpy(robot->directions[1], "North");
    strcpy(robot->directions[2], "West");
    strcpy(robot->directions[3], "South");
    
    robot->dx[0] = 1; robot->dx[1] = 0; robot->dx[2] = -1; robot->dx[3] = 0;
    robot->dy[0] = 0; robot->dy[1] = 1; robot->dy[2] = 0; robot->dy[3] = -1;
    
    return robot;
}

void step(Robot* robot, int num) {
    for (int i = 0; i < num; i++) {
        // Try to move in current direction
        int nextX = robot->x + robot->dx[robot->dirIndex];
        int nextY = robot->y + robot->dy[robot->dirIndex];
        
        // Check if next position is within bounds
        if (0 <= nextX && nextX < robot->width && 0 <= nextY && nextY < robot->height) {
            robot->x = nextX;
            robot->y = nextY;
        } else {
            // Hit boundary, turn 90 degrees counterclockwise
            int originalDir = robot->dirIndex;
            int turns = 0;
            while (turns < 4) {
                robot->dirIndex = (robot->dirIndex + 1) % 4;
                turns += 1;
                nextX = robot->x + robot->dx[robot->dirIndex];
                nextY = robot->y + robot->dy[robot->dirIndex];
                if (0 <= nextX && nextX < robot->width && 0 <= nextY && nextY < robot->height) {
                    robot->x = nextX;
                    robot->y = nextY;
                    break;
                }
            }
            if (turns >= 4) {
                // No valid move found (like 1x1 grid), restore original direction
                robot->dirIndex = originalDir;
            }
        }
    }
}

int* getPos(Robot* robot) {
    int* pos = (int*)malloc(2 * sizeof(int));
    pos[0] = robot->x;
    pos[1] = robot->y;
    return pos;
}

char* getDir(Robot* robot) {
    return robot->directions[robot->dirIndex];
}

typedef struct {
    char command[20];
    int params[2];
    int paramCount;
} Operation;

int parseOperations(char* line, Operation** operations) {
    int count = 0;
    int capacity = 10;
    *operations = (Operation*)malloc(capacity * sizeof(Operation));
    
    char* ptr = line;
    while (*ptr) {
        if (*ptr == '[' && *(ptr+1) == '"') {
            if (count >= capacity) {
                capacity *= 2;
                *operations = (Operation*)realloc(*operations, capacity * sizeof(Operation));
            }
            
            Operation* op = &(*operations)[count];
            op->paramCount = 0;
            
            // Parse command
            ptr += 2; // Skip '["'
            int cmdLen = 0;
            while (*ptr != '"') {
                op->command[cmdLen++] = *ptr++;
            }
            op->command[cmdLen] = '\0';
            
            // Skip to parameters
            while (*ptr && *ptr != '[') ptr++;
            if (*ptr == '[') {
                ptr++; // Skip '['
                while (*ptr && *ptr != ']') {
                    if (*ptr >= '0' && *ptr <= '9') {
                        int num = 0;
                        while (*ptr >= '0' && *ptr <= '9') {
                            num = num * 10 + (*ptr - '0');
                            ptr++;
                        }
                        op->params[op->paramCount++] = num;
                    } else {
                        ptr++;
                    }
                }
            }
            
            count++;
        }
        ptr++;
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline
    line[strcspn(line, "\n")] = 0;
    
    Operation* operations;
    int opCount = parseOperations(line, &operations);
    
    Robot* robot = NULL;
    
    printf("[");
    for (int i = 0; i < opCount; i++) {
        if (i > 0) printf(",");
        
        Operation* op = &operations[i];
        if (strcmp(op->command, "Robot") == 0) {
            robot = createRobot(op->params[0], op->params[1]);
            printf("null");
        } else if (strcmp(op->command, "step") == 0) {
            step(robot, op->params[0]);
            printf("null");
        } else if (strcmp(op->command, "getPos") == 0) {
            int* pos = getPos(robot);
            printf("[%d,%d]", pos[0], pos[1]);
            free(pos);
        } else if (strcmp(op->command, "getDir") == 0) {
            printf("\"%s\"", getDir(robot));
        }
    }
    printf("]\n");
    
    free(operations);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(w + h)

Pre-compute cycle once, then O(1) per step() call

✓ Linear Growth

Space Complexity

O(w + h)

Store the perimeter cycle positions

✓ Linear Space

12.0K Views

Medium Frequency

~25 min Avg. Time

245 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

Cycle Detection with Modular Arithmetic — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler