Desafio de autômatos celulares infinitos cúbicos 3D

const FACE = 1 << 16; // The start index for counters that relate to 2D faces
const EDGE = FACE + (1 << 8); // The start index for counters that relate to 1D edges
const POINT = EDGE + (1 << 4); // The start index for the counters that relate to the 0D point
const colorNames = ["PINK", "RED", "GREEN", "BLUE"];

function sumColors(cube, ...corners) {
    // Extract the colors for the given corners from the encoded cube and sum them modulo 4
    let result = 0;
    for (const corner of corners) {
        result += cube >> (corner * 2);
    }
    return result & 3;
}

function shape(colors, ...indices) {
    // Take the colors at the given indices of the array and encode those in a single integer (2 bits per color)
    let result = 0;
    for (let j = indices.length - 1; j >= 0; j--) {
        result = (result << 2) | colors[indices[j]];
    }
    // If there are just 2 indices, the two colors are the endpoints of an edge
    if (indices.length == 2) result |= EDGE;
    // If there are 4 indices, the four colors are the corners of a face
    else if (indices.length == 4) result |= FACE;
    // Otherwise there are 8 indices, the 8 corners of a cube
    return result;
}

function report(step, counters) {
    // aggregate the counters per the color of the first corner in each shape
    const results = [0n, 0n, 0n, 0n];
    for (let state = 0; state < counters.length; state++) {
        const count = counters[state];
        results[state & 3] += count;
    }

    console.log(`STEP ${step}: ${results[0]} times ${colorNames[0]}, ${results[1]} times ${colorNames[1]}, ${results[2]} times ${colorNames[2]}, ${results[3]} times ${colorNames[3]}`);
}

function solve(cube) {
    let colors = [];
    // flatten the given 3D cube to a flat array of colors
    for (let face of cube) {
        for (let edge of face) {
            for (let color of edge) {
                colors.push(color);
            }
        }
    }
    // Create a counter for every possible cube (in terms of colors), every face and every edge
    const counters = Array(POINT + 4).fill(0n); // The n-suffix denotes BigInteger type
    // Initialise the counters with the cube we start with:
    counters[shape(colors, 0, 1, 2, 3, 4, 5, 6, 7)] += 1n; // We have one cube
    // Faces on the "far" side of X, Y and Z directions
    counters[shape(colors, 1, 3, 5, 7)] += 1n;
    counters[shape(colors, 2, 3, 6, 7)] += 1n;
    counters[shape(colors, 4, 5, 6, 7)] += 1n;
    // Edges on the "far" side of X, Y and Z directions
    counters[shape(colors, 3, 7)] += 1n;
    counters[shape(colors, 5, 7)] += 1n;
    counters[shape(colors, 6, 7)] += 1n;
    // The furthest color:
    counters[POINT + colors.at(-1)] = 1n;
    // Output the counters for the initial state
    report(0, counters);
    // loop to next generations
    for (let step = 1; step <= 19; step++) {
        const copy = [...counters];
        for (let state = 0; state < counters.length - 4; state++) {
            const count = copy[state];
            if (!count) continue;
            counters[state] -= count;
            const cube3x3x3 = [
                sumColors(state, 0),
                sumColors(state, 0, 1),
                sumColors(state, 1),
                sumColors(state, 0, 2),
                sumColors(state, 0, 1, 2, 3),
                sumColors(state, 1, 3),
                sumColors(state, 2),
                sumColors(state, 2, 3),
                sumColors(state, 3),
                sumColors(state, 0, 4),
                sumColors(state, 0, 1, 4, 5),
                sumColors(state, 1, 5),
                sumColors(state, 0, 2, 4, 6),
                sumColors(state, 0, 1, 2, 3, 4, 5, 6, 7),
                sumColors(state, 1, 3, 5, 7),
                sumColors(state, 2, 6),
                sumColors(state, 2, 3, 6, 7),
                sumColors(state, 3, 7),
                sumColors(state, 4),
                sumColors(state, 4, 5),
                sumColors(state, 5),
                sumColors(state, 4, 6),
                sumColors(state, 4, 5, 6, 7),
                sumColors(state, 5, 7),
                sumColors(state, 6),
                sumColors(state, 6, 7),
                sumColors(state, 7),
            ];
            if ((state & EDGE) === EDGE) { // Treat as edge
                counters[shape(cube3x3x3, 0, 1)] += count;
                counters[shape(cube3x3x3, 1, 2)] += count;
            } else if ((state & FACE) === FACE) { // Treat as face
                counters[shape(cube3x3x3, 0, 1, 3, 4)] += count;
                counters[shape(cube3x3x3, 1, 2, 4, 5)] += count;
                counters[shape(cube3x3x3, 3, 4, 6, 7)] += count;
                counters[shape(cube3x3x3, 4, 5, 7, 8)] += count;
            } else { // Cube -- normal case
                counters[shape(cube3x3x3, 0, 1, 3, 4, 9, 10, 12, 13)] += count; 
                counters[shape(cube3x3x3, 1, 2, 4, 5, 10, 11, 13, 14)] += count; 
                counters[shape(cube3x3x3, 3, 4, 6, 7, 12, 13, 15, 16)] += count; 
                counters[shape(cube3x3x3, 4, 5, 7, 8, 13, 14, 16, 17)] += count; 
                counters[shape(cube3x3x3, 9, 10, 12, 13, 18, 19, 21, 22)] += count; 
                counters[shape(cube3x3x3, 10, 11, 13, 14, 19, 20, 22, 23)] += count; 
                counters[shape(cube3x3x3, 12, 13, 15, 16, 21, 22, 24, 25)] += count; 
                counters[shape(cube3x3x3, 13, 14, 16, 17, 22, 23, 25, 26)] += count; 
            }
        }
        report(step, counters);
    }
}

const PINK = 0;
const RED = 1;
const GREEN = 2;
const BLUE = 3;
// The cube given as example in the question:
const cube = [[[RED, PINK], [GREEN, GREEN]],[[BLUE, RED], [PINK, RED]]];
solve(cube);