Remove Colored Pieces if Both Neighbors are the Same Color

Remove Colored Pieces if Both Neighbors are the Same Color - Problem

Colored Pieces Game

Alice and Bob are playing a strategic game with colored pieces arranged in a line. Each piece is colored either 'A' (blue) or 'B' (red). The game follows these rules:

Game Rules:
• Alice moves first and can only remove 'A' pieces
• Bob can only remove 'B' pieces
• A piece can only be removed if both its neighbors are the same color as the piece
• Edge pieces (first and last) can never be removed
• The first player who cannot make a move loses

Your Task: Determine if Alice wins when both players play optimally.

Example: In "AAABBB", Alice can remove the middle 'A', and Bob can remove the middle 'B'. The game continues until one player runs out of valid moves.

Input & Output

example_1.py — Python

$ Input: colors = "AAABBB"

› Output: true

💡 Note: Alice removes middle 'A' to get "AABBB", then Bob removes middle 'B' to get "AABB". No more moves possible. Alice made the last move, so she wins.

example_2.py — Python

$ Input: colors = "AA"

› Output: false

💡 Note: Alice cannot make any moves because there are no 'A' pieces with both neighbors being 'A'. Bob wins by default.

example_3.py — Python

$ Input: colors = "ABBBBBBBAAA"

› Output: false

💡 Note: Alice has 1 move from 'AAA' group (3-2=1). Bob has 5 moves from 'BBBBBB' group (6-2=4). Bob wins with more available moves.

Visualization

Tap to expand

Understanding the Visualization

Identify Groups

Scan through the string and identify consecutive groups of same-colored pieces

Calculate Moves

For each group with 3+ pieces, the player gets (group_size - 2) possible moves

Compare Totals

Alice wins if her total available moves > Bob's total available moves

Key Takeaway

🎯 Key Insight: This game theory problem reduces to simple counting because move order doesn't affect the total number of available moves for each player.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string to count consecutive groups

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track counts and current group

✓ Linear Space

Constraints

1 ≤ colors.length ≤ 10⁵
colors consists of only the letters 'A' and 'B'
The string will always have at least one character

Asked in

f Meta 15 G Google 12 a Amazon 8 ⊞ Microsoft 6

The optimal solution counts available moves for each player in O(n) time. For each consecutive group of 3+ same-colored pieces, a player gets (length - 2) moves. Alice wins if her total moves exceed Bob's, since the order of moves doesn't affect the outcome.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation Approach	O(n²)	O(n)	Simulate the actual game by repeatedly finding and removing valid pieces
Optimal Counting (One Pass)	O(n)	O(1)	Count available moves for each player in a single pass through the string

Simulation Approach — Algorithm Steps

Start with Alice's turn
Scan the string for removable pieces for current player
Remove one piece if found and switch players
Repeat until no valid moves exist
Return true if Bob runs out of moves first

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with the original string and Alice's turn

Find Move

Scan for valid pieces the current player can remove

Make Move

Remove the piece and switch players

Check End

Continue until no moves are possible

Code -

solution.c — C

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

int canMove(char* s, char player, int len) {
    for (int i = 1; i < len - 1; i++) {
        if (s[i] == player && s[i-1] == player && s[i+1] == player) {
            return i;
        }
    }
    return -1;
}

bool winnerOfGame(char* colors) {
    int len = strlen(colors);
    char s[1001];
    strcpy(s, colors);
    
    bool aliceTurn = true;
    
    while (true) {
        char player = aliceTurn ? 'A' : 'B';
        int pos = canMove(s, player, len);
        
        if (pos == -1) {
            return !aliceTurn;
        }
        
        // Remove character at pos
        for (int i = pos; i < len - 1; i++) {
            s[i] = s[i + 1];
        }
        len--;
        s[len] = '\0';
        aliceTurn = !aliceTurn;
    }
}

int main() {
    char colors[1001];
    fgets(colors, sizeof(colors), stdin);
    
    // Remove newline and quotes
    colors[strcspn(colors, "\n")] = 0;
    if (colors[0] == '"' && colors[strlen(colors)-1] == '"') {
        colors[strlen(colors)-1] = 0;
        memmove(colors, colors + 1, strlen(colors));
    }
    
    printf("%s\n", winnerOfGame(colors) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we make O(n) moves and each move requires O(n) scan

⚠ Quadratic Growth

Space Complexity

O(n)

Need to store the modified string after each move

⚡ Linearithmic Space

Constraints

1 ≤ colors.length ≤ 10⁵
colors consists of only the letters 'A' and 'B'
The string will always have at least one character

21.8K Views

Medium Frequency

~15 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Simulation Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler