Push Dominoes

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: "RRRL"

💡 Note: The first domino is already falling right, the second is already falling right, the third gets pushed right by the second domino (force arrives at t=1) before being affected by the fourth domino's leftward force, and the fourth is already falling left.

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.

Constraints

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

Visualization

Tap to expand

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

✓ Simulation (Time Step by Step)

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

This approach mimics the real-world physics by simulating each time step. We repeatedly scan the array, updating dominoes that should fall based on their current neighbors, until no more changes occur.

Two Pointers (Force Calculation)

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

This approach treats the problem as calculating the strength of forces from each direction. We use two passes to calculate rightward and leftward forces, then determine the final state based on which force is stronger at each position.

Simulation (Time Step by Step) — Algorithm Steps

Start with the initial domino configuration
For each time step, scan all dominoes from left to right
If a domino is upright (.) and has a falling neighbor, it may fall
Update the configuration after checking all dominoes
Repeat until no changes occur in a complete pass

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with R.L configuration

Time Step 1

Middle domino gets pushed right by left neighbor

Final State

All dominoes have settled

Code -

solution.c — C

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

char* pushDominoes(char* dominoes) {
    int n = strlen(dominoes);
    char* result = malloc((n + 1) * sizeof(char));
    strcpy(result, dominoes);
    
    int changed = 1;
    while (changed) {
        changed = 0;
        char* temp = malloc((n + 1) * sizeof(char));
        strcpy(temp, result);
        
        for (int i = 0; i < n; i++) {
            if (result[i] == '.') {
                int leftPush = i > 0 && result[i-1] == 'R';
                int rightPush = i < n-1 && result[i+1] == 'L';
                
                if (leftPush && !rightPush) {
                    temp[i] = 'R';
                    changed = 1;
                } else if (rightPush && !leftPush) {
                    temp[i] = 'L';
                    changed = 1;
                }
            }
        }
        
        strcpy(result, temp);
        free(temp);
    }
    
    return result;
}

int main() {
    char dominoes[100001];
    fgets(dominoes, sizeof(dominoes), stdin);
    
    // Remove newline if present
    int len = strlen(dominoes);
    if (len > 0 && dominoes[len-1] == '\n') {
        dominoes[len-1] = '\0';
    }
    
    char* result = pushDominoes(dominoes);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we need O(n) time steps and O(n) work per step

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for temporary variables

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Simulation (Time Step by Step) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler