Bulb Switcher II - Practice Coding Problems

Bulb Switcher II - Problem

Imagine you're in a room with n bulbs labeled from 1 to n, all initially turned ON. On the wall, there are four special buttons that control the bulbs in different patterns:

Button 1: Flips all bulbs (1, 2, 3, 4, ...)
Button 2: Flips bulbs with even labels (2, 4, 6, 8, ...)
Button 3: Flips bulbs with odd labels (1, 3, 5, 7, ...)
Button 4: Flips bulbs at positions 3k + 1 where k ≥ 0 (1, 4, 7, 10, ...)

You must press buttons exactly presses times. Each press can be any of the four buttons. Your goal is to determine how many different possible states the bulbs can be in after all button presses.

Example: With n=2 and presses=1, you could press button 1 (both bulbs OFF), button 2 (bulb 1 ON, bulb 2 OFF), or button 3 (bulb 1 OFF, bulb 2 ON), giving you 3 different states.

Input & Output

example_1.py — Basic case

$ Input: n = 1, presses = 1

› Output: 4

💡 Note: With 1 bulb and 1 press: Button 1 → [0], Button 2 → [1] (no effect), Button 3 → [0], Button 4 → [0]. All 4 buttons give different results.

example_2.py — Two bulbs

$ Input: n = 2, presses = 1

› Output: 3

💡 Note: Button 1 → [0,0], Button 2 → [1,0], Button 3 → [0,1], Button 4 → [0,1]. Buttons 3 and 4 give same result, so 3 unique states.

example_3.py — Multiple presses

$ Input: n = 3, presses = 2

› Output: 7

💡 Note: With 2 presses, we can achieve combinations like pressing different buttons once each, or pressing one button twice (which cancels out). This creates 7 distinct final states.

Visualization

Tap to expand

Understanding the Visualization

Pattern Recognition

Notice that button effects follow mathematical patterns - even/odd positions, arithmetic sequences

Cancellation Discovery

Realize that pressing same button twice returns to original state

Periodicity Insight

Understand that the pattern repeats every 3 bulbs due to LCM of button patterns

State Space Reduction

Reduce from exponential to constant time by focusing on button press parities

Key Takeaway

🎯 Key Insight: Mathematical pattern recognition transforms an exponential problem into a constant-time solution by identifying button press cancellations and periodic bulb patterns.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Constant time as we only check fixed number of combinations

✓ Linear Growth

Space Complexity

O(1)

Only store a few button states and bulb configurations

✓ Linear Space

Constraints

1 ≤ n ≤ 1000
0 ≤ presses ≤ 1000
All bulbs start in the ON state
Button presses must be exactly equal to the given number

Asked in

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

The optimal solution uses mathematical insights to recognize that pressing the same button twice cancels out, so only the parity (odd/even count) of button presses matters. Additionally, due to the periodic pattern of button effects, only the first 3 bulbs determine the entire state. This reduces the problem from O(4^presses) to O(1) by checking only 16 possible button combinations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(4^presses × n)	O(4^presses × n)	Generate all possible button press sequences and count unique final states
Mathematical Pattern Recognition (Optimal)	O(1)	O(1)	Use mathematical insights about button effects and periodicities to solve efficiently

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible sequences of button presses (4^presses combinations)
For each sequence, simulate the button presses on the bulb array
Store unique final states in a set
Return the count of unique states

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

All n bulbs start in ON state (represented as 1s)

Generate Sequences

Create all 4^presses possible button sequences

Simulate Each Sequence

Apply each button sequence to get final bulb states

Count Unique States

Store unique final states and return count

Code -

solution.c — C

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

void applyButton(int* bulbs, int n, int button) {
    if (button == 1) {
        for (int i = 0; i < n; i++) {
            bulbs[i] = 1 - bulbs[i];
        }
    } else if (button == 2) {
        for (int i = 1; i < n; i += 2) {
            bulbs[i] = 1 - bulbs[i];
        }
    } else if (button == 3) {
        for (int i = 0; i < n; i += 2) {
            bulbs[i] = 1 - bulbs[i];
        }
    } else if (button == 4) {
        for (int i = 0; i < n; i += 3) {
            bulbs[i] = 1 - bulbs[i];
        }
    }
}

int power(int base, int exp) {
    int result = 1;
    for (int i = 0; i < exp; i++) {
        result *= base;
    }
    return result;
}

int flipLights(int n, int presses) {
    int totalSequences = power(4, presses);
    char states[1000][1000];
    int stateCount = 0;
    
    for (int seq = 0; seq < totalSequences; seq++) {
        int* bulbs = (int*)malloc(n * sizeof(int));
        for (int i = 0; i < n; i++) {
            bulbs[i] = 1;
        }
        
        int temp = seq;
        for (int i = 0; i < presses; i++) {
            int button = (temp % 4) + 1;
            temp /= 4;
            applyButton(bulbs, n, button);
        }
        
        char state[1000] = "";
        for (int i = 0; i < n; i++) {
            char digit[2];
            sprintf(digit, "%d", bulbs[i]);
            strcat(state, digit);
        }
        
        int found = 0;
        for (int i = 0; i < stateCount; i++) {
            if (strcmp(states[i], state) == 0) {
                found = 1;
                break;
            }
        }
        
        if (!found) {
            strcpy(states[stateCount], state);
            stateCount++;
        }
        
        free(bulbs);
    }
    
    return stateCount;
}

int main() {
    int n, presses;
    scanf("%d %d", &n, &presses);
    printf("%d\n", flipLights(n, presses));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^presses × n)

4^presses possible sequences, each taking O(n) time to simulate

✓ Linear Growth

Space Complexity

O(4^presses × n)

Storage for all possible states, each requiring O(n) space

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000
0 ≤ presses ≤ 1000
All bulbs start in the ON state
Button presses must be exactly equal to the given number

23.4K Views

Medium Frequency

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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler