Robot Bounded In Circle - Practice Coding Problems

Robot Bounded In Circle - Problem

Imagine a robot placed on an infinite 2D plane at the origin (0, 0), initially facing north. The robot receives a sequence of instructions and will repeat them infinitely.

The robot understands three commands:

'G' - Move forward 1 unit in the current direction
'L' - Turn 90 degrees left (counterclockwise)
'R' - Turn 90 degrees right (clockwise)

The Challenge: Determine if the robot will stay within a bounded circular area forever, or if it will eventually escape to infinity.

Key Insight: If after executing the instruction sequence once, the robot either returns to the origin OR is not facing north, then it will eventually form a cycle and stay bounded!

Example: Instructions "GGLLGG" will make the robot walk in a square pattern, never escaping.

Input & Output

example_1.py — Basic Square Pattern

$ Input: instructions = "GGLLGG"

› Output: true

💡 Note: Robot moves North 2 units, turns left twice (now facing South), moves South 2 units. After one cycle: back at origin (0,0) but facing South. Since it returns to origin, it's bounded in a cycle.

example_2.py — Straight Line Escape

$ Input: instructions = "GG"

› Output: false

💡 Note: Robot moves North 2 units. After one cycle: at position (0,2) and still facing North. Each cycle will move it further North by 2 units, so it escapes to infinity.

example_3.py — Circular Pattern

$ Input: instructions = "GL"

› Output: true

💡 Note: Robot moves North 1 unit, then turns left (facing West). After one cycle: at (0,1) facing West. Since direction changed, after 4 cycles it will return to origin, forming a square pattern.

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Robot starts at origin (0,0) facing North

Execute Instructions

Process each instruction: G moves forward, L/R turn 90 degrees

Analyze Final State

Check position and direction after one complete cycle

Apply Mathematical Rule

Bounded if: at origin OR not facing North

Key Takeaway

🎯 Key Insight: The robot can only escape to infinity if it's displaced from origin while still facing the original direction (North). Any change in direction will eventually create a cycle due to the 4-fold rotational symmetry of the plane.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the instruction string of length n

✓ Linear Growth

Space Complexity

O(1)

Only storing position coordinates and direction, constant extra space

✓ Linear Space

Constraints

1 ≤ instructions.length ≤ 100
instructions[i] is 'G', 'L' or 'R'
The robot will repeat the instructions infinitely

Asked in

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

The optimal solution uses a beautiful mathematical insight: execute the instructions just once and check the final state. If the robot returns to origin OR is not facing North, it will be bounded. The key insight is that any rotation from the initial direction will eventually create a cycle due to rotational symmetry.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Mathematical Analysis (Optimal)	O(n)	O(1)	Execute instructions once and check final position and direction mathematically
Simulation (Multiple Cycles)	O(k*n)	O(k)	Simulate multiple instruction cycles until we detect a loop or determine boundedness

One-Pass Mathematical Analysis (Optimal) — Algorithm Steps

Initialize robot at origin (0,0) facing North
Execute the instruction sequence exactly once
Check final position and direction
Return true if: back at origin OR not facing North
Return false if: displaced from origin AND still facing North

Visualization

Tap to expand

Step-by-Step Walkthrough

Execute Once

Run through all instructions exactly one time

Check Position

If back at origin (0,0), robot is bounded

Check Direction

If not facing North, robot will eventually cycle back

Final Decision

Bounded if either condition is true, unbounded otherwise

Code -

solution.c — C

#include <stdbool.h>
#include <string.h>

bool isRobotBounded(char* instructions) {
    int x = 0, y = 0;
    int direction = 0; // North=0, East=1, South=2, West=3
    
    int dx[] = {0, 1, 0, -1};
    int dy[] = {1, 0, -1, 0};
    
    for (int i = 0; i < strlen(instructions); i++) {
        char instruction = instructions[i];
        if (instruction == 'G') {
            x += dx[direction];
            y += dy[direction];
        } else if (instruction == 'L') {
            direction = (direction - 1 + 4) % 4;
        } else { // 'R'
            direction = (direction + 1) % 4;
        }
    }
    
    return (x == 0 && y == 0) || direction != 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the instruction string of length n

✓ Linear Growth

Space Complexity

O(1)

Only storing position coordinates and direction, constant extra space

✓ Linear Space

Constraints

1 ≤ instructions.length ≤ 100
instructions[i] is 'G', 'L' or 'R'
The robot will repeat the instructions infinitely

68.9K Views

Medium-High Frequency

~15 min Avg. Time

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

One-Pass Mathematical Analysis (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler