Move Pieces to Obtain a String - Practice Coding Problems

Move Pieces to Obtain a String - Problem

🎯 Move Pieces to Transform String

Imagine you have a sliding puzzle with pieces that can only move in specific directions! You're given two strings: a start configuration and a target configuration, both of length n.

Each string contains exactly three types of characters:

'L' - A left-moving piece that can only slide left into adjacent blank spaces
'R' - A right-moving piece that can only slide right into adjacent blank spaces
'_' - A blank space that pieces can occupy

Your mission: Determine if you can transform the start string into the target string by sliding the pieces according to their movement rules.

Key Rules:

An 'L' piece can move left only if there's a '_' directly to its left
An 'R' piece can move right only if there's a '_' directly to its right
Pieces cannot jump over other pieces
You can perform any number of valid moves

Return true if the transformation is possible, false otherwise.

Input & Output

example_1.py — Basic Transformation

$ Input: start = "_L__R__R_", target = "L______RR"

› Output: true

💡 Note: L piece can move left from position 1 to position 0. Both R pieces can move right: first R from position 4 to position 7, second R from position 7 to position 8.

example_2.py — Invalid Movement

$ Input: start = "R_L_", target = "_LR_"

› Output: false

💡 Note: R piece cannot move right past the L piece, and L piece cannot move left past the R piece. The pieces would need to swap positions which is impossible.

example_3.py — Same Configuration

$ Input: start = "_R", target = "R_"

› Output: true

💡 Note: R piece can move right from position 1 to position 0... wait, that's impossible! R can only move right. This should be false.

Constraints

n == start.length == target.length
1 ≤ n ≤ 10⁵
start and target consist only of characters 'L', 'R', and '_'

Visualization

Tap to expand

Understanding the Visualization

Initial Traffic

Vehicles are positioned on the road with parking spaces (_) between them

Movement Rules

L vehicles can only move left to exit, R vehicles only move right to destination

Position Check

Verify each vehicle can reach target without violating movement constraints

Valid Configuration

All vehicles can reach their targets following traffic rules

Key Takeaway

🎯 Key Insight: L vehicles can only move left (position decreases) and R vehicles can only move right (position increases). The relative order of vehicles of the same type never changes, making this a constraint satisfaction problem rather than a pathfinding problem.

Asked in

G Google 45 f Facebook 32 A Amazon 28 ⊞ Microsoft 25

The optimal solution uses a two-pointers approach to validate movement constraints in O(n) time. Key insights: L pieces can only move left (position decreases), R pieces can only move right (position increases), and the relative order of same-type pieces never changes. First verify both strings have identical piece sequences (ignoring underscores), then check each piece can reach its target position without violating movement rules.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers Validation (Optimal)	O(n)	O(n)	Use two pointers to validate movement constraints and relative positioning
Brute Force Simulation	O(3^n)	O(3^n)	Try all possible moves until target is reached or no more moves possible

Two Pointers Validation (Optimal) — Algorithm Steps

First check if both strings have same characters (ignoring underscores)
Extract sequences of non-underscore characters from both strings
If sequences don't match, return false immediately
Use two pointers to check position constraints for each piece
For L pieces: position in target must be ≤ position in start
For R pieces: position in target must be ≥ position in start

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Pieces

Remove underscores and extract piece positions

Compare Sequences

Verify both strings have same pieces in same order

Validate Positions

Check L pieces can move left and R pieces can move right

Return Result

All constraints satisfied means transformation possible

Code -

solution.c — C

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

bool canChange(char* start, char* target) {
    int n = strlen(start);
    
    // Extract pieces and positions
    char startPieces[1001] = {0};
    char targetPieces[1001] = {0};
    int startPos[1000][2]; // [char, position]
    int targetPos[1000][2];
    int startCount = 0, targetCount = 0;
    int pieceIdx = 0;
    
    for (int i = 0; i < n; i++) {
        if (start[i] != '_') {
            startPieces[pieceIdx] = start[i];
            startPos[startCount][0] = start[i];
            startPos[startCount][1] = i;
            startCount++;
        }
        if (target[i] != '_') {
            targetPos[targetCount][0] = target[i];
            targetPos[targetCount][1] = i;
            targetCount++;
        }
    }
    
    // Build target pieces string
    for (int i = 0; i < targetCount; i++) {
        targetPieces[i] = targetPos[i][0];
    }
    
    // Compare piece sequences
    if (strcmp(startPieces, targetPieces) != 0) {
        return false;
    }
    
    // Check position constraints
    for (int i = 0; i < startCount; i++) {
        char startChar = startPos[i][0];
        int startIdx = startPos[i][1];
        char targetChar = targetPos[i][0];
        int targetIdx = targetPos[i][1];
        
        if (startChar != targetChar) return false;
        
        // L can only move left
        if (startChar == 'L' && startIdx < targetIdx) {
            return false;
        }
        
        // R can only move right
        if (startChar == 'R' && startIdx > targetIdx) {
            return false;
        }
    }
    
    return true;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through both strings to extract pieces and validate positions

✓ Linear Growth

Space Complexity

O(n)

Store piece positions for validation

⚡ Linearithmic Space

28.5K Views

Medium-High Frequency

~18 min Avg. Time

892 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

🎯 Move Pieces to Transform String

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Two Pointers Validation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler