Swap Adjacent in LR String

Swap Adjacent in LR String - Problem

In a string composed of 'L', 'R', and 'X' characters, like "RXXLRXRXL", a move consists of either:

Replacing one occurrence of "XL" with "LX", or
Replacing one occurrence of "RX" with "XR"

Given the starting string start and the ending string result, return true if and only if there exists a sequence of moves to transform start to result.

Key insight: L can only move left, R can only move right, and their relative order must be preserved.

Input & Output

Example 1 — Basic Transformation

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

› Output: true

💡 Note: We can transform start to result: R can move right through X positions, L can move left through X positions. The sequence R,L,R,R,L is preserved in both strings.

Example 2 — Invalid Movement

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

› Output: false

💡 Note: Cannot change R to L - only movements allowed are XL→LX and RX→XR. Character types must remain the same.

Example 3 — Impossible Direction

$ Input: start = "XXLR", result = "LRXX"

› Output: false

💡 Note: L at position 2 cannot move right to position 0, and R at position 3 cannot move left to position 1. Movement constraints are violated.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 38 M Microsoft 29 a Amazon 22

The key insight is that L can only move left and R can only move right, while preserving their relative order. The optimal approach uses two pointers to match L/R characters in O(n) time while validating movement constraints. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(2^n) Space: O(2^n)

Generate all possible next states by applying valid moves (XL→LX, RX→XR) and use breadth-first search to find if the target string is reachable. This explores the entire state space.

Single Pass Character Matching

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

Use two pointers to traverse both strings simultaneously, skipping X characters and matching L/R characters. For each matched pair, verify the movement constraints: L can only be at same or left position, R can only be at same or right position.

Two Pointers with Movement Rules

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

Extract only L and R characters from both strings and check: 1) Same sequence of L/R characters, 2) Each L in result is at same or left position, 3) Each R in result is at same or right position. This leverages the key insight about movement constraints.

Brute Force Simulation — Algorithm Steps

Start with initial string in queue
For each state, generate all possible moves
Check if any generated state matches target
Continue until target found or queue empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with input string in queue

Generate Moves

For each state, try all XL→LX and RX→XR moves

Check Target

Return true if target string is reached

Code -

solution.c — C

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

#define MAX_STATES 100000
#define MAX_LEN 1000

static char queue_states[MAX_STATES][MAX_LEN];
static char visited_states[MAX_STATES][MAX_LEN];

bool solution(char* start, char* result) {
    int start_len = strlen(start);
    int result_len = strlen(result);
    
    if (start_len != result_len) return false;
    if (strcmp(start, result) == 0) return true;
    
    int front = 0, rear = 0;
    int visited_count = 0;
    
    strcpy(queue_states[rear], start);
    rear++;
    strcpy(visited_states[visited_count], start);
    visited_count++;
    
    while (front < rear) {
        char current[MAX_LEN];
        strcpy(current, queue_states[front]);
        front++;
        
        int current_len = strlen(current);
        for (int i = 0; i < current_len - 1; i++) {
            if (current[i] == 'X' && current[i + 1] == 'L') {
                char newState[MAX_LEN];
                strcpy(newState, current);
                newState[i] = 'L';
                newState[i + 1] = 'X';
                
                if (strcmp(newState, result) == 0) return true;
                
                bool found = false;
                for (int j = 0; j < visited_count; j++) {
                    if (strcmp(visited_states[j], newState) == 0) {
                        found = true;
                        break;
                    }
                }
                if (!found) {
                    strcpy(visited_states[visited_count], newState);
                    visited_count++;
                    strcpy(queue_states[rear], newState);
                    rear++;
                }
            } else if (current[i] == 'R' && current[i + 1] == 'X') {
                char newState[MAX_LEN];
                strcpy(newState, current);
                newState[i] = 'X';
                newState[i + 1] = 'R';
                
                if (strcmp(newState, result) == 0) return true;
                
                bool found = false;
                for (int j = 0; j < visited_count; j++) {
                    if (strcmp(visited_states[j], newState) == 0) {
                        found = true;
                        break;
                    }
                }
                if (!found) {
                    strcpy(visited_states[visited_count], newState);
                    visited_count++;
                    strcpy(queue_states[rear], newState);
                    rear++;
                }
            }
        }
    }
    
    return false;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each position can potentially be in multiple states, leading to exponential branching

✓ Linear Growth

Space Complexity

O(2^n)

Queue stores exponentially many possible string states

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

891 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

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler