Day 24.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 24\n",
    "\n",
    "https://adventofcode.com/2020/day/24"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import collections\n",
    "import enum\n",
    "import operator\n",
    "import typing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import aocd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "TEST_DATA = \"\"\"\n",
    "sesenwnenenewseeswwswswwnenewsewsw\n",
    "neeenesenwnwwswnenewnwwsewnenwseswesw\n",
    "seswneswswsenwwnwse\n",
    "nwnwneseeswswnenewneswwnewseswneseene\n",
    "swweswneswnenwsewnwneneseenw\n",
    "eesenwseswswnenwswnwnwsewwnwsene\n",
    "sewnenenenesenwsewnenwwwse\n",
    "wenwwweseeeweswwwnwwe\n",
    "wsweesenenewnwwnwsenewsenwwsesesenwne\n",
    "neeswseenwwswnwswswnw\n",
    "nenwswwsewswnenenewsenwsenwnesesenew\n",
    "enewnwewneswsewnwswenweswnenwsenwsw\n",
    "sweneswneswneneenwnewenewwneswswnese\n",
    "swwesenesewenwneswnwwneseswwne\n",
    "enesenwswwswneneswsenwnewswseenwsese\n",
    "wnwnesenesenenwwnenwsewesewsesesew\n",
    "nenewswnwewswnenesenwnesewesw\n",
    "eneswnwswnwsenenwnwnwwseeswneewsenese\n",
    "neswnwewnwnwseenwseesewsenwsweewe\n",
    "wseweeenwnesenwwwswnew\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HexCubeCoordinates(enum.Enum):\n",
    "    \"\"\"See cube coordinates:\n",
    "        https://www.redblobgames.com/grids/hexagons/#coordinates\n",
    "    \"\"\"\n",
    "    E = (1, -1, 0)\n",
    "    SE = (0, -1, 1)\n",
    "    SW = (-1, 0, 1)\n",
    "    W = (-1, 1, 0)\n",
    "    NW = (0, 1, -1)\n",
    "    NE = (1, 0, -1)\n",
    "    \n",
    "    @classmethod\n",
    "    def from_str(cls, s):\n",
    "        try:\n",
    "            return cls[s.upper()]\n",
    "        except KeyError:\n",
    "            return None\n",
    "        \n",
    "    def move(self, gridpoint):\n",
    "        return tuple(map(operator.add, gridpoint, self.value))\n",
    "    \n",
    "    @staticmethod\n",
    "    def adjacent(gridpoint):\n",
    "        for direction in HexCubeCoordinates:\n",
    "            yield direction.move(gridpoint)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_directions(line: str):\n",
    "    move = ''\n",
    "    for c in line:\n",
    "        move += c\n",
    "        assert len(move) <= 2\n",
    "        direction = HexCubeCoordinates.from_str(move)\n",
    "        if direction is not None:\n",
    "            yield direction\n",
    "            move = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_data(data):\n",
    "    for line in data.splitlines():\n",
    "        if line:\n",
    "            yield [d for d in parse_directions(line)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution to Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def flip(tile, flipped_tiles):\n",
    "    if tile in flipped_tiles:\n",
    "        flipped_tiles.discard(tile)\n",
    "    else:\n",
    "        flipped_tiles.add(tile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_moves(data):\n",
    "    flipped_tiles = set()\n",
    "    for line in parse_data(data):\n",
    "        tile = (0, 0, 0)\n",
    "        for direction in line:\n",
    "            tile = direction.move(tile)\n",
    "        flip(tile, flipped_tiles)\n",
    "    return flipped_tiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "269"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flipped_tiles = process_moves(aocd.get_data(day=24, year=2020))\n",
    "# flipped_tiles = process_moves(TEST_DATA)\n",
    "len(flipped_tiles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution to Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_flipped_neighbors(tile, flipped_tiles):\n",
    "    return sum(\n",
    "        neighbor in flipped_tiles\n",
    "        for neighbor in HexCubeCoordinates.adjacent(tile)\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def flipped_tiles_to_flip(flipped_tiles):\n",
    "    for tile in flipped_tiles:\n",
    "        n = count_flipped_neighbors(tile, flipped_tiles)\n",
    "        if n == 0 or n > 2:\n",
    "            yield tile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_unflipped_candidates(flipped_tiles):\n",
    "    return set([\n",
    "        neighbor\n",
    "        for tile in flipped_tiles\n",
    "        for neighbor in HexCubeCoordinates.adjacent(tile)\n",
    "        if neighbor not in flipped_tiles\n",
    "    ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def unflipped_tiles_to_flip(flipped_tiles):\n",
    "    for tile in get_unflipped_candidates(flipped_tiles):\n",
    "        n = count_flipped_neighbors(tile, flipped_tiles)\n",
    "        if n == 2:\n",
    "            yield tile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def turn(flipped_tiles):\n",
    "    new_tiles = flipped_tiles.copy()\n",
    "    for tile in flipped_tiles_to_flip(flipped_tiles):\n",
    "        flip(tile, new_tiles)\n",
    "    for tile in unflipped_tiles_to_flip(flipped_tiles):\n",
    "        flip(tile, new_tiles)\n",
    "    return new_tiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "part2 = flipped_tiles.copy()\n",
    "for _ in range(100):\n",
    "    part2 = turn(part2)\n",
    "len(part2)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}