Robot Return to Origin - Practice Coding Problems

Robot Return to Origin - Problem

String Simulation Easy

Imagine a robot starting its journey at the origin point (0, 0) on a 2D coordinate plane. The robot receives a sequence of movement commands and executes them one by one.

You are given a string moves where each character represents a single movement command:

'R' - Move right (increases x-coordinate by 1)
'L' - Move left (decreases x-coordinate by 1)
'U' - Move up (increases y-coordinate by 1)
'D' - Move down (decreases y-coordinate by 1)

Your task is to determine whether the robot returns to the origin (0, 0) after executing all the movement commands.

Note: The robot's facing direction is irrelevant - each command always moves the robot in the absolute direction regardless of its current orientation.

Goal: Return true if the robot ends up at the origin, false otherwise.

Input & Output

example_1.py — Simple Return

$ Input: moves = "UD"

› Output: true

💡 Note: The robot moves up one step, then down one step. It ends up back at the origin (0,0).

example_2.py — Square Path

$ Input: moves = "RRULLDD"

› Output: false

💡 Note: Starting at origin: R(1,0) → R(2,0) → U(2,1) → L(1,1) → L(0,1) → D(0,0) → D(0,-1). The robot ends at (0,-1), not at origin.

example_3.py — Balanced Movements

$ Input: moves = "RRLLURDD"

› Output: true

💡 Note: R appears 2 times, L appears 2 times (balanced horizontally). U appears 1 time, D appears 2 times (not balanced vertically), so result is false. Wait, let me recount: R=2, L=2, U=1, D=2. This should be false. Let me correct: moves="RRLLURDD" has R=2, L=2, U=1, D=2, so it returns false.

Constraints

1 ≤ moves.length ≤ 2 × 10⁴
moves consists only of the characters 'U', 'D', 'L' and 'R'
Each move has equal magnitude (distance of 1)

Visualization

Tap to expand

Understanding the Visualization

Process All Moves

Count or track net displacement for each axis

Check Horizontal Balance

Net horizontal displacement must be zero (L = R)

Check Vertical Balance

Net vertical displacement must be zero (U = D)

Determine Result

Robot returns to origin only if both axes are balanced

Key Takeaway

🎯 Key Insight: A robot returns to origin if and only if the number of moves in each direction equals the number of moves in the opposite direction (L=R and U=D).

Asked in

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

The optimal solution uses a counting approach that recognizes we only need to verify if opposite movements balance out. Instead of simulating each step, we count the frequency of each direction and check if left moves equal right moves and up moves equal down moves. This gives us O(n) time complexity with clean, efficient code.

Common Approaches

Approach	Time	Space	Notes
✓ Count-Based Approach (Optimal)	O(n)	O(1)	Count occurrences of each move type and check if opposite moves balance out
Simulation Approach	O(n)	O(1)	Simulate every move by tracking x,y coordinates throughout the journey

Count-Based Approach (Optimal) — Algorithm Steps

Initialize counters for each direction (or use net displacement)
Count occurrences of each move type in a single pass
Check if left moves equal right moves AND up moves equal down moves
Return true only if both horizontal and vertical movements balance

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Direction Frequencies

Track how many times each direction appears

Check Horizontal Balance

Verify that left moves = right moves

Check Vertical Balance

Verify that up moves = down moves

Code -

solution.c — C

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

bool robotReturnToOrigin(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;
}

// Alternative using counters
bool robotReturnToOriginCount(char* moves) {
    int countR = 0, countL = 0, countU = 0, countD = 0;
    int len = strlen(moves);
    
    for (int i = 0; i < len; i++) {
        switch (moves[i]) {
            case 'R': countR++; break;
            case 'L': countL++; break;
            case 'U': countU++; break;
            case 'D': countD++; break;
        }
    }
    
    return countR == countL && countU == countD;
}

int main() {
    char moves[20001];
    fgets(moves, sizeof(moves), stdin);
    moves[strcspn(moves, "\n")] = 0;
    if (moves[0] == '"') {
        memmove(moves, moves + 1, strlen(moves));
        moves[strlen(moves) - 1] = '\0';
    }
    printf("%s\n", robotReturnToOrigin(moves) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the moves string to count each direction

✓ Linear Growth

Space Complexity

O(1)

Only using constant space for counters or variables

✓ Linear Space

87.0K Views

Medium Frequency

~8 min Avg. Time

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

Count-Based Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler