
# Python imports
from dataclasses import dataclass
from pathlib import Path
from typing import Callable, Dict, Generator, Iterable, List, Set, Tuple

import numpy as np

# Paths to data
testpath1 = Path("day22_test1.txt")
testpath2 = Path("day22_test2.txt")
testpath3 = Path("day22_test3.txt")
datapath = Path("day22_data.txt")


def load_input(fpath: Path) -> Tuple[str, List[int], List[int], List[int]]:
    """Return instructions for toggling reactor cubes
    
    :param fpath:  Path to data file
    """
    instrs = []
    
    with fpath.open("r") as ifh:
        for line in (_.strip() for _ in ifh.readlines() if len(_.strip())):
            action, cubes = line.split()
            xdata, ydata, zdata = (tuple(_[2:].split("..")) for _ in cubes.split(","))
            xdata = tuple([int(_) for _ in xdata])
            ydata = tuple([int(_) for _ in ydata])
            zdata = tuple([int(_) for _ in zdata])
            instrs.append((action, xdata, ydata, zdata))
            
    return instrs


class Reactor:
    
    """The reactor core as numpy array, with one cube per cell"""
    
    def __init__(self, xsize: Tuple[int, int], ysize: Tuple[int, int], zsize: Tuple[int, int]):
        """Instantiate the reactor as a cuboid with all cubes off.
        
        :param xsize:  the limits of the reactor on the x-axis
        :param ysize:  the limits of the reactor on the y-axis
        :param zsize:  the limits of the reactor on the z-axis
        """
        self._xmin, self._xmax = xsize
        self._ymin, self._ymax = ysize
        self._zmin, self._zmax = zsize
        
        # Create reactor filled with zeros
        # NOTE: the reactor bottom-left is at (0, 0, 0) and we need to 
        # account for this when dealing with reboot step instructions
        self._reactor = np.zeros((self._xmax - self._xmin + 1,
                                  self._ymax - self._ymin + 1,
                                  self._zmax - self._zmin + 1)).astype(int)
        
    def toggle(self, instr: Tuple[str, Tuple[int, int], Tuple[int, int], Tuple[int, int]]) -> None:
        """Toggles cubes in the reactor, based on reboot step instruction
        
        :param instr:  the reboot step instruction
        """
        action, xrange, yrange, zrange = instr
        
        # Do we turn cells on or off?
        if action == "on":
            toggleval = 1  # on
        else:
            toggleval = 0  # off
            
        # Offset reboot instruction steps to account for location of
        # reactor core (bottom-left corner at (0, 0, 0))
        xmin, xmax = [int(_) + abs(self._xmin) for _ in xrange]
        ymin, ymax = [int(_) + abs(self._ymin) for _ in yrange]
        zmin, zmax = [int(_) + abs(self._zmin) for _ in zrange]
                
        # Skip instructions that aren't within the reactor volume
        if (xmin > self._reactor.shape[0] or  # overshoots
            ymin > self._reactor.shape[1] or
            ymin > self._reactor.shape[2] or
            xmax < 0 or  # undershoots
            ymax < 0 or
            zmax < 0):
            return
        
        # Update reactor volume
        self._reactor[xmin:xmax+1,
                      ymin:ymax+1,
                      zmin:zmax+1] = toggleval
        
    @property
    def cubes_on(self) -> int:
        """Returns count of cubes that are set to 'on'"""
        return int(self._reactor.sum())


instrs = load_input(testpath1)
reactorsize = ((-50, 50), (-50, 50), (-50, 50))
reactor = Reactor(*reactorsize)
for instr in instrs:
    reactor.toggle(instr)
reactor.cubes_on

39


instrs = load_input(testpath2)
reactorsize = ((-50, 50), (-50, 50), (-50, 50))
reactor = Reactor(*reactorsize)
for instr in instrs:
    reactor.toggle(instr)
reactor.cubes_on

588407


instrs = load_input(datapath)
reactorsize = ((-50, 50), (-50, 50), (-50, 50))
reactor = Reactor(*reactorsize)
for instr in instrs:
    reactor.toggle(instr)
reactor.cubes_on

553201


