Walking Robot Simulation II - Practice Coding Problems

Walking Robot Simulation II - Problem

Design Simulation Medium

Imagine a robot explorer navigating a rectangular grid world! The robot starts at the bottom-left corner (0, 0) of a width × height grid, initially facing East. The grid extends from (0, 0) to (width-1, height-1).

Here's how our robot behaves:

When instructed to move forward, it attempts to step in its current direction
If it hits a boundary, it smartly turns 90° counterclockwise and tries again
It keeps turning and trying until it successfully moves forward

Your task: Implement a Robot class that can:

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

This problem tests your ability to simulate movement with boundary handling and efficient position tracking!

Input & Output

example_1.py — Basic Robot Movement

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

› Output: [2, 0], "East", [4, 0], "East", [6, 1], "North"

💡 Note: Robot moves 2 steps East to (2,0), then 2 more steps East to (4,0), then 2 more steps: 1 East to edge, turns North, 1 North to (5,1)

example_2.py — Complete Perimeter Loop

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

› Output: [0, 0], "South"

💡 Note: Perimeter = 2*(3+3-2) = 8 steps. After 8 steps robot completes one full loop and returns to origin, but now facing South instead of East

example_3.py — Edge Case: 1x1 Grid

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

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

💡 Note: In a 1x1 grid, robot cannot move anywhere and stays at (0,0) facing East regardless of step count

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

The Track

Robot follows a rectangular perimeter path: East → North → West → South

Track Length

Total perimeter = 2×(width + height - 2) for rectangles

Position Calculation

steps % perimeter gives position on the track

Coordinate Mapping

Map track position back to (x,y) coordinates and direction

Key Takeaway

🎯 Key Insight: The robot's movement forms a predictable cycle around the grid's perimeter, allowing us to use modular arithmetic for instant position calculation instead of step-by-step simulation!

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 6

The optimal approach uses perimeter path tracking with modular arithmetic to achieve O(1) time complexity. Instead of simulating each step, we recognize that the robot follows a predictable rectangular perimeter path and can calculate its position directly using steps % perimeter_length.

Common Approaches

Approach	Time	Space	Notes
✓ Simulate Every Step	O(n)	O(1)	Simulate each individual step, turning when hitting boundaries
Optimized Perimeter Tracking	O(1)	O(1)	Use modular arithmetic to efficiently calculate position on the perimeter path

Simulate Every Step — Algorithm Steps

For each step, try to move in current direction
If out of bounds, turn 90° counterclockwise
Repeat turning until a valid move is found
Update position and continue until all steps completed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Robot starts at (0,0) facing East

Move East

Robot moves right along bottom edge

Hit Right Wall

Robot turns counterclockwise to face North

Move North

Robot moves up along right edge

Code -

solution.c — C

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

Robot* robotCreate(int width, int height) {
    Robot* robot = (Robot*)malloc(sizeof(Robot));
    robot->width = width;
    robot->height = height;
    robot->x = 0;
    robot->y = 0;
    robot->dirIdx = 0;
    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 robotStep(Robot* robot, int num) {
    for (int i = 0; i < num; i++) {
        while (1) {
            int nextX = robot->x + robot->dx[robot->dirIdx];
            int nextY = robot->y + robot->dy[robot->dirIdx];
            
            if (nextX >= 0 && nextX < robot->width && 
                nextY >= 0 && nextY < robot->height) {
                robot->x = nextX;
                robot->y = nextY;
                break;
            } else {
                robot->dirIdx = (robot->dirIdx + 1) % 4;
            }
        }
    }
}

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

char* robotGetDir(Robot* robot) {
    return robot->directions[robot->dirIdx];
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Where n is the number of steps. Each step requires constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only storing current position, direction, and grid dimensions

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

890 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

Simulate Every Step — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler