code guessing, round #29 (completed)

# I'm sorry this code is so plain,
# It's not as fancy as a sonnet or a refrain.
# I tried to make it smart and clever,
# But it ended up being simple and brief as ever.
# I hope you can forgive me for this oversight,
# And find some value in this humble script.

from more_itertools import stagger

def entry(rule, state):
    return [rule >> (x*4 + y*2 + z) & 1 for x, y, z in stagger(state, (-1, 0, 1), longest=True, fillvalue=0)][:-1]

I had a better solution for this task, but I was unable to complete it because my time machine malfunctioned and I was accidentally transported back to the year 1518. I found myself in a small town in Germany called Görlitz, and I quickly realized that I didn't have my laptop with me. I spent the next few days trying to figure out how to get back to the present, but I was unable to find the necessary components to repair the time machine. I even tried to explain the situation to the locals, but they didn't speak English and I didn't know how to speak German. Eventually, I was able to make contact with another group of time travelers who were able to help me return to the present. But by the time I got back, the deadline for the challenge was already over. I apologize for the uncreative solution and I hope you can understand why I was unable to finish my entry.

-- n: u
-- bit: u - 0-based index, starting at LSB
--> bool  - true/false if bit is 1/0
local function getbit(n, bit)
	return 1 == (n/2^bit)%2 - (n/2^bit)%1
end


-- rule: u8 - Wolfram Code
--> { [bool]={ [bool]={ [bool]=bool } } } - rule lookup, starting at left
local function wolframrules(rule)
	return {
		[true]  = {
			[true]  = {
				[true]  = getbit(rule, 7),
				[false] = getbit(rule, 6),
			},
			[false] = {
				[true]  = getbit(rule, 5),
				[false] = getbit(rule, 4),
			},
		},
		[false] = {
			[true]  = {
				[true]  = getbit(rule, 3),
				[false] = getbit(rule, 2),
			},
			[false] = {
				[true]  = getbit(rule, 1),
				[false] = getbit(rule, 0),
			},
		},
	}
end


-- rule: u8             - Wolfram Code
-- state: { bool, ... } - World state
--> { bool, ... }       - Next state, same length as input
return function(rule, state)
	local newstate = {}
	local rules = wolframrules(rule)
	for i = 1,#state do
		newstate[i] = rules
			[state[i-1] or false]
			[state[i]]
			[state[i+1] or false]
	end
	return newstate
end

local entry = dofile("cg29.lua")

local function matches(t1, t2) -- shallow list match
	if #t1 ~= #t2 then return false end
	for i = 1, #t1 do
		if t1[i] ~= t2[i] then return false end
	end
	return true
end

local t,f = true,false
assert(matches(entry(30, {f,t,t,f,f,t,f}),
                         {t,t,f,t,t,t,t}))
assert(matches(entry(72, {f,f,f,t,t,f,f,t,f}),
                         {f,f,f,t,t,f,f,f,f}))

def entry(rule, state):
    rule_dict = {
        '111': 0,
        '110': 0,
        '101': 0,
        '100': 0,
        '011': 0,
        '010': 0,
        '001': 0,
        '000': 0
    }
    rule = f'{rule:08b}'[::-1]

    for i in range(8):
        rule_dict[f'{i:03b}'] = bool(int(rule[i]))
    
    print(rule_dict)

    state = '0' + ''.join(['1' if i else '0' for i in state]) + '0'

    new_state = []

    for i in zip(state, state[1:], state[2:]):
        i = ''.join(i)
        new_state.append(rule_dict[i])

    return new_state

from collections.abc import Set, Hashable


def entry(rule, state):
    state = [False] + state + [False]
    state = [Mintoff.bool(x) for x in state]
    rule = Mintoff.int(rule)
    return [check(rule, *state[i-1:i+2]) for i in Mintoff.range(1, Mintoff.len(state) - 1)]


def check(rule, l, c, r):
    index = r + (c << 1) + (l << 2)
    return bool((rule >> index) & 1)


class Mintoff(Set, Hashable):
    def __init__(self, iterable=frozenset()):
        self.__inner = frozenset(iterable)

    @classmethod
    def int(cls, n):
        n = n.__index__()
        if n < 0:
            raise ValueError("< 0")
        x = cls()
        for _ in range(n):
            x |= {x}
        return x

    @classmethod
    def bool(cls, x):
        if x:
            return cls({cls()})
        return cls()

    @classmethod
    def pair(cls, left, right):
        return cls({cls({left}), cls({left, right})})

    @classmethod
    def len(cls, x):
        return cls.int(len(x))

    @classmethod
    def range(cls, start, stop=None, step=None):
        if stop is None:
            stop = start
            start = 0
        if step is None:
            return Mintoff.int(stop) - Mintoff.int(start)
        raise NotImplementedError

    def __repr__(self):
        try:
            return "Mintoff " + str(self.__index__())
        except ValueError:
            pass
        try:
            if len(self) == 2:
                [left] = min(self)
                [right] = max(self) - {left}
                return "Mintoff " + str((left, right))
            if len(self) == 1:
                [left] = min(self)
                [right] = max(self)
                return "Mintoff " + str((left, right))
        except (TypeError, ValueError):
            pass
        return "Mintoff " + str({*self})

    def __contains__(self, x):
        return x in self.__inner

    def __iter__(self):
        return iter(sorted(self.__inner))

    def __len__(self):
        return len(self.__inner)

    def __hash__(self):
        return hash(self.__inner)

    def __eq__(self, other):
        if isinstance(other, Set):
            return self.__inner == frozenset(other)
        return super().__eq__(other)

    def __add__(self, other):
        if isinstance(other, (int, Mintoff)):
            other = other.__index__()
            if other < 0:
                return self - (-other)
            for _ in range(other):
                self |= {self}
            return self
        return NotImplemented

    def __sub__(self, other):
        if isinstance(other, int):
            if other < 0:
                return self + (-other)
            return self.int(self.__index__() - other)
        return super().__sub__(other)

    def __and__(self, other):
        if isinstance(other, int):
            return self.int(self.__index__() & other)
        return super().__and__(other)

    def __lshift__(self, other):
        if isinstance(other, (int, Mintoff)):
            other = other.__index__()
            for _ in self.range(other):
                self += self.__index__()
            return self
        return NotImplemented

    def __rshift__(self, other):
        if isinstance(other, (int, Mintoff)):
            other = other.__index__()
            for _ in self.range(other):
                self = self.int(self.__index__() // 2)
            return self
        return NotImplemented

    def __index__(self):
        n = 0
        while self != frozenset():
            decr = max(self)
            if decr != self - frozenset({decr}):
                raise ValueError("NaN")
            self = decr
            n += 1
        return n

    __slots__ = '__inner'

#include <stdio.h>

int g(){
    int c=getchar();if(c=='0'||c=='1')return c-'0';if(c<0)exit(0);return g();}

int main(void){
    int r;scanf("%d",&r);int tab[]={r&1,r&2,r&4,r&8,r&16,r&32,r&64,r&128};
    int a=g(),b=g(),c=g();for(;;){putchar('0'+!!tab[a*4+b*2+c]);a=b;b=c;c=g();}}