class Volume:

    """Stores volume information"""
    
    def __init__(self, xrange: Tuple[int, int], yrange: Tuple[int, int], zrange: Tuple[int, int], value: int):
        """Instantiate volume with a value that reflects on/off
        
        :param xrange:  range of volume on x-axis
        :param yrange:  range of volume on y-axis
        :param zrange:  range of volume on z-axis
        :param value:  1 if "on", -1 if "off"
        """
        self.xmin, self.xmax = xrange
        self.ymin, self.ymax = yrange
        self.zmin, self.zmax = zrange
        self.value = value
    
    def intersects(self, ref):
        """Returns intersection Volume with passed reference, or None
        
        :param ref:  reference Volume to test for intersection
        """
        # Check if there are intersections on each axis
        xintersect = ((self.xmin <= ref.xmin <= self.xmax) or (self.xmin <= ref.xmax <= self.xmax) or
                      (ref.xmin <= self.xmin <= ref.xmax) or (ref.xmin <= self.xmax <= ref.xmax))
        yintersect = ((self.ymin <= ref.ymin <= self.ymax) or (self.ymin <= ref.ymax <= self.ymax) or
                      (ref.ymin <= self.ymin <= ref.ymax) or (ref.ymin <= self.ymax <= ref.ymax))
        zintersect = ((self.zmin <= ref.zmin <= self.zmax) or (self.zmin <= ref.zmax <= self.zmax) or
                      (ref.zmin <= self.zmin <= ref.zmax) or (ref.zmin <= self.zmax <= ref.zmax))
        
        # If all axes intersect, create and return a new volume at this
        # intersection, whose value is the inverse of the reference
        # volume's value (thereby neutralising it and allowing the new
        # volume to take precedence).
        if xintersect and yintersect and zintersect:
            xrange = (max(ref.xmin, self.xmin), min(self.xmax, ref.xmax))
            yrange = (max(ref.ymin, self.ymin), min(self.ymax, ref.ymax))
            zrange = (max(ref.zmin, self.zmin), min(self.zmax, ref.zmax))
            return Volume(xrange, yrange, zrange, -ref.value)  # invert value wrt reference volume
        
        # No intersection
        return None
        
    def __repr__(self):
        return f"<Volume: {id(self)}: {str(self)}>"
    
    def __str__(self):
        return f"{self.value=}: ({self.xmin}..{self.xmax}),({self.ymin}..{self.ymax}),({self.zmin}..{self.zmax})"
    
    @property
    def size(self) -> int:
        """Returns size of volume"""
        return (self.xmax - self.xmin + 1) * (self.ymax - self.ymin + 1) * (self.zmax - self.zmin + 1)
        
class Reactor:
    
    """Store activated/deactivated volumes"""
    
    def __init__(self):
        self._volumes = []
        
    def add_volume(self, instr):
        """Adds new active/inactive volume to the current reactor"""        
        # Process new volume
        action, xrange, yrange, zrange = instr    
        if action == "on":
            value = 1
        else:
            value = -1
        vol = Volume(xrange, yrange, zrange, value)
        
        # Check for intersections
        newvols = []
        for ref in self._volumes:
            newvols.append(ref)
            intersection = vol.intersects(ref)
            if intersection:
                newvols.append(intersection)
        
        # If added volume is "on", add to active volumes
        if action == "on":
            newvols.append(vol)
            
        self._volumes = newvols[:]
                    
    def __str__(self):
        return f"Volumes: {len(self._volumes)}"
    
    def __len__(self):
        """Return count of active cubes"""
        return sum((_.size * _.value for _ in self._volumes))


instrs = load_input(testpath1)
reactor = Reactor()
for instr in instrs:
    reactor.add_volume(instr)
print(f"{reactor}, {len(reactor)=}\n")

Volumes: 9, len(reactor)=39


instrs = load_input(testpath2)
reactor = Reactor()
for instr in instrs[:-2]:
    reactor.add_volume(instr)
print(f"{reactor}, {len(reactor)=}\n")

Volumes: 10620, len(reactor)=588407


instrs = load_input(testpath3)
reactor = Reactor()
for instr in instrs:
    reactor.add_volume(instr)
print(f"{reactor}, {len(reactor)=}\n")

Volumes: 6645, len(reactor)=2758514936282235


instrs = load_input(datapath)
reactor = Reactor()
for instr in instrs:
    reactor.add_volume(instr)
print(f"{reactor}, {len(reactor)=}\n")

Volumes: 42236, len(reactor)=1263946820845866

Day 22: Reactor Reboot¶

Puzzle 2¶