Prison Cells After N Days

Prison Cells After N Days - Problem

There are 8 prison cells in a row and each cell is either occupied or vacant.

Each day, whether the cell is occupied or vacant changes according to the following rules:

If a cell has two adjacent neighbors that are both occupied or both vacant, then the cell becomes occupied.
Otherwise, it becomes vacant.

Note: Because the prison is a row, the first and last cells in the row can't have two adjacent neighbors.

You are given an integer array cells where cells[i] == 1 if the i^th cell is occupied and cells[i] == 0 if the i^th cell is vacant, and you are given an integer n.

Return the state of the prison after n days (i.e., n such changes described above).

Input & Output

Example 1 — Basic Transformation

$ Input: cells = [0,1,0,1,1,0,0,1], n = 7

› Output: [0,0,0,0,0,0,0,0]

💡 Note: After 7 days of applying the transformation rules, all cells become vacant. The transformation quickly converges to all zeros for this initial state.

Example 2 — Single Day

$ Input: cells = [1,0,0,1,0,0,1,0], n = 1

› Output: [0,0,0,1,0,0,1,0]

💡 Note: After one day: cell[3] becomes 1 (neighbors 0,0 are same), cell[6] becomes 1 (neighbors 0,0 are same), all other middle cells become 0 due to different neighbors, and edge cells become 0.

Example 3 — No Change Needed

$ Input: cells = [1,1,1,1,1,1,1,1], n = 0

› Output: [1,1,1,1,1,1,1,1]

💡 Note: When n = 0, no days pass so the cells remain unchanged from the initial state.

Constraints

cells.length == 8
cells[i] is either 0 or 1
1 ≤ n ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is that prison cell states form cycles due to limited state space. The optimal approach uses cycle detection to avoid simulating all n days. Best approach is cycle detection with Time: O(1), Space: O(1).

Common Approaches

✓ Brute Force Simulation

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

For each day from 1 to n, create a new state by applying the neighbor rules to each cell. First and last cells always become vacant since they can't have two neighbors.

Cycle Detection

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

Since there are only 2^6 = 64 possible states for the middle 6 cells (first and last are always 0), the pattern must repeat within 14 days maximum. We detect the cycle and use modular arithmetic to find the final state.

Brute Force Simulation — Algorithm Steps

Apply transformation rules for each day
First and last cells always become 0
Middle cells check if both neighbors are same

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Starting configuration of 8 cells

Apply Rules

Transform each cell based on neighbors

Next Day

New state after one day

Code -

solution.c — C

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

void solution(int* cells, int n) {
    for (int day = 0; day < n; day++) {
        int newCells[8] = {0};
        for (int i = 1; i < 7; i++) {
            if (cells[i-1] == cells[i+1]) {
                newCells[i] = 1;
            } else {
                newCells[i] = 0;
            }
        }
        memcpy(cells, newCells, sizeof(newCells));
    }
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[100];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int cells[8];
    char* token = strtok(line, "[,]");
    int i = 0;
    while (token != NULL && i < 8) {
        cells[i] = atoi(token);
        token = strtok(NULL, "[,]");
        i++;
    }
    
    int n;
    scanf("%d", &n);
    
    solution(cells, n);
    
    printf("[");
    for (int i = 0; i < 8; i++) {
        printf("%d", cells[i]);
        if (i < 7) printf(",");
    }
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We simulate n days, each taking O(8) = O(1) time

✓ Linear Growth

Space Complexity

O(1)

Only use temporary array of fixed size 8

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler