Robot Return to Origin

Robot Return to Origin - Problem

String Simulation Easy

There is a robot starting at position (0, 0), the origin, on a 2D plane. Given a sequence of its moves, judge if this robot ends up at (0, 0) after it completes its moves.

You are given a string moves that represents the move sequence of the robot where moves[i] represents its i-th move. Valid moves are 'R' (right), 'L' (left), 'U' (up), and 'D' (down).

Return true if the robot returns to the origin after it finishes all of its moves, or false otherwise.

Note: The way that the robot is "facing" is irrelevant. 'R' will always make the robot move to the right once, 'L' will always make it move left, etc. Also, assume that the magnitude of the robot's movement is the same for each move.

Input & Output

Example 1 — Simple Return

$ Input: moves = "UD"

› Output: true

💡 Note: Robot moves up once, then down once, returning to origin (0,0)

Example 2 — Square Path

$ Input: moves = "LLUR"

› Output: false

💡 Note: Robot moves left twice, up once, right once. Final position is (-1,1), not origin

Example 3 — Complex Return

$ Input: moves = "RRLLUD"

› Output: true

💡 Note: Robot moves right twice, left twice, up once, down once. R and L cancel out, U and D cancel out, returning to origin (0,0)

Constraints

1 ≤ moves.length ≤ 2 × 10⁴
moves contains only valid characters: 'R', 'L', 'U', 'D'

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that for a robot to return to origin, every move in one direction must be balanced by a move in the opposite direction. The optimal approach tracks net displacement in horizontal and vertical dimensions. Time: O(n), Space: O(1)

Common Approaches

✓ Balance Tracking

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

Instead of counting individual moves, track the net balance. Increment/decrement for opposing moves and check if both balances are zero at the end.

Move Counter

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

Count how many times each move appears. For the robot to return to origin, the number of 'R' moves must equal 'L' moves, and 'U' moves must equal 'D' moves.

Position Tracking

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

Start at (0,0) and update coordinates for each move: R increments x, L decrements x, U increments y, D decrements y. Check if final position is (0,0).

Balance Tracking — Algorithm Steps

Initialize horizontal and vertical balance counters
Update balances: R/L affect horizontal, U/D affect vertical
Return true if both balances are zero

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set horizontal=0, vertical=0

Process

Update balances for each move

Check

Both balances must be zero

Code -

solution.c — C

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

bool solution(char* moves) {
    int horizontal = 0, vertical = 0;
    int len = strlen(moves);
    for (int i = 0; i < len; i++) {
        switch (moves[i]) {
            case 'R': horizontal++; break;
            case 'L': horizontal--; break;
            case 'U': vertical++; break;
            case 'D': vertical--; break;
        }
    }
    return horizontal == 0 && vertical == 0;
}

int main() {
    char moves[10001];
    fgets(moves, sizeof(moves), stdin);
    moves[strcspn(moves, "\n")] = 0;
    bool result = solution(moves);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the moves string

✓ Linear Growth

Space Complexity

O(1)

Only two variables for horizontal and vertical balance

✓ Linear Space

285.0K Views

Medium Frequency

~10 min Avg. Time

1.9K 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

Balance Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler