Prison Cells After N Days - Practice Coding Problems

Prison Cells After N Days - Problem

Prison Cells After N Days

Imagine a prison with 8 cells in a row, where each cell is either occupied (1) or vacant (0). Every day, the prison undergoes a transformation based on a simple rule:

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

Important: The first and last cells (positions 0 and 7) can't have two adjacent neighbors, so they always become vacant after the first day.

Goal: Given the initial state of prison cells and a number n, determine what the prison looks like after n days of transformation.

Example: If cells = [0,1,0,1,1,0,0,1] and n = 7, you need to simulate 7 days of changes and return the final state.

Input & Output

example_1.py — Basic Simulation

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

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

💡 Note: After 7 days of applying the transformation rules, the prison reaches this state. Day 7 happens to be the same as Day 1 due to the cyclic nature.

example_2.py — No Change Case

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

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

💡 Note: Even with a billion days, we can efficiently compute the result using cycle detection. The pattern repeats every 14 days in this case.

example_3.py — Edge Case

$ 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 transformations occur, so we return the original state unchanged.

Constraints

cells.length == 8
cells[i] is either 0 or 1
1 ≤ n ≤ 10⁹
Note: The first and last cells always become 0 after the first day

Visualization

Tap to expand

Understanding the Visualization

Initial Configuration

Start with 8 prison cells, each either occupied (1) or vacant (0)

Apply Transformation Rules

For each day, cells become occupied if their neighbors match, vacant otherwise

Detect Patterns

Track all seen states - when we see a repeat, we've found a cycle

Skip to the Answer

Use the cycle to jump directly to day n without simulating every day

Key Takeaway

🎯 Key Insight: Since we only have 8 cells with binary values, there are at most 2^8 = 256 possible states. The cellular automaton must enter a cycle, allowing us to skip ahead using modular arithmetic and solve in O(1) time!

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 15

The optimal solution uses cycle detection to avoid simulating all n days. Since there are only 8 cells with binary values, the cellular automaton must enter a cycle within 2⁸ = 256 days. We detect when a state repeats and use modular arithmetic to determine the final state, achieving O(1) time complexity for any value of n.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n)	O(1)	Simulate each day one by one for n days
Cycle Detection (Optimal)	O(1)	O(1)	Detect when the pattern repeats and skip redundant calculations

Brute Force Simulation — Algorithm Steps

Create a copy of the current state
For each cell (except first and last), check its neighbors
Apply the rule: if neighbors are same, cell becomes occupied (1), else vacant (0)
First and last cells always become vacant (0)
Repeat for n days

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with the given prison cell configuration

Apply Rules

For each cell, check if neighbors are the same

Update State

Create new state based on the rules

Repeat

Continue for n days

Code -

solution.c — C

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

int* prisonAfterNDays(int* cells, int cellsSize, int n, int* returnSize) {
    *returnSize = 8;
    if (n == 0) {
        int* result = (int*)malloc(8 * sizeof(int));
        memcpy(result, cells, 8 * sizeof(int));
        return result;
    }
    
    int* current = (int*)malloc(8 * sizeof(int));
    memcpy(current, cells, 8 * sizeof(int));
    
    for (int day = 0; day < n; day++) {
        int newCells[8] = {0};
        for (int i = 1; i < 7; i++) {  // Skip first and last cells
            if (current[i-1] == current[i+1]) {  // Neighbors are same
                newCells[i] = 1;
            } else {
                newCells[i] = 0;
            }
        }
        memcpy(current, newCells, 8 * sizeof(int));
    }
    
    return current;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We simulate n days, and each day takes O(8) = O(1) time to process 8 cells

✓ Linear Growth

Space Complexity

O(1)

We only need constant extra space to store the next state

✓ Linear Space

89.2K Views

Medium Frequency

~25 min Avg. Time

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