Robot Return to Origin - Practice Coding Problems

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 = "RRULUL"

› Output: true

💡 Note: R:2, L:2, U:2, D:0. Wait - this has U:2 and no D, so it should be false. Let me correct: moves right twice, up twice, left twice - final position is (0,2), so false. Actually let me use a valid example: "RRLLUU" would be false, "RRLLUD" would be true.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Input

Sequence of moves as string

Process

Track displacement for each move

Output

Check if robot returns to (0,0)

Key Takeaway

🎯 Key Insight: A robot returns to origin if and only if opposite moves are perfectly balanced

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

Approach	Time	Space	Notes
✓ Move Counter	O(n)	O(1)	Count occurrences of each move and check if opposites balance
Position Tracking	O(n)	O(1)	Track robot's x,y coordinates after each move
Balance Tracking	O(n)	O(1)	Track net displacement in both dimensions simultaneously

Move Counter — Algorithm Steps

Count occurrences of each move type
Check if R count equals L count
Check if U count equals D count

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Moves

Count R, L, U, D occurrences

Check Balance

Verify R=L and U=D

Result

Return true if balanced

Code -

solution.c — C

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

bool solution(char* moves) {
    int countR = 0, countL = 0, countU = 0, countD = 0;
    int len = strlen(moves);
    for (int i = 0; i < len; i++) {
        if (moves[i] == 'R') countR++;
        else if (moves[i] == 'L') countL++;
        else if (moves[i] == 'U') countU++;
        else if (moves[i] == 'D') countD++;
    }
    return countR == countL && countU == countD;
}

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 to count all move frequencies

✓ Linear Growth

Space Complexity

O(1)

Fixed number of counters for four move types

✓ 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

Move Counter — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler