Flip Game - Practice Coding Problems

Flip Game - Problem

String Easy

Flip Game Challenge

You're playing an exciting game with your friend where you take turns flipping consecutive ++ symbols to -- in a string. Imagine you have a string like "++++" - you can flip any two consecutive plus signs to minus signs in one move.

Your task: Given a string currentState containing only '+' and '-' characters, find all possible states after making exactly one valid move.

A valid move: Find any two consecutive "++" and flip them to "--"

Example: If the current state is "++++", you can make moves at positions 0-1, 1-2, or 2-3, resulting in states: ["--++", "+--+", "++--"]

Return all possible states after one move, or an empty list if no moves are possible.

Input & Output

example_1.py — Basic Case

$ Input: currentState = "++++"

› Output: ["--++", "+--+", "++--"]

💡 Note: There are three consecutive '++' pairs at positions (0,1), (1,2), and (2,3). Each can be flipped to '--' to create a new valid state.

example_2.py — Mixed Characters

$ Input: currentState = "+"

› Output: []

💡 Note: No consecutive '++' pairs exist, so no valid moves are possible. Return empty list.

example_3.py — Already Flipped

$ Input: currentState = "+-++"

› Output: ["+---"]

💡 Note: Only one consecutive '++' pair exists at positions (2,3), which can be flipped to create "+---".

Visualization

Tap to expand

Understanding the Visualization

Identify Targets

Scan the panel to find all pairs of adjacent ON switches

Generate States

For each valid pair, create a new panel state by flipping them OFF

Collect Results

Gather all possible panel configurations after one move

Key Takeaway

🎯 Key Insight: This is a generation problem where we must find ALL possible states, so we cannot avoid checking every position. The single-pass approach is optimal.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We iterate through n positions, and for each valid move, we create a new string of length n

⚠ Quadratic Growth

Space Complexity

O(n * k)

Where k is the number of valid moves, each requiring O(n) space for the new string

⚡ Linearithmic Space

Constraints

1 ≤ currentState.length ≤ 500
currentState[i] is either '+' or '-'
The game requires at least 2 characters to make a valid move

Asked in

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

The optimal approach uses a single pass through the string to identify all consecutive "++" patterns and generate new states by flipping them to "--". Since we must examine every position to find all valid moves, this O(n²) solution is actually optimal for this problem type.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass String Generation	O(n²)	O(n * k)	Iterate through string and generate new state for each valid move

Single Pass String Generation — Algorithm Steps

Initialize empty result list
Iterate through string from index 0 to n-2
For each position i, check if s[i] == '+' and s[i+1] == '+'
If true, create new string: s[0:i] + '--' + s[i+2:]
Add the new string to result list
Return the result list

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with the input string and empty result list

Scan Position 0-1

Check if characters at positions 0 and 1 are both '+'

Generate State

If valid, create new string by flipping '++' to '--'

Continue Scanning

Move to next position and repeat until end of string

Code -

solution.c — C

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

char** generatePossibleNextMoves(char* currentState, int* returnSize) {
    int n = strlen(currentState);
    char** result = (char**)malloc(n * sizeof(char*));
    *returnSize = 0;
    
    // Scan through the string looking for consecutive '++'
    for (int i = 0; i < n - 1; i++) {
        if (currentState[i] == '+' && currentState[i + 1] == '+') {
            // Create new state by flipping '++' to '--'
            char* newState = (char*)malloc((n + 1) * sizeof(char));
            strncpy(newState, currentState, i);
            newState[i] = '-';
            newState[i + 1] = '-';
            strcpy(newState + i + 2, currentState + i + 2);
            result[(*returnSize)++] = newState;
        }
    }
    
    return result;
}

int main() {
    char input[1001];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline if present
    int len = strlen(input);
    if (len > 0 && input[len-1] == '\n') {
        input[len-1] = '\0';
    }
    
    int returnSize;
    char** result = generatePossibleNextMoves(input, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(", ");
        free(result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We iterate through n positions, and for each valid move, we create a new string of length n

⚠ Quadratic Growth

Space Complexity

O(n * k)

Where k is the number of valid moves, each requiring O(n) space for the new string

⚡ Linearithmic Space

Constraints

1 ≤ currentState.length ≤ 500
currentState[i] is either '+' or '-'
The game requires at least 2 characters to make a valid move

28.4K Views

Medium Frequency

~15 min Avg. Time

850 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

Single Pass String Generation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler