Robot Bounded in Circle: Why Does One Pass Work, and What Is the Python Solution?

Editorial answer · Explanation + Python solution

The one-pass test

You only need the final position and direction. There is no need to store every visited point or run the instructions indefinitely.

Why this works

Think of one complete instruction string as a single movement pattern. Each repetition has the same shape, rotated to match the robot’s starting direction.

For the last case, the displacement vectors are the same vector rotated by 0°, 90°, 180° and 270°. Their sum is zero. Since the repeating route consists of finitely many steps, a circle can enclose the whole route.

Python 3 solution

Represent north with the direction vector (0, 1). A left turn changes (dx, dy) to (-dy, dx); a right turn changes it to (dy, -dx).

class Solution:
    def isRobotBounded(self, instructions: str) -> bool:
        x, y = 0, 0
        dx, dy = 0, 1  # Start facing north.

        for move in instructions:
            if move == "G":
                x, y = x + dx, y + dy
            elif move == "L":
                dx, dy = -dy, dx
            else:  # The remaining valid command is "R".
                dx, dy = dy, -dx

        return (x == 0 and y == 0) or (dx, dy) != (0, 1)

Command correction: LeetCode uses G for “go forward”. If an assessment variant uses S instead, change that comparison to match its statement. Do not use S when submitting to this LeetCode problem.

Examples

A closer look at GL

Each pass moves forward once and turns left. The end states show how a changed heading closes the route:

Complexity and edge cases

• Time: O(n), where n is the instruction-string length. Each command is processed once.
• Extra space: O(1), using only position and direction variables.
• Turns only: bounded, because the robot never leaves the origin.
• Forward moves only: unbounded for a nonempty string.

Code verification: checked against all 9,840 valid command strings of lengths 1–8, eight explicit examples and four maximum-length cases. The independent reference simulator executes four full passes and checks for a return to the origin.

Problem reference: LeetCode 1041 — Robot Bounded In Circle. The explanation and implementation here are Qaskme’s AI-assisted editorial practice material.