Swap Adjacent in LR String - Practice Coding Problems

Swap Adjacent in LR String - Problem

Imagine you have a string of characters where 'L' represents people who can only move left, 'R' represents people who can only move right, and 'X' represents empty spaces.

The movement rules are simple:

XL can become LX (L person moves left into empty space)
RX can become XR (R person moves right into empty space)

Given a start string like "RXXLRXRXL" and a target result string, determine if you can transform the start string into the result string using only these allowed moves.

Goal: Return true if transformation is possible, false otherwise.

Think of it as a puzzle where people can only move in their designated direction, but they can't jump over each other!

Input & Output

example_1.py — Basic Transformation

$ Input: start = "RXXLRXRXL", result = "XLRXXXRXL"

› Output: true

💡 Note: R can move right past X's, L can move left past X's. The sequence R,L,R,R,L is preserved in both strings, and all movements follow the constraints.

example_2.py — Impossible Transformation

$ Input: start = "RXL", result = "LXR"

› Output: false

💡 Note: The relative order changes from R,L to L,R, which is impossible since R cannot jump over L (R moves right, L moves left, they can't cross).

example_3.py — Same String

$ Input: start = "X", result = "L"

› Output: false

💡 Note: Cannot change X to L since X represents empty space and L represents a person - the total count of L and R characters must remain the same.

Constraints

1 ≤ start.length ≤ 10⁴
result.length == start.length
start and result consist only of characters 'L', 'R', and 'X'

Visualization

Tap to expand

Understanding the Visualization

Valid Movement

R moves right: RX → XR, L moves left: XL → LX

Relative Order

L and R characters maintain their sequence order

Position Constraints

L can only be at same position or move left, R can only be at same position or move right

Impossible Cases

R cannot move left past L, L cannot move right past R

Key Takeaway

🎯 Key Insight: Characters can only move in their designated direction and cannot change their relative order

Asked in

G Google 25 f Meta 18 a Amazon 12 ⊞ Microsoft 8

The optimal solution uses two pointers to verify that transformations follow movement rules. Key insight: relative order of L and R cannot change, L can only move left, and R can only move right. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(1)	Use two pointers to verify movement constraints without simulation
Brute Force (BFS/DFS)	O(2^n)	O(2^n)	Try all possible move sequences using breadth-first search

Two Pointers (Optimal) — Algorithm Steps

First verify both strings have same L and R characters in same order
Use two pointers to traverse both strings, skipping X characters
For each L in start, ensure it's not to the left of corresponding L in result
For each R in start, ensure it's not to the right of corresponding R in result
If all constraints satisfied, transformation is possible

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Place pointers at start of both strings

Skip Empty Spaces

Move pointers past X characters

Compare Characters

Ensure L/R characters match in order

Validate Movement

Check L moves left, R moves right constraints

Code -

solution.c — C

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

#define MAX_LEN 1000

bool canTransform(char* start, char* result) {
    int len = strlen(start);
    if (len != strlen(result)) return false;
    
    // Check if both strings have same characters ignoring X
    char s1[MAX_LEN] = {0}, s2[MAX_LEN] = {0};
    int idx1 = 0, idx2 = 0;
    
    for (int i = 0; i < len; i++) {
        if (start[i] != 'X') s1[idx1++] = start[i];
        if (result[i] != 'X') s2[idx2++] = result[i];
    }
    
    if (strcmp(s1, s2) != 0) return false;
    
    int i = 0, j = 0;
    
    while (i < len && j < len) {
        // Skip X in start string
        while (i < len && start[i] == 'X') i++;
        // Skip X in result string
        while (j < len && result[j] == 'X') j++;
        
        // Both reached end
        if (i == len && j == len) return true;
        
        // One reached end but not the other
        if (i == len || j == len) return false;
        
        // Characters must match
        if (start[i] != result[j]) return false;
        
        // L can only move left (position in result <= position in start)
        if (start[i] == 'L' && j > i) return false;
        
        // R can only move right (position in result >= position in start)
        if (start[i] == 'R' && j < i) return false;
        
        i++;
        j++;
    }
    
    return true;
}

int main() {
    char start[MAX_LEN], result[MAX_LEN];
    fgets(start, sizeof(start), stdin);
    fgets(result, sizeof(result), stdin);
    
    // Remove quotes and newlines
    start[strcspn(start, "\"\n")] = 0;
    result[strcspn(result, "\"\n")] = 0;
    
    printf("%s\n", canTransform(start, result) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through both strings with two pointers

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables and counters

✓ Linear Space

27.4K Views

Medium Frequency

~25 min Avg. Time

890 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

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler