Push Dominoes - Practice Coding Problems

Push Dominoes - Problem

Imagine you're looking at a line of n dominoes standing upright. Suddenly, some dominoes are pushed - some topple to the left (L), others to the right (R), while some remain upright (.).

Physics takes over! Each second, falling dominoes push their neighbors in the same direction. When a domino gets pushed from both sides with equal force, it stays perfectly balanced and upright.

Your mission: Given the initial state as a string where 'L' means pushed left, 'R' means pushed right, and '.' means upright, determine what the dominoes look like after they've all settled.

Example: "R.L" becomes "RRL" - the middle domino gets pushed right before the left force reaches it!

Input & Output

example_1.py — Basic Example

$ Input: dominoes = "RR.L"

› Output: "RRR"

💡 Note: The first domino falls right, the second is already falling right, the third gets pushed right by the second domino before the fourth domino's leftward force can reach it.

example_2.py — Balanced Forces

$ Input: dominoes = ".L.R...LR..L.."

› Output: "LL.RR.LLRRLL.."

💡 Note: Multiple force interactions create various regions where dominoes fall left, right, or remain upright when forces balance.

example_3.py — No Forces

$ Input: dominoes = "..."

› Output: "..."

💡 Note: When no dominoes are initially pushed, they all remain upright.

Visualization

Tap to expand

Right Pass: Force = N at R, 0 at L Decrease by 1 each step2. Left Pass: Force = N at L, 0 at R Decrease by 1 each step3. Compare: Net = Right - Left Positive→R, Negative→L, Zero→.

Understanding the Visualization

Map the Forces

Identify all source points where dominoes are initially pushed

Calculate Right Waves

Compute how far rightward forces travel from each R

Calculate Left Waves

Compute how far leftward forces travel from each L

Find the Winners

At each position, the stronger force determines the final state

Key Takeaway

🎯 Key Insight: Instead of simulating time steps, calculate force strengths directly - rightward forces decrease with distance from R, leftward forces decrease with distance from L, and the stronger force wins at each position!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the array, each taking O(n) time

✓ Linear Growth

Space Complexity

O(n)

Need arrays to store force values from both directions

⚡ Linearithmic Space

Constraints

1 ≤ dominoes.length ≤ 10⁵
dominoes[i] is either 'L', 'R', or '.'
All dominoes fall at the same speed (1 position per second)

Asked in

f Facebook 45 G Google 38 ⊞ Microsoft 32 a Amazon 28

The optimal solution uses a two-pass force calculation approach. First, we calculate rightward forces spreading from each 'R'. Then we calculate leftward forces from each 'L'. Finally, we compare net forces at each position to determine if dominoes fall right (positive), left (negative), or stay upright (zero). This achieves O(n) time complexity with clean, intuitive physics-based reasoning.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Force Calculation)	O(n)	O(n)	Calculate forces from both directions and determine the final state
Simulation (Time Step by Step)	O(n²)	O(1)	Simulate the domino falling process second by second

Two Pointers (Force Calculation) — Algorithm Steps

First pass: Calculate rightward forces spreading from each 'R'
Second pass: Calculate leftward forces spreading from each 'L'
For each position, compare the force strengths
If rightward force is stronger, domino falls right
If leftward force is stronger, domino falls left
If forces are equal, domino stays upright

Visualization

Tap to expand

Step-by-Step Walkthrough

Right Forces

Calculate rightward forces from R dominoes

Left Forces

Calculate leftward forces from L dominoes

Net Result

Compare forces to determine final state

Code -

solution.c — C

char* pushDominoes(char* dominoes) {
    int n = strlen(dominoes);
    int* forces = calloc(n, sizeof(int));
    char* result = malloc((n + 1) * sizeof(char));
    
    // Calculate rightward forces
    int force = 0;
    for (int i = 0; i < n; i++) {
        if (dominoes[i] == 'R') {
            force = n;
        } else if (dominoes[i] == 'L') {
            force = 0;
        } else {
            force = force > 0 ? force - 1 : 0;
        }
        forces[i] += force;
    }
    
    // Calculate leftward forces
    force = 0;
    for (int i = n - 1; i >= 0; i--) {
        if (dominoes[i] == 'L') {
            force = n;
        } else if (dominoes[i] == 'R') {
            force = 0;
        } else {
            force = force > 0 ? force - 1 : 0;
        }
        forces[i] -= force;
    }
    
    // Determine final state
    for (int i = 0; i < n; i++) {
        if (forces[i] > 0) {
            result[i] = 'R';
        } else if (forces[i] < 0) {
            result[i] = 'L';
        } else {
            result[i] = '.';
        }
    }
    result[n] = '\0';
    
    free(forces);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the array, each taking O(n) time

✓ Linear Growth

Space Complexity

O(n)

Need arrays to store force values from both directions

⚡ Linearithmic Space

Constraints

1 ≤ dominoes.length ≤ 10⁵
dominoes[i] is either 'L', 'R', or '.'
All dominoes fall at the same speed (1 position per second)

89.2K Views

Medium Frequency

~18 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (Force Calculation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler