Furthest Point From Origin - Practice Coding Problems

Furthest Point From Origin - Problem

String Counting Easy

You're standing at the origin (position 0) on an infinite number line, ready to embark on a journey! You have a string of movement instructions consisting of:

'L' - Must move left (position -= 1)
'R' - Must move right (position += 1)
'_' - Your choice! Move either left OR right

Your goal is to strategically choose the direction for each '_' character to end up as far away from the origin as possible after executing all moves.

Return: The maximum distance from origin you can achieve.

Example: With moves "L_R", you could go Left → Left → Right (ending at position -1, distance = 1) or Left → Right → Right (ending at position +1, distance = 1). Both give distance = 1.

Input & Output

example_1.py — Python

$ Input: moves = "L_R"

› Output: 2

💡 Note: We start at 0. The optimal strategy is: L (go to -1), then _ as L (go to -2), then R (go to -1). Final distance = |-1| = 1. Wait, let's recalculate: L=1, R=1, _=1. Net = 1-1 = 0. Max distance = |0| + 1 = 1. Actually, if we do L, then _ as R, then R: position becomes -1+1+1 = 1, distance = 1. Both give same result = 1. Let me recalculate the example: for "L_R", if we choose _ as R: L(-1) → R(0) → R(+1), distance = 1. If we choose _ as L: L(-1) → L(-2) → R(-1), distance = 1. Both ways give distance 1, but the optimal formula gives |1-1| + 1 = 1.

example_2.py — Python

$ Input: moves = "_R__L"

› Output: 5

💡 Note: We have L=1, R=1, _=3. Net displacement = 1-1 = 0. To maximize distance, use all 3 flexible moves in the same direction. Max distance = |0| + 3 = 3. Wait, that's wrong. Let me recalculate: if all _ go R: R+R+R+R+L = +3. If all _ go L: L+R+L+L+L = -3. Both give distance 3. Actually the optimal is max(|net + flexible|, |net - flexible|) = max(|0+3|, |0-3|) = max(3,3) = 3.

example_3.py — Python

$ Input: moves = "__"

› Output: 2

💡 Note: All moves are flexible. L=0, R=0, _=2. Net displacement = 0. We can go either all left (final position -2, distance 2) or all right (final position +2, distance 2). Max distance = |0| + 2 = 2.

Constraints

1 ≤ moves.length ≤ 50
moves consists only of characters 'L', 'R' and '_'.
At least one character in moves

Visualization

Tap to expand

Understanding the Visualization

Analyze Constraints

Count mandatory left moves, mandatory right moves, and flexible moves

Calculate Net Effect

Determine where mandatory moves alone would take you

Optimize Flexible Moves

Use all flexible moves to amplify your distance from origin

Apply Mathematical Formula

Max distance = |net_displacement| + flexible_moves

Key Takeaway

🎯 Key Insight: All flexible moves should work together to maximize distance - if the net mandatory displacement pushes you in one direction, use all flexible moves to amplify that displacement!

Asked in

f Meta 12 a Amazon 8 G Google 5 ⊞ Microsoft 3

The optimal solution uses a mathematical approach: count the 'L', 'R', and '_' characters, calculate the net displacement from mandatory moves, then use all flexible moves to maximize the distance from origin. The formula is max_distance = |R_count - L_count| + flexible_count, achieving O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal Mathematical Solution	O(n)	O(1)	Count L, R, and _ characters, then use math to determine maximum distance
Brute Force (Try All Combinations)	O(2^k × n)	O(k)	Generate all possible combinations of L/R for each '_' character

Optimal Mathematical Solution — Algorithm Steps

Count occurrences of 'L', 'R', and '_' characters in one pass
Calculate net displacement from mandatory moves: R_count - L_count
All '_' moves should go in the direction that maximizes distance from origin
If net displacement is positive, all '_' should be 'R'; if negative, all '_' should be 'L'
Return absolute value of (net_displacement + flexible_moves_count) or (net_displacement - flexible_moves_count)

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Characters

Count L, R, and _ in one pass through the string

Calculate Net Displacement

Net = R_count - L_count (mandatory displacement)

Optimize Flexible Moves

All _ moves should amplify the distance from origin

Apply Formula

Max distance = |net_displacement| + flexible_count

Code -

solution.c — C

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

int furthestDistanceFromOrigin(char* moves) {
    int leftCount = 0;
    int rightCount = 0;
    int flexibleCount = 0;
    int len = strlen(moves);
    
    // Count each type of move in one pass
    for (int i = 0; i < len; i++) {
        if (moves[i] == 'L') leftCount++;
        else if (moves[i] == 'R') rightCount++;
        else flexibleCount++; // moves[i] == '_'
    }
    
    // Calculate net displacement from mandatory moves
    int netDisplacement = rightCount - leftCount;
    
    // All flexible moves go in direction that maximizes distance
    int maxDistance = abs(netDisplacement) + flexibleCount;
    
    return maxDistance;
}

int main() {
    char moves[1001];
    scanf("%s", moves);
    // Remove quotes if present
    if (moves[0] == '"') {
        int len = strlen(moves);
        memmove(moves, moves + 1, len - 2);
        moves[len - 2] = '\0';
    }
    printf("%d\n", furthestDistanceFromOrigin(moves));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string to count characters

✓ Linear Growth

Space Complexity

O(1)

Only using a few integer variables for counting

✓ Linear Space

28.4K Views

Medium Frequency

~12 min Avg. Time

847 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

Optimal Mathematical Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler