adventofcode2020-notebook.ipynb

{
 "metadata": {
  "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-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3",
   "language": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# Advent of Code 2020"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "##  Day 1: \n",
    "### Report Repair\n",
    "### --- Part One ---\n",
    "After saving Christmas five years in a row, you've decided to take a vacation at a nice resort on a tropical island. Surely, Christmas will go on without you.\n",
    "\n",
    "The tropical island has its own currency and is entirely cash-only. The gold coins used there have a little picture of a starfish; the locals just call them stars. None of the currency exchanges seem to have heard of them, but somehow, you'll need to find fifty of these coins by the time you arrive so you can pay the deposit on your room.\n",
    "\n",
    "To save your vacation, you need to get all fifty stars by December 25th.\n",
    "\n",
    "Collect stars by solving puzzles. Two puzzles will be made available on each day in the Advent calendar; the second puzzle is unlocked when you complete the first. Each puzzle grants one star. Good luck!\n",
    "\n",
    "Before you leave, the Elves in accounting just need you to fix your expense report (your puzzle input); apparently, something isn't quite adding up.\n",
    "\n",
    "Specifically, they need you to find the two entries that sum to 2020 and then multiply those two numbers together.\n",
    "\n",
    "For example, suppose your expense report contained the following:\n",
    "\n",
    "- 1721\n",
    "- 979\n",
    "- 366\n",
    "- 299\n",
    "- 675\n",
    "- 1456\n",
    "\n",
    "In this list, the two entries that sum to 2020 are 1721 and 299. Multiplying them together produces 1721 * 299 = 514579, so the correct answer is 514579.\n",
    "\n",
    "Of course, your expense report is much larger. Find the two entries that sum to 2020; what do you get if you multiply them together?\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1st number = 1632, 2nd = 388, product = 633216\n1st number = 388, 2nd = 1632, product = 633216\n"
     ]
    }
   ],
   "source": [
    "f = open('d01p1-input.txt', 'r')\n",
    "data = f.readlines()\n",
    "data = list(map(int,data))\n",
    "for x in data:\n",
    "\tfor y in data:\n",
    "\t\tif x + y == 2020: print(f\"1st number = {x}, 2nd = {y}, product = {x*y}\")"
   ]
  },
  {
   "source": [
    "## Day 1:\n",
    "### Report Repair\n",
    "### --- Part Two ---\n",
    "\n",
    "The Elves in accounting are thankful for your help; one of them even offers you a starfish coin they had left over from a past vacation. They offer you a second one if you can find three numbers in your expense report that meet the same criteria.\n",
    "\n",
    "Using the above example again, the three entries that sum to 2020 are 979, 366, and 675. Multiplying them together produces the answer, 241861950.\n",
    "\n",
    "In your expense report, what is the product of the three entries that sum to 2020?\n",
    "\n",
    "\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1st number = 1607, 2nd = 196, 3rd = 217, product = 68348924\n",
      "1st number = 1607, 2nd = 217, 3rd = 196, product = 68348924\n",
      "1st number = 196, 2nd = 1607, 3rd = 217, product = 68348924\n",
      "1st number = 196, 2nd = 217, 3rd = 1607, product = 68348924\n",
      "1st number = 217, 2nd = 1607, 3rd = 196, product = 68348924\n",
      "1st number = 217, 2nd = 196, 3rd = 1607, product = 68348924\n"
     ]
    }
   ],
   "source": [
    "f = open('d01p1-input.txt', 'r')\n",
    "data = f.readlines()\n",
    "data = list(map(int,data))\n",
    "for x in data:\n",
    "\tfor y in data:\n",
    "\t\tfor z in data:\n",
    "\t\t\tif x + y + z == 2020: \n",
    "\t\t\t\tprint(f\"1st number = {x}, 2nd = {y}, 3rd = {z}, product = {x*y*z}\")\n",
    "\t\t\t\tbreak\n"
   ]
  },
  {
   "source": [
    "## Day 2: \n",
    "### --- Password Philosophy ---\n",
    "\n",
    "Your flight departs in a few days from the coastal airport; the easiest way down to the coast from here is via toboggan.\n",
    "\n",
    "The shopkeeper at the North Pole Toboggan Rental Shop is having a bad day. \"Something's wrong with our computers; we can't log in!\" You ask if you can take a look.\n",
    "\n",
    "Their password database seems to be a little corrupted: some of the passwords wouldn't have been allowed by the Official Toboggan Corporate Policy that was in effect when they were chosen.\n",
    "\n",
    "To try to debug the problem, they have created a list (your puzzle input) of passwords (according to the corrupted database) and the corporate policy when that password was set.\n",
    "\n",
    "For example, suppose you have the following list:\n",
    "\n",
    "- 1-3 a: abcde\n",
    "- 1-3 b: cdefg\n",
    "- 2-9 c: ccccccccc\n",
    "\n",
    "Each line gives the password policy and then the password. The password policy indicates the lowest and highest number of times a given letter must appear for the password to be valid. For example, 1-3 a means that the password must contain a at least 1 time and at most 3 times.\n",
    "\n",
    "In the above example, 2 passwords are valid. The middle password, cdefg, is not; it contains no instances of b, but needs at least 1. The first and third passwords are valid: they contain one a or nine c, both within the limits of their respective policies.\n",
    "\n",
    "How many passwords are valid according to their policies?\n",
    "\n",
    "To begin, get your puzzle input."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "422 valid passwords\n"
     ]
    }
   ],
   "source": [
    "f = open('d02-input.txt', 'r')\n",
    "data = f.readlines()\n",
    "data = [x.strip().split() for x in data]\n",
    "valid = 0\n",
    "for row in range(len(data)):\n",
    "\t# min value = data[row][0].split('-')[0]\n",
    "\t# max value = data[row][0].split('-')[1]\n",
    "\t# character = data[row][1].split(':')[0]\n",
    "\t# password to test = data[row][2]\n",
    "\t# number occurances of letter = data[row][2].count(data[row][1].split(':')[0])\n",
    "\tmax = int(data[row][0].split('-')[1])\n",
    "\tmin = int(data[row][0].split('-')[0])\n",
    "\tchar_count = data[row][2].count(data[row][1].split(':')[0])\n",
    "\tvalid += (char_count >= min) * (char_count <= max)\n",
    "print(valid,\"valid passwords\")"
   ]
  },
  {
   "source": [
    "## D2:\n",
    "### --- Password Philosophy ---\n",
    "### --- Part Two ---\n",
    "\n",
    "While it appears you validated the passwords correctly, they don't seem to be what the Official Toboggan Corporate Authentication System is expecting.\n",
    "\n",
    "The shopkeeper suddenly realizes that he just accidentally explained the password policy rules from his old job at the sled rental place down the street! The Official Toboggan Corporate Policy actually works a little differently.\n",
    "\n",
    "Each policy actually describes two positions in the password, where 1 means the first character, 2 means the second character, and so on. (Be careful; Toboggan Corporate Policies have no concept of \"index zero\"!) Exactly one of these positions must contain the given letter. Other occurrences of the letter are irrelevant for the purposes of policy enforcement.\n",
    "\n",
    "Given the same example list from above:\n",
    "\n",
    "- 1-3 a: abcde is valid: position 1 contains a and position 3 does not.\n",
    "- 1-3 b: cdefg is invalid: neither position 1 nor position 3 contains b.\n",
    "- 2-9 c: ccccccccc is invalid: both position 2 and position 9 contain c.\n",
    "\n",
    "How many passwords are valid according to the new interpretation of the policies?"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "451 valid passwords\n"
     ]
    }
   ],
   "source": [
    "f = open('d02-input.txt', 'r')\n",
    "data = f.readlines()\n",
    "data = [x.strip().split() for x in data]\n",
    "valid = 0\n",
    "for row in range(len(data)):\n",
    "\t# char_pos_1 = data[row][0].split('-')[0]\n",
    "\t# char_pos_2 = data[row][0].split('-')[1]\n",
    "\t# character = data[row][1].split(':')[0]\n",
    "\t# password to test = data[row][2]\n",
    "\t# number occurances of letter = data[row][2].count(data[row][1].split(':')[0])\n",
    "\ttest_char = data[row][1].split(':')[0]\n",
    "\tchar_pos_2 = int(data[row][0].split('-')[1]) - 1\n",
    "\tchar_pos_1 = int(data[row][0].split('-')[0]) - 1\n",
    "\t# valid =+ (data[row][2][char_pos_1] == test_char) * (data[row][2][char_pos_2] == test_char)\n",
    "\tif (data[row][2][char_pos_1] == test_char and data[row][2][char_pos_2] != test_char) or (data[row][2][char_pos_1] != test_char and data[row][2][char_pos_2] == test_char):\n",
    "\t\tvalid = valid + 1\n",
    "print(valid,\"valid passwords\")"
   ]
  },
  {
   "source": [
    "## Day 3: \n",
    "### --- Toboggan Trajectory ---\n",
    "\n",
    "With the toboggan login problems resolved, you set off toward the airport. While travel by toboggan might be easy, it's certainly not safe: there's very minimal steering and the area is covered in trees. You'll need to see which angles will take you near the fewest trees.\n",
    "\n",
    "Due to the local geology, trees in this area only grow on exact integer coordinates in a grid. You make a map (your puzzle input) of the open squares (.) and trees (#) you can see. For example:\n",
    "\n",
    "..##.......\n",
    "#...#...#..\n",
    ".#....#..#.\n",
    "..#.#...#.#\n",
    ".#...##..#.\n",
    "..#.##.....\n",
    ".#.#.#....#\n",
    ".#........#\n",
    "#.##...#...\n",
    "#...##....#\n",
    ".#..#...#.#\n",
    "\n",
    "These aren't the only trees, though; due to something you read about once involving arboreal genetics and biome stability, the same pattern repeats to the right many times:\n",
    "\n",
    "..##.........##.........##.........##.........##.........##.......  --->\n",
    "#...#...#..#...#...#..#...#...#..#...#...#..#...#...#..#...#...#..\n",
    ".#....#..#..#....#..#..#....#..#..#....#..#..#....#..#..#....#..#.\n",
    "..#.#...#.#..#.#...#.#..#.#...#.#..#.#...#.#..#.#...#.#..#.#...#.#\n",
    ".#...##..#..#...##..#..#...##..#..#...##..#..#...##..#..#...##..#.\n",
    "..#.##.......#.##.......#.##.......#.##.......#.##.......#.##.....  --->\n",
    ".#.#.#....#.#.#.#....#.#.#.#....#.#.#.#....#.#.#.#....#.#.#.#....#\n",
    ".#........#.#........#.#........#.#........#.#........#.#........#\n",
    "#.##...#...#.##...#...#.##...#...#.##...#...#.##...#...#.##...#...\n",
    "#...##....##...##....##...##....##...##....##...##....##...##....#\n",
    ".#..#...#.#.#..#...#.#.#..#...#.#.#..#...#.#.#..#...#.#.#..#...#.#  --->\n",
    "\n",
    "You start on the open square (.) in the top-left corner and need to reach the bottom (below the bottom-most row on your map).\n",
    "\n",
    "The toboggan can only follow a few specific slopes (you opted for a cheaper model that prefers rational numbers); start by counting all the trees you would encounter for the slope right 3, down 1:\n",
    "\n",
    "From your starting position at the top-left, check the position that is right 3 and down 1. Then, check the position that is right 3 and down 1 from there, and so on until you go past the bottom of the map.\n",
    "\n",
    "The locations you'd check in the above example are marked here with O where there was an open square and X where there was a tree:\n",
    "\n",
    "..##.........##.........##.........##.........##.........##.......  --->\n",
    "#..O#...#..#...#...#..#...#...#..#...#...#..#...#...#..#...#...#..\n",
    ".#....X..#..#....#..#..#....#..#..#....#..#..#....#..#..#....#..#.\n",
    "..#.#...#O#..#.#...#.#..#.#...#.#..#.#...#.#..#.#...#.#..#.#...#.#\n",
    ".#...##..#..X...##..#..#...##..#..#...##..#..#...##..#..#...##..#.\n",
    "..#.##.......#.X#.......#.##.......#.##.......#.##.......#.##.....  --->\n",
    ".#.#.#....#.#.#.#.O..#.#.#.#....#.#.#.#....#.#.#.#....#.#.#.#....#\n",
    ".#........#.#........X.#........#.#........#.#........#.#........#\n",
    "#.##...#...#.##...#...#.X#...#...#.##...#...#.##...#...#.##...#...\n",
    "#...##....##...##....##...#X....##...##....##...##....##...##....#\n",
    ".#..#...#.#.#..#...#.#.#..#...X.#.#..#...#.#.#..#...#.#.#..#...#.#  --->\n",
    "\n",
    "In this example, traversing the map using this slope would cause you to encounter 7 trees.\n",
    "\n",
    "Starting at the top-left corner of your map and following a slope of right 3 and down 1, how many trees would you encounter?\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "209 trees encountered\n"
     ]
    }
   ],
   "source": [
    "f = open('d03-input.txt', 'r')\n",
    "data = f.readlines()\n",
    "trees = 0\n",
    "col = 0\n",
    "length = len(data[0])\n",
    "for row in range(len(data)):\n",
    "    if data[row][col] == \"#\":\n",
    "            trees += 1 \n",
    "    col = (col + 3) % (length-1)\n",
    "print(trees,\"trees encountered\")\n"
   ]
  },
  {
   "source": [
    "### --- Toboggan Trajectory ---\n",
    "### --- Part Two ---\n",
    "\n",
    "Time to check the rest of the slopes - you need to minimize the probability of a sudden arboreal stop, after all.\n",
    "\n",
    "Determine the number of trees you would encounter if, for each of the following slopes, you start at the top-left corner and traverse the map all the way to the bottom:\n",
    "\n",
    "-    Right 1, down 1.\n",
    "-    Right 3, down 1. (This is the slope you already checked.)\n",
    "-    Right 5, down 1.\n",
    "-    Right 7, down 1.\n",
    "-    Right 1, down 2.\n",
    "\n",
    "In the above example, these slopes would find 2, 7, 3, 4, and 2 tree(s) respectively; multiplied together, these produce the answer 336.\n",
    "\n",
    "What do you get if you multiply together the number of trees encountered on each of the listed slopes?\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "answer =  1574890240\n"
     ]
    }
   ],
   "source": [
    "f = open('d03-input.txt', 'r')\n",
    "data = f.readlines()\n",
    "length = len(data[0])\n",
    "routes = [(1,1),(3,1),(5,1),(7,1),(1,2)]\n",
    "answer = 0\n",
    "for route in range(len(routes)):\n",
    "    col = 0\n",
    "    trees = 0\n",
    "    for row in range(0, len(data), routes[route][1]):\n",
    "        if data[row][col] == \"#\":\n",
    "                trees += 1\n",
    "        col = (col + routes[route][0]) % (length-1)\n",
    "    if answer != 0:\n",
    "        answer = answer * trees\n",
    "    else:\n",
    "        answer = trees\n",
    "\n",
    "print(\"answer = \",answer)\n"
   ]
  },
  {
   "source": [
    "## Day 4: \n",
    "### --- Passport Processing ---\n",
    "\n",
    "You arrive at the airport only to realize that you grabbed your North Pole Credentials instead of your passport. While these documents are extremely similar, North Pole Credentials aren't issued by a country and therefore aren't actually valid documentation for travel in most of the world.\n",
    "\n",
    "It seems like you're not the only one having problems, though; a very long line has formed for the automatic passport scanners, and the delay could upset your travel itinerary.\n",
    "\n",
    "Due to some questionable network security, you realize you might be able to solve both of these problems at the same time.\n",
    "\n",
    "The automatic passport scanners are slow because they're having trouble detecting which passports have all required fields. The expected fields are as follows:\n",
    "\n",
    "- byr (Birth Year)\n",
    "- iyr (Issue Year)\n",
    "- eyr (Expiration Year)\n",
    "- hgt (Height)\n",
    "- hcl (Hair Color)\n",
    "- ecl (Eye Color)\n",
    "- pid (Passport ID)\n",
    "- cid (Country ID)\n",
    "Passport data is validated in batch files (your puzzle input). Each passport is represented as a sequence of key:value pairs separated by spaces or newlines. Passports are separated by blank lines.\n",
    "\n",
    "Here is an example batch file containing four passports:\n",
    "\n",
    "ecl:gry pid:860033327 eyr:2020 hcl:#fffffd\n",
    "byr:1937 iyr:2017 cid:147 hgt:183cm\n",
    "\n",
    "iyr:2013 ecl:amb cid:350 eyr:2023 pid:028048884\n",
    "hcl:#cfa07d byr:1929\n",
    "\n",
    "hcl:#ae17e1 iyr:2013\n",
    "eyr:2024\n",
    "ecl:brn pid:760753108 byr:1931\n",
    "hgt:179cm\n",
    "\n",
    "hcl:#cfa07d eyr:2025 pid:166559648\n",
    "iyr:2011 ecl:brn hgt:59in\n",
    "\n",
    "The first passport is valid - all eight fields are present. The second passport is invalid - it is missing hgt (the Height field).\n",
    "\n",
    "The third passport is interesting; the only missing field is cid, so it looks like data from North Pole Credentials, not a passport at all! Surely, nobody would mind if you made the system temporarily ignore missing cid fields. Treat this \"passport\" as valid.\n",
    "\n",
    "The fourth passport is missing two fields, cid and byr. Missing cid is fine, but missing any other field is not, so this passport is invalid.\n",
    "\n",
    "According to the above rules, your improved system would report 2 valid passports.\n",
    "\n",
    "Count the number of valid passports - those that have all required fields. Treat cid as optional. In your batch file, how many passports are valid?"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "250 passports are valid\n"
     ]
    }
   ],
   "source": [
    "f = open('d04-input.txt', 'r')\n",
    "data = f.readlines()\n",
    "data_str = \"\"\n",
    "valid = 0\n",
    "for lines in data:\n",
    "\tdata_str += lines\n",
    "data_str = data_str.split(\"\\n\\n\")\n",
    "for passport in data_str:\n",
    "\tif (\"byr\" in passport) and (\"iyr\" in passport) and (\"eyr\" in passport) and (\"hgt\" in passport) and (\"hcl\" in passport) and (\"ecl\" in passport) and (\"pid\" in passport):\n",
    "\t\tvalid = valid + 1\n",
    "print(valid,\"passports are valid\")"
   ]
  },
  {
   "source": [
    "### --- Passport Processing ---\n",
    "### --- Part Two ---\n",
    "\n",
    "The line is moving more quickly now, but you overhear airport security talking about how passports with invalid data are getting through. Better add some data validation, quick!\n",
    "\n",
    "You can continue to ignore the cid field, but each other field has strict rules about what values are valid for automatic validation:\n",
    "\n",
    "byr (Birth Year) - four digits; at least 1920 and at most 2002.\n",
    "iyr (Issue Year) - four digits; at least 2010 and at most 2020.\n",
    "eyr (Expiration Year) - four digits; at least 2020 and at most 2030.\n",
    "hgt (Height) - a number followed by either cm or in:\n",
    "If cm, the number must be at least 150 and at most 193.\n",
    "If in, the number must be at least 59 and at most 76.\n",
    "hcl (Hair Color) - a # followed by exactly six characters 0-9 or a-f.\n",
    "ecl (Eye Color) - exactly one of: amb blu brn gry grn hzl oth.\n",
    "pid (Passport ID) - a nine-digit number, including leading zeroes.\n",
    "cid (Country ID) - ignored, missing or not.\n",
    "Your job is to count the passports where all required fields are both present and valid according to the above rules. Here are some example values:\n",
    "\n",
    "byr valid:   2002\n",
    "byr invalid: 2003\n",
    "\n",
    "hgt valid:   60in\n",
    "hgt valid:   190cm\n",
    "hgt invalid: 190in\n",
    "hgt invalid: 190\n",
    "\n",
    "hcl valid:   #123abc\n",
    "hcl invalid: #123abz\n",
    "hcl invalid: 123abc\n",
    "\n",
    "ecl valid:   brn\n",
    "ecl invalid: wat\n",
    "\n",
    "pid valid:   000000001\n",
    "pid invalid: 0123456789\n",
    "Here are some invalid passports:\n",
    "\n",
    "eyr:1972 cid:100\n",
    "hcl:#18171d ecl:amb hgt:170 pid:186cm iyr:2018 byr:1926\n",
    "\n",
    "iyr:2019\n",
    "hcl:#602927 eyr:1967 hgt:170cm\n",
    "ecl:grn pid:012533040 byr:1946\n",
    "\n",
    "hcl:dab227 iyr:2012\n",
    "ecl:brn hgt:182cm pid:021572410 eyr:2020 byr:1992 cid:277\n",
    "\n",
    "hgt:59cm ecl:zzz\n",
    "eyr:2038 hcl:74454a iyr:2023\n",
    "pid:3556412378 byr:2007\n",
    "Here are some valid passports:\n",
    "\n",
    "pid:087499704 hgt:74in ecl:grn iyr:2012 eyr:2030 byr:1980\n",
    "hcl:#623a2f\n",
    "\n",
    "eyr:2029 ecl:blu cid:129 byr:1989\n",
    "iyr:2014 pid:896056539 hcl:#a97842 hgt:165cm\n",
    "\n",
    "hcl:#888785\n",
    "hgt:164cm byr:2001 iyr:2015 cid:88\n",
    "pid:545766238 ecl:hzl\n",
    "eyr:2022\n",
    "\n",
    "iyr:2010 hgt:158cm hcl:#b6652a ecl:blu byr:1944 eyr:2021 pid:093154719\n",
    "Count the number of valid passports - those that have all required fields and valid values. Continue to treat cid as optional. In your batch file, how many passports are valid?"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "154 passports are valid\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "f = open('d04-input.txt', 'r')\n",
    "data = f.readlines()\n",
    "data_str = \"\"\n",
    "valid = 0\n",
    "for lines in data:\n",
    "\tdata_str += lines\n",
    "data_str = data_str.split(\"\\n\\n\")\n",
    "valid = 0\n",
    "for passport in data_str:\n",
    "\tpassport_info = passport.replace(\"\\n\",\" \")\n",
    "\tpassport_info = passport_info.split(\" \")\n",
    "\tindx_iyr = [passport_info.index(i) for i in passport_info if 'iyr:' in i]\n",
    "\tindx_byr = [passport_info.index(i) for i in passport_info if 'byr:' in i]\n",
    "\tindx_eyr = [passport_info.index(i) for i in passport_info if 'eyr:' in i]\n",
    "\tindx_hgt = [passport_info.index(i) for i in passport_info if 'hgt:' in i]\n",
    "\tindx_hcl = [passport_info.index(i) for i in passport_info if 'hcl:' in i]\n",
    "\tindx_ecl = [passport_info.index(i) for i in passport_info if 'ecl:' in i]\n",
    "\tindx_pid = [passport_info.index(i) for i in passport_info if 'pid:' in i]\n",
    "\t\n",
    "\tif indx_iyr == [] or indx_byr ==[] or indx_eyr == [] or indx_hgt == [] or indx_hcl == [] or indx_ecl == [] or indx_pid == []:\n",
    "\t\tcontinue\n",
    "\t\n",
    "\tindx_iyr = indx_iyr[0]\n",
    "\tindx_byr = indx_byr[0]\n",
    "\tindx_eyr = indx_eyr[0]\n",
    "\tindx_hgt = indx_hgt[0]\n",
    "\tindx_hcl = indx_hcl[0]\n",
    "\tindx_ecl = indx_ecl[0]\n",
    "\tindx_pid = indx_pid[0]\n",
    "\t\n",
    "\tbyr = int(passport_info[indx_byr].split(\":\")[1])\n",
    "\tiyr = int(passport_info[indx_iyr].split(\":\")[1])\n",
    "\teyr = int(passport_info[indx_eyr].split(\":\")[1])\n",
    "\thgt = passport_info[indx_hgt].split(\":\")[1]\n",
    "\thcl = passport_info[indx_hcl].split(\":\")[1]\n",
    "\tecl = passport_info[indx_ecl].split(\":\")[1]\n",
    "\tpid = passport_info[indx_pid].split(\":\")[1]\n",
    "\t\n",
    "\tif (byr >= 1920 and byr <= 2002) and (iyr >= 2010 and iyr <= 2020) and (eyr >= 2020 and eyr <= 2030) and (re.findall(\"^#[0-9A-Fa-f]{6}$\", hcl)) and (ecl in [\"amb\", \"blu\", \"brn\", \"gry\", \"grn\", \"hzl\", \"oth\"]) and (re.findall('\\d{9}', pid)) and ( ((hgt.endswith(\"cm\") and int(hgt[:len(hgt)-2]) >= 150 and int(hgt[:len(hgt)-2]) <= 192)) or ((hgt.endswith(\"in\") and int(hgt[:len(hgt)-2]) >= 59 and int(hgt[:len(hgt)-2]) <= 76)) ):\n",
    "\t\tvalid += 1\n",
    "print(valid,\"passports are valid\")"
   ]
  },
  {
   "source": [
    "## Day 5:\n",
    "### --- Binary Boarding ---\n",
    "\n",
    "You board your plane only to discover a new problem: you dropped your boarding pass! You aren't sure which seat is yours, and all of the flight attendants are busy with the flood of people that suddenly made it through passport control.\n",
    "\n",
    "You write a quick program to use your phone's camera to scan all of the nearby boarding passes (your puzzle input); perhaps you can find your seat through process of elimination.\n",
    "\n",
    "Instead of zones or groups, this airline uses binary space partitioning to seat people. A seat might be specified like FBFBBFFRLR, where F means \"front\", B means \"back\", L means \"left\", and R means \"right\".\n",
    "\n",
    "The first 7 characters will either be F or B; these specify exactly one of the 128 rows on the plane (numbered 0 through 127). Each letter tells you which half of a region the given seat is in. Start with the whole list of rows; the first letter indicates whether the seat is in the front (0 through 63) or the back (64 through 127). The next letter indicates which half of that region the seat is in, and so on until you're left with exactly one row.\n",
    "\n",
    "For example, consider just the first seven characters of FBFBBFFRLR:\n",
    "\n",
    "Start by considering the whole range, rows 0 through 127.\n",
    "F means to take the lower half, keeping rows 0 through 63.\n",
    "B means to take the upper half, keeping rows 32 through 63.\n",
    "F means to take the lower half, keeping rows 32 through 47.\n",
    "B means to take the upper half, keeping rows 40 through 47.\n",
    "B keeps rows 44 through 47.\n",
    "F keeps rows 44 through 45.\n",
    "The final F keeps the lower of the two, row 44.\n",
    "The last three characters will be either L or R; these specify exactly one of the 8 columns of seats on the plane (numbered 0 through 7). The same process as above proceeds again, this time with only three steps. L means to keep the lower half, while R means to keep the upper half.\n",
    "\n",
    "For example, consider just the last 3 characters of FBFBBFFRLR:\n",
    "\n",
    "Start by considering the whole range, columns 0 through 7.\n",
    "R means to take the upper half, keeping columns 4 through 7.\n",
    "L means to take the lower half, keeping columns 4 through 5.\n",
    "The final R keeps the upper of the two, column 5.\n",
    "So, decoding FBFBBFFRLR reveals that it is the seat at row 44, column 5.\n",
    "\n",
    "Every seat also has a unique seat ID: multiply the row by 8, then add the column. In this example, the seat has ID 44 * 8 + 5 = 357.\n",
    "\n",
    "Here are some other boarding passes:\n",
    "\n",
    "BFFFBBFRRR: row 70, column 7, seat ID 567.\n",
    "FFFBBBFRRR: row 14, column 7, seat ID 119.\n",
    "BBFFBBFRLL: row 102, column 4, seat ID 820.\n",
    "As a sanity check, look through your list of boarding passes. What is the highest seat ID on a boarding pass?\n",
    "\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[113] [1] 905 922\n"
     ]
    }
   ],
   "source": [
    "f = open('d05-input.txt', 'r')\n",
    "data = f.readlines()\n",
    "\n",
    "maxseatid=0\n",
    "\n",
    "for line in data:\n",
    "    row_code = line[:7]\n",
    "    seat_code= line[7:]\n",
    "    seatrow = []\n",
    "    seatid = 0\n",
    "    for s in range(0,128,1):\n",
    "        seatrow.append(s)\n",
    "    for s in row_code:\n",
    "        if s == \"F\":\n",
    "            seatrow = seatrow[:int(len(seatrow)/2)]\n",
    "        else:\n",
    "            seatrow = seatrow[int(len(seatrow)/2):]\n",
    "    seatnum = []\n",
    "    for s in range(0,8,1):\n",
    "        seatnum.append(s)\n",
    "    for s in seat_code:\n",
    "        if s == \"L\":\n",
    "            seatnum = seatnum[:int(len(seatnum)/2)]\n",
    "        else:\n",
    "            seatnum = seatnum[int(len(seatnum)/2):]\n",
    "    seatid = seatrow[0] * 8 + seatnum[0]\n",
    "    maxseatid = (seatid * (seatid > maxseatid)) + (maxseatid * (seatid <= maxseatid))\n",
    "print(seatrow,seatnum, seatid, maxseatid)\n"
   ]
  },
  {
   "source": [
    "### --- Binary Boarding ---\n",
    "### --- Part Two ---\n",
    "\n",
    "Ding! The \"fasten seat belt\" signs have turned on. Time to find your seat.\n",
    "\n",
    "It's a completely full flight, so your seat should be the only missing boarding pass in your list. However, there's a catch: some of the seats at the very front and back of the plane don't exist on this aircraft, so they'll be missing from your list as well.\n",
    "\n",
    "Your seat wasn't at the very front or back, though; the seats with IDs +1 and -1 from yours will be in your list.\n",
    "\n",
    "What is the ID of your seat?\n",
    "\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "747.0\n"
     ]
    }
   ],
   "source": [
    "f = open('d05-input.txt', 'r')\n",
    "data = f.readlines()\n",
    "\n",
    "maxseatid=0\n",
    "seatid=[]\n",
    "\n",
    "for idx, line in enumerate(data):\n",
    "    row_code = line[:7]\n",
    "    seat_code= line[7:]\n",
    "    seatrow = []\n",
    "    for s in range(0,128,1):\n",
    "        seatrow.append(s)\n",
    "    for s in row_code:\n",
    "        if s == \"F\":\n",
    "            seatrow = seatrow[:int(len(seatrow)/2)]\n",
    "        else:\n",
    "            seatrow = seatrow[int(len(seatrow)/2):]\n",
    "    seatnum = []\n",
    "    for s in range(0,8,1):\n",
    "        seatnum.append(s)\n",
    "    for s in seat_code:\n",
    "        if s == \"L\":\n",
    "            seatnum = seatnum[:int(len(seatnum)/2)]\n",
    "        else:\n",
    "            seatnum = seatnum[int(len(seatnum)/2):]\n",
    "    seatid.append(seatrow[0] * 8 + seatnum[0])\n",
    "\n",
    "seatid.sort()\n",
    "for s in range(0,len(seatid)-1):\n",
    "    if (seatid[s+1] - seatid[s]) == 1:\n",
    "        continue\n",
    "    else:\n",
    "        print((seatid[s+1]+seatid[s]) / 2)\n",
    "\n",
    "\n",
    "    \n"
   ]
  },
  {
   "source": [
    "## Day 6:\n",
    "### --- Custom Customs ---\n",
    "\n",
    "As your flight approaches the regional airport where you'll switch to a much larger plane, customs declaration forms are distributed to the passengers.\n",
    "\n",
    "The form asks a series of 26 yes-or-no questions marked a through z. All you need to do is identify the questions for which anyone in your group answers \"yes\". Since your group is just you, this doesn't take very long.\n",
    "\n",
    "However, the person sitting next to you seems to be experiencing a language barrier and asks if you can help. For each of the people in their group, you write down the questions for which they answer \"yes\", one per line. For example:\n",
    "\n",
    "- abcx\n",
    "- abcy\n",
    "- abcz\n",
    "\n",
    "In this group, there are 6 questions to which anyone answered \"yes\": a, b, c, x, y, and z. (Duplicate answers to the same question don't count extra; each question counts at most once.)\n",
    "\n",
    "Another group asks for your help, then another, and eventually you've collected answers from every group on the plane (your puzzle input). Each group's answers are separated by a blank line, and within each group, each person's answers are on a single line. For example:\n",
    "\n",
    "- abc\n",
    "\n",
    "- a\n",
    "- b\n",
    "- c\n",
    "\n",
    "- ab\n",
    "- ac\n",
    "\n",
    "- a\n",
    "- a\n",
    "- a\n",
    "- a\n",
    "\n",
    "- b\n",
    "\n",
    "This list represents answers from five groups:\n",
    "\n",
    "- The first group contains one person who answered \"yes\" to 3 questions: a, b, and c.\n",
    "- The second group contains three people; combined, they answered \"yes\" to 3 questions: a, b, and c.\n",
    "- The third group contains two people; combined, they answered \"yes\" to 3 questions: a, b, and c.\n",
    "- The fourth group contains four people; combined, they answered \"yes\" to only 1 question, a.\n",
    "- The last group contains one person who answered \"yes\" to only 1 question, b.\n",
    "\n",
    "In this example, the sum of these counts is 3 + 3 + 3 + 1 + 1 = 11.\n",
    "\n",
    "For each group, count the number of questions to which anyone answered \"yes\". What is the sum of those counts?\n",
    "\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "sum of questions answered yes =  6297\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "f = open('d06-input.txt', 'r')\n",
    "data = f.readlines()\n",
    "data_clean = []\n",
    "lst = \"\"\n",
    "count = 0\n",
    "# clean data string - get groups into one line each\n",
    "for lines in data:\n",
    "\tif lines == \"\\n\":\n",
    "\t\tdata_clean.append(lst.replace(\"\\n\", \"\"))\n",
    "\t\tlst = \"\"\n",
    "\t\tcontinue\n",
    "\telse:\n",
    "\t\tlst += lines\n",
    "\n",
    "#loop through each line\n",
    "for lines in data_clean:\n",
    "# loop through a...z\n",
    "\tfor letter in string.ascii_lowercase:\n",
    "# if that letter in the line increment counter\n",
    "\t\tif letter in lines:\n",
    "\t\t\tcount += 1\n",
    "print(\"sum of questions answered yes = \",count)\n"
   ]
  },
  {
   "source": [
    "### --- Custom Customs ---\n",
    "### --- Part Two ---\n",
    "\n",
    "As you finish the last group's customs declaration, you notice that you misread one word in the instructions:\n",
    "\n",
    "You don't need to identify the questions to which anyone answered \"yes\"; you need to identify the questions to which everyone answered \"yes\"!\n",
    "\n",
    "Using the same example as above:\n",
    "\n",
    "- abc\n",
    "\n",
    "- a\n",
    "- b\n",
    "- c\n",
    "\n",
    "- ab\n",
    "- ac\n",
    "\n",
    "- a\n",
    "- a\n",
    "- a\n",
    "- a\n",
    "\n",
    "- b\n",
    "This list represents answers from five groups:\n",
    "\n",
    "In the first group, everyone (all 1 person) answered \"yes\" to 3 questions: a, b, and c.\n",
    "In the second group, there is no question to which everyone answered \"yes\".\n",
    "In the third group, everyone answered yes to only 1 question, a. Since some people did not answer \"yes\" to b or c, they don't count.\n",
    "In the fourth group, everyone answered yes to only 1 question, a.\n",
    "In the fifth group, everyone (all 1 person) answered \"yes\" to 1 question, b.\n",
    "In this example, the sum of these counts is 3 + 0 + 1 + 1 + 1 = 6.\n",
    "\n",
    "For each group, count the number of questions to which everyone answered \"yes\". What is the sum of those counts?\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "number of questions to which anyone answered yes is:  3158\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "\n",
    "f = open('d06-input.txt', 'r')\n",
    "data = f.readlines()\n",
    "data_clean = []\n",
    "lst = \"\"\n",
    "count = 0\n",
    "letter_count = 0\n",
    "group = []\n",
    "lttrs = []\n",
    "for lines in data:\n",
    "\tgroup.append(lines)\n",
    "\tif lines == \"\\n\":\n",
    "\t\tdata_clean.append(group)\n",
    "\t\tgroup=[]\n",
    "for i in data_clean:\n",
    "\tfor letter in string.ascii_lowercase:\n",
    "\t\tletter_count = 0\n",
    "\t\tfor j in range(0,len(i)-1):\n",
    "\t\t\tletter_count += i[j].count(letter)\n",
    "\t\tif letter_count == len(i)-1:\n",
    "\t\t\tcount += 1\n",
    "\n",
    "\t\t\n",
    "print(\"number of questions to which anyone answered yes is: \",count)\n"
   ]
  },
  {
   "source": [
    "## Day 7: \n",
    "### --- Handy Haversacks ---\n",
    "\n",
    "You land at the regional airport in time for your next flight. In fact, it looks like you'll even have time to grab some food: all flights are currently delayed due to issues in luggage processing.\n",
    "\n",
    "Due to recent aviation regulations, many rules (your puzzle input) are being enforced about bags and their contents; bags must be color-coded and must contain specific quantities of other color-coded bags. Apparently, nobody responsible for these regulations considered how long they would take to enforce!\n",
    "\n",
    "For example, consider the following rules:\n",
    "\n",
    "- light red bags contain 1 bright white bag, 2 muted yellow bags.\n",
    "- dark orange bags contain 3 bright white bags, 4 muted yellow bags.\n",
    "- bright white bags contain 1 shiny gold bag.\n",
    "- muted yellow bags contain 2 shiny gold bags, 9 faded blue bags.\n",
    "- shiny gold bags contain 1 dark olive bag, 2 vibrant plum bags.\n",
    "- dark olive bags contain 3 faded blue bags, 4 dotted black bags.\n",
    "- vibrant plum bags contain 5 faded blue bags, 6 dotted black bags.\n",
    "- faded blue bags contain no other bags.\n",
    "- dotted black bags contain no other bags.\n",
    "\n",
    "These rules specify the required contents for 9 bag types. In this example, every faded blue bag is empty, every vibrant plum bag contains 11 bags (5 faded blue and 6 dotted black), and so on.\n",
    "\n",
    "You have a shiny gold bag. If you wanted to carry it in at least one other bag, how many different bag colors would be valid for the outermost bag? (In other words: how many colors can, eventually, contain at least one shiny gold bag?)\n",
    "\n",
    "In the above rules, the following options would be available to you:\n",
    "\n",
    "- A bright white bag, which can hold your shiny gold bag directly.\n",
    "- A muted yellow bag, which can hold your shiny gold bag directly, plus some other bags.\n",
    "- A dark orange bag, which can hold bright white and muted yellow bags, either of which could then hold your shiny gold bag.\n",
    "- A light red bag, which can hold bright white and muted yellow bags, either of which could then hold your shiny gold bag.\n",
    "- So, in this example, the number of bag colors that can eventually contain at least one shiny gold bag is 4.\n",
    "\n",
    "How many bag colors can eventually contain at least one shiny gold bag? (The list of rules is quite long; make sure you get all of it.)\n",
    "\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "278 bag colors can eventually contain at least one shiny gold bag\n"
     ]
    }
   ],
   "source": [
    "f = open('d07-input.txt', 'r')\n",
    "data = f.readlines()\n",
    "# data = [\"light red bags contain 1 bright white bag, 2 muted yellow bags.\", \"dark orange bags contain 3 bright white bags, 4 muted yellow bags.\", \"bright white bags contain 1 shiny gold bag.\" , \"muted yellow bags contain 2 shiny gold bags, 9 faded blue bags.\" , \"shiny gold bags contain 1 dark olive bag, 2 vibrant plum bags.\" , \"dark olive bags contain 3 faded blue bags, 4 dotted black bags.\", \"vibrant plum bags contain 5 faded blue bags, 6 dotted black bags.\" , \"faded blue bags contain no other bags.\", \"dotted black bags contain no other bags.\"]\n",
    "myBags = []\n",
    "data_clean = [data[i].split(\"contain\") for i in range(len(data))]\n",
    "\n",
    "# find the bags that can contain \"shiny gold bags\"\n",
    "myBags = [data_clean[s][0][0:len(data_clean[s][0])-6] for s in range(len(data_clean)) if \"shiny gold\" in data_clean[s][1]]\n",
    "\n",
    "# find bags that can contain bags that can contain \"shiny gold bags\"\n",
    "for bag_col in myBags:\n",
    "\tmyBags += [data_clean[s][0][0:len(data_clean[s][0])-6] for s in range(len(data_clean)) if bag_col in data_clean[s][1]]\n",
    "\n",
    "# remove duplicate bag colours\n",
    "myBags = list(dict.fromkeys(myBags))\t\n",
    "print(len(myBags),\"bag colors can eventually contain at least one shiny gold bag\")"
   ]
  },
  {
   "source": [
    "### --- Handy Haversacks ---\n",
    "### --- Part Two ---\n",
    "\n",
    "It's getting pretty expensive to fly these days - not because of ticket prices, but because of the ridiculous number of bags you need to buy!\n",
    "\n",
    "Consider again your shiny gold bag and the rules from the above example:\n",
    "\n",
    "- faded blue bags contain 0 other bags.\n",
    "- dotted black bags contain 0 other bags.\n",
    "- vibrant plum bags contain 11 other bags: 5 faded blue bags and 6 dotted black bags.\n",
    "- dark olive bags contain 7 other bags: 3 faded blue bags and 4 dotted black bags.\n",
    "\n",
    "So, a single shiny gold bag must contain 1 dark olive bag (and the 7 bags within it) plus 2 vibrant plum bags (and the 11 bags within each of those): 1 + 1*7 + 2 + 2*11 = 32 bags!\n",
    "\n",
    "Of course, the actual rules have a small chance of going several levels deeper than this example; be sure to count all of the bags, even if the nesting becomes topologically impractical!\n",
    "\n",
    "Here's another example:\n",
    "\n",
    "- shiny gold bags contain 2 dark red bags.\n",
    "- dark red bags contain 2 dark orange bags.\n",
    "- dark orange bags contain 2 dark yellow bags.\n",
    "- dark yellow bags contain 2 dark green bags.\n",
    "- dark green bags contain 2 dark blue bags.\n",
    "- dark blue bags contain 2 dark violet bags.\n",
    "- dark violet bags contain no other bags.\n",
    "\n",
    "In this example, a single shiny gold bag must contain 126 other bags.\n",
    "\n",
    "How many individual bags are required inside your single shiny gold bag?\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "- shiny gold bags contain 2 dark coral bags, 1 mirrored orange bag.\n",
    "- \n",
    "-     2 dark coral bags contain 6 dim lavender bags, 6 pale green bags, 8 mirrored orange bags, 2 dim coral bag\n",
    "-         6 dim lavender bags contain 12 pale gold bags, 30 mirrored turquoise bags, 6 dull lime bag, 6 dull beige bag.\n",
    "-             12 pale gold bags contain 60 light lavender bags, 48 mirrored orange bags, 48 muted chartreuse bags.\n",
    "-                 60 light lavender bags contain 120 plaid turquoise bags.\n",
    "-                     120 plaid turquoise bags contain 480 light silver bags.\n",
    "-                         light silver bags contain no other bags.\n",
    "-                 mirrored orange bags contain no other bags.\n",
    "-                 48 muted chartreuse bags contain 48 clear olive bag.\n",
    "-                     clear olive bags contain no other bags.\n",
    "- \n",
    "-             30 mirrored turquoise bags contain 150 drab beige bags, 30 faded plum bag, 120 mirrored orange bags.\n",
    "-                 150 drab beige bags contain 600 pale gold bags.\n",
    "-                     600 pale gold bags contain 3000 light lavender bags, 2400 mirrored orange bags, 2400 muted chartreuse bags.\n",
    "-                         3000 light lavender bags contain 6000 plaid turquoise bags.\n",
    "-                             6000 plaid turquoise bags contain 24000 light silver bags.\n",
    "-                                 light silver bags contain no other bags.\n",
    "-                         mirrored orange bags contain no other bags.\n",
    "-                         2400 muted chartreuse bags contain 2400 clear olive bag.\n",
    "-                             clear olive bags contain no other bags.\n",
    "-                 30 faded plum bags contain 60 dull lime bags, 120 dim coral bags, 150 shiny maroon bags, 90 pale red bags.\n",
    "-                         60 dull lime bags contain 240 mirrored orange bags.\n",
    "-                             mirrored orange bags contain no other bags.\n",
    "-                         dim coral bags contain no other bags.\n",
    "-                         150 shiny maroon bags contain 150 mirrored orange bag, 150 muted chartreuse bag, 750 wavy bronze bags, 150 dull lavender bag.\n",
    "-                             mirrored orange bags contain no other bags.\n",
    "-                             150 muted chartreuse bags contain 150 clear olive bag.\n",
    "-                                 clear olive bags contain no other bags.\n",
    "-                             wavy bronze bags contain no other bags.\n",
    "-                             150 dull lavender bags contain 750 clear olive bags, 150 mirrored orange bag.\n",
    "-                                 clear olive bags contain no other bags.\n",
    "-                                 mirrored orange bags contain no other bags.\n",
    "-                         pale red bags contain no other bags.\n",
    "-                 mirrored orange bags contain no other bags.\n",
    "\n",
    "-             6 dull lime bags contain 24 mirrored orange bags\n",
    "-                 mirrored orange bags contain no other bags.\n",
    "\n",
    "-             dull beige bags contain no other bags\n",
    "        \n",
    "-         6 pale green bags contain 6 pale red bag, 30 dull lavender bags, 24 clear olive bags.\n",
    "-             pale red bags contain no other bags.\n",
    "-             30 dull lavender bags contain 150 clear olive bags, 30 mirrored orange bag.\n",
    "-                 clear olive bags contain no other bags.\n",
    "-                 mirrored orange bags contain no other bags.\n",
    "-             clear olive bags contain no other bags.\n",
    "        \n",
    "-         mirrored orange bags contain no other bags.\n",
    "        \n",
    "-         dim coral bags contain no other bags.\n",
    "\n",
    "-     1 mirrored orange bags contain no other bags.\n",
    "\n",
    "### Total = 45157 bags\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## Day 8:\n",
    "### --- Handheld Halting ---\n",
    "\n",
    "Your flight to the major airline hub reaches cruising altitude without incident. While you consider checking the in-flight menu for one of those drinks that come with a little umbrella, you are interrupted by the kid sitting next to you.\n",
    "\n",
    "Their handheld game console won't turn on! They ask if you can take a look.\n",
    "\n",
    "You narrow the problem down to a strange infinite loop in the boot code (your puzzle input) of the device. You should be able to fix it, but first you need to be able to run the code in isolation.\n",
    "\n",
    "The boot code is represented as a text file with one instruction per line of text. Each instruction consists of an operation (acc, jmp, or nop) and an argument (a signed number like +4 or -20).\n",
    "\n",
    "    acc increases or decreases a single global value called the accumulator by the value given in the argument. For example, acc +7 would increase the accumulator by 7. The accumulator starts at 0. After an acc instruction, the instruction immediately below it is executed next.\n",
    "    jmp jumps to a new instruction relative to itself. The next instruction to execute is found using the argument as an offset from the jmp instruction; for example, jmp +2 would skip the next instruction, jmp +1 would continue to the instruction immediately below it, and jmp -20 would cause the instruction 20 lines above to be executed next.\n",
    "    nop stands for No OPeration - it does nothing. The instruction immediately below it is executed next.\n",
    "\n",
    "For example, consider the following program:\n",
    "\n",
    "- nop +0\n",
    "- acc +1\n",
    "- jmp +4\n",
    "- acc +3\n",
    "- jmp -3\n",
    "- acc -99\n",
    "- acc +1\n",
    "- jmp -4\n",
    "- acc +6\n",
    "\n",
    "These instructions are visited in this order:\n",
    "\n",
    "- nop +0  | 1\n",
    "- acc +1  | 2, 8(!)\n",
    "- jmp +4  | 3\n",
    "- acc +3  | 6\n",
    "- jmp -3  | 7\n",
    "- acc -99 |\n",
    "- acc +1  | 4\n",
    "- jmp -4  | 5\n",
    "- acc +6  |\n",
    "\n",
    "First, the nop +0 does nothing. Then, the accumulator is increased from 0 to 1 (acc +1) and jmp +4 sets the next instruction to the other acc +1 near the bottom. After it increases the accumulator from 1 to 2, jmp -4 executes, setting the next instruction to the only acc +3. It sets the accumulator to 5, and jmp -3 causes the program to continue back at the first acc +1.\n",
    "\n",
    "This is an infinite loop: with this sequence of jumps, the program will run forever. The moment the program tries to run any instruction a second time, you know it will never terminate.\n",
    "\n",
    "Immediately before the program would run an instruction a second time, the value in the accumulator is 5.\n",
    "\n",
    "Run your copy of the boot code. Immediately before any instruction is executed a second time, what value is in the accumulator?\n",
    "\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "value in accumulator is: 2058\n"
     ]
    }
   ],
   "source": [
    "# read data file\n",
    "f = open('d08-input.txt', 'r')\n",
    "data = f.readlines()\n",
    "# test data\n",
    "# data = [\"nop +0\", \"acc +1\", \"jmp +4\", \"acc +3\", \"jmp -3\", \"acc -99\", \"acc +1\", \"jmp -4\", \"acc +6\"]\n",
    "\n",
    "# initialise variables\n",
    "codeLine = 0\n",
    "accumulator = 0\n",
    "executedCodeLines = []\n",
    "repeatedLines = False\n",
    "\n",
    "# loop until a line is repeated\n",
    "while not(repeatedLines):\n",
    "    # split input data into components\n",
    "    command = data[codeLine][0:3]\n",
    "    value = data[codeLine][3:]\n",
    "    # if the line of code has been executed then change the repeatedLines variable\n",
    "    if codeLine in executedCodeLines:\n",
    "        repeatedLines = True\n",
    "        break\n",
    "    else: executedCodeLines.append(codeLine)\n",
    "    # executed the commands\n",
    "    if command == \"acc\":\n",
    "        accumulator += int(value)\n",
    "        codeLine += 1\n",
    "    if command == \"nop\":\n",
    "        codeLine += 1\n",
    "    if command == \"jmp\":\n",
    "        codeLine += int(value)\n",
    "\n",
    "# print result\n",
    "print(\"value in accumulator is:\",accumulator)\n"
   ]
  },
  {
   "source": [
    "### --- Handheld Halting ---\n",
    "### --- Part Two ---\n",
    "\n",
    "After some careful analysis, you believe that exactly one instruction is corrupted.\n",
    "\n",
    "Somewhere in the program, either a jmp is supposed to be a nop, or a nop is supposed to be a jmp. (No acc instructions were harmed in the corruption of this boot code.)\n",
    "\n",
    "The program is supposed to terminate by attempting to execute an instruction immediately after the last instruction in the file. By changing exactly one jmp or nop, you can repair the boot code and make it terminate correctly.\n",
    "\n",
    "For example, consider the same program from above:\n",
    "\n",
    "- nop +0\n",
    "- acc +1\n",
    "- jmp +4\n",
    "- acc +3\n",
    "- jmp -3\n",
    "- acc -99\n",
    "- acc +1\n",
    "- jmp -4\n",
    "- acc +6\n",
    "\n",
    "If you change the first instruction from nop +0 to jmp +0, it would create a single-instruction infinite loop, never leaving that instruction. If you change almost any of the jmp instructions, the program will still eventually find another jmp instruction and loop forever.\n",
    "\n",
    "However, if you change the second-to-last instruction (from jmp -4 to nop -4), the program terminates! The instructions are visited in this order:\n",
    "\n",
    "- nop +0  | 1\n",
    "- acc +1  | 2\n",
    "- jmp +4  | 3\n",
    "- acc +3  |\n",
    "- jmp -3  |\n",
    "- acc -99 |\n",
    "- acc +1  | 4\n",
    "- nop -4  | 5\n",
    "- acc +6  | 6\n",
    "\n",
    "After the last instruction (acc +6), the program terminates by attempting to run the instruction below the last instruction in the file. With this change, after the program terminates, the accumulator contains the value 8 (acc +1, acc +1, acc +6).\n",
    "\n",
    "Fix the program so that it terminates normally by changing exactly one jmp (to nop) or nop (to jmp). What is the value of the accumulator after the program terminates?\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "value of accumulator is: 1000\n"
     ]
    }
   ],
   "source": [
    "# read data file\n",
    "f = open('d08-input.txt', 'r')\n",
    "data = f.readlines()\n",
    "# test data\n",
    "# data = [\"nop +0\", \"acc +1\", \"jmp +4\", \"acc +3\", \"jmp -3\", \"acc -99\", \"acc +1\", \"jmp -4\", \"acc +6\"]\n",
    "\n",
    "\n",
    "# TRY:\n",
    "# identify all the lines with jmp or nop\n",
    "# loop through the list changing each in turn to the other\n",
    "# if code executes - flag success\n",
    "# if code repeats revert data set and swop next matching command and try again\n",
    "\n",
    "# identify all the lines with jmp or nop\n",
    "testLines = []\n",
    "for idx, i in enumerate(data):\n",
    "    if i[0:3] == \"jmp\" or i[0:3] == \"nop\":\n",
    "        testLines.append(idx)\n",
    "# loop through the list changing each in turn to the other\n",
    "\n",
    "for idx in testLines:\n",
    "    if data[idx][0:3] == \"jmp\":\n",
    "        data[idx] = data[idx].replace(\"jmp\",\"nop\")\n",
    "    else:\n",
    "        data[idx] = data[idx].replace(\"nop\", \"jmp\")\n",
    "    # while-loop until a line is repeated\n",
    "    \n",
    "    # initialise variables\n",
    "    codeLine = 0\n",
    "    accumulator = 0\n",
    "    executedCodeLines = []\n",
    "    lastJmpLine = []\n",
    "    repeatedLines = False\n",
    "\n",
    "    while not(repeatedLines):\n",
    "        # split input data into components\n",
    "        command = data[codeLine][0:3]\n",
    "        value = data[codeLine][3:]\n",
    "        # if the line of code has been executed then change the repeatedLines variable\n",
    "        if codeLine in executedCodeLines:\n",
    "            repeatedLines = True\n",
    "            # reset the change code line then end the loop\n",
    "            if data[idx][0:3] == \"jmp\":\n",
    "                data[idx] = data[idx].replace(\"jmp\",\"nop\")\n",
    "            else:\n",
    "                data[idx] = data[idx].replace(\"nop\", \"jmp\")\n",
    "            break\n",
    "        else: executedCodeLines.append(codeLine)\n",
    "        # executed the commands\n",
    "        if command == \"acc\":\n",
    "            accumulator += int(value)\n",
    "            codeLine += 1\n",
    "        if command == \"nop\":\n",
    "            codeLine += 1\n",
    "        if command == \"jmp\":\n",
    "            codeLine += int(value)\n",
    "        if codeLine > len(data)-1:\n",
    "            break\n",
    "    if (repeatedLines == False) and (codeLine == len(data)):\n",
    "        break\n",
    "\n",
    "print(\"value of accumulator is:\",accumulator)"
   ]
  },
  {
   "source": [
    "## Day 9:\n",
    "### --- Encoding Error ---\n",
    "\n",
    "With your neighbor happily enjoying their video game, you turn your attention to an open data port on the little screen in the seat in front of you.\n",
    "\n",
    "Though the port is non-standard, you manage to connect it to your computer through the clever use of several paperclips. Upon connection, the port outputs a series of numbers (your puzzle input).\n",
    "\n",
    "The data appears to be encrypted with the eXchange-Masking Addition System (XMAS) which, conveniently for you, is an old cypher with an important weakness.\n",
    "\n",
    "XMAS starts by transmitting a preamble of 25 numbers. After that, each number you receive should be the sum of any two of the 25 immediately previous numbers. The two numbers will have different values, and there might be more than one such pair.\n",
    "\n",
    "For example, suppose your preamble consists of the numbers 1 through 25 in a random order. To be valid, the next number must be the sum of two of those numbers:\n",
    "\n",
    "    26 would be a valid next number, as it could be 1 plus 25 (or many other pairs, like 2 and 24).\n",
    "    49 would be a valid next number, as it is the sum of 24 and 25.\n",
    "    100 would not be valid; no two of the previous 25 numbers sum to 100.\n",
    "    50 would also not be valid; although 25 appears in the previous 25 numbers, the two numbers in the pair must be different.\n",
    "\n",
    "Suppose the 26th number is 45, and the first number (no longer an option, as it is more than 25 numbers ago) was 20. Now, for the next number to be valid, there needs to be some pair of numbers among 1-19, 21-25, or 45 that add up to it:\n",
    "\n",
    "    26 would still be a valid next number, as 1 and 25 are still within the previous 25 numbers.\n",
    "    65 would not be valid, as no two of the available numbers sum to it.\n",
    "    64 and 66 would both be valid, as they are the result of 19+45 and 21+45 respectively.\n",
    "\n",
    "Here is a larger example which only considers the previous 5 numbers (and has a preamble of length 5):\n",
    "\n",
    "35\n",
    "20\n",
    "15\n",
    "25\n",
    "47\n",
    "40\n",
    "62\n",
    "55\n",
    "65\n",
    "95\n",
    "102\n",
    "117\n",
    "150\n",
    "182\n",
    "127\n",
    "219\n",
    "299\n",
    "277\n",
    "309\n",
    "576\n",
    "\n",
    "In this example, after the 5-number preamble, almost every number is the sum of two of the previous 5 numbers; the only number that does not follow this rule is 127.\n",
    "\n",
    "The first step of attacking the weakness in the XMAS data is to find the first number in the list (after the preamble) which is not the sum of two of the 25 numbers before it. What is the first number that does not have this property?\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "first number is: 10884537\n"
     ]
    }
   ],
   "source": [
    "# read data file\n",
    "f = open('d09-input.txt', 'r')\n",
    "data = f.readlines()\n",
    "# test data\n",
    "# data = [35, 20, 15, 25, 47, 40, 62, 55, 65, 95, 102, 117, 150, 182, 127, 219, 299, 277, 309, 576]\n",
    "preamble = 25 #25 for main problem, 5 for testing\n",
    "for i in range(0,len(data)):\n",
    "    data[i] = int(data[i].strip(\"\\n\"))\n",
    "# print(data[preamble:])\n",
    "\n",
    "for idx, i in enumerate(data[preamble:]):\n",
    "    solution = False\n",
    "    # print(\"idx\",idx,\"i\",i)\n",
    "    for j in data[idx:idx+preamble]:\n",
    "        for k in data[idx:idx+preamble]:\n",
    "            if j + k == i and (j != k):\n",
    "                # print(\"i\",i,\"j\",j,\"k\",k)\n",
    "                solution = True\n",
    "                break\n",
    "        if solution == True:\n",
    "            break\n",
    "    if solution == False:\n",
    "        print(\"first number is:\",i)\n",
    "        break"
   ]
  },
  {
   "source": [
    "### --- Encoding Error ---\n",
    "### --- Part Two ---\n",
    "\n",
    "The final step in breaking the XMAS encryption relies on the invalid number you just found: you must find a contiguous set of at least two numbers in your list which sum to the invalid number from step 1.\n",
    "\n",
    "Again consider the above example:\n",
    "\n",
    "35\n",
    "20\n",
    "15\n",
    "25\n",
    "47\n",
    "40\n",
    "62\n",
    "55\n",
    "65\n",
    "95\n",
    "102\n",
    "117\n",
    "150\n",
    "182\n",
    "127\n",
    "219\n",
    "299\n",
    "277\n",
    "309\n",
    "576\n",
    "\n",
    "In this list, adding up all of the numbers from 15 through 40 produces the invalid number from step 1, 127. (Of course, the contiguous set of numbers in your actual list might be much longer.)\n",
    "\n",
    "To find the encryption weakness, add together the smallest and largest number in this contiguous range; in this example, these are 15 and 47, producing 62.\n",
    "\n",
    "What is the encryption weakness in your XMAS-encrypted list of numbers?\n",
    "\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "10884537 10884537 [408514, 507208, 753282, 695857, 570543, 444281, 626571, 592643, 500865, 693401, 599118, 661929, 814643, 662453, 712303, 852795, 788131]\n1261309\n"
     ]
    }
   ],
   "source": [
    "# read data file\n",
    "f = open('d09-input.txt', 'r')\n",
    "data = f.readlines()\n",
    "# test data\n",
    "# data = [35, 20, 15, 25, 47, 40, 62, 55, 65, 95, 102, 117, 150, 182, 127, 219, 299, 277, 309, 576]\n",
    "preamble = 25 #25 for main problem, 5 for testing\n",
    "for i in range(0,len(data)):\n",
    "    data[i] = int(data[i].strip(\"\\n\"))\n",
    "# print(data[preamble:])\n",
    "\n",
    "for idx, i in enumerate(data[preamble:]):\n",
    "    solution = False\n",
    "    # print(\"idx\",idx,\"i\",i)\n",
    "    for j in data[idx:idx+preamble]:\n",
    "        for k in data[idx:idx+preamble]:\n",
    "            if j + k == i and (j != k):\n",
    "                # print(\"i\",i,\"j\",j,\"k\",k)\n",
    "                solution = True\n",
    "                break\n",
    "        if solution == True:\n",
    "            break\n",
    "    if solution == False:\n",
    "        break\n",
    "# i is the value, data.index(i) is the position of i in the list\n",
    "# need to loop through the data list to the position of i to find \n",
    "# a combination of two or more numbers that sum to i\n",
    "targetNumber = i\n",
    "targetIdx = data.index(i)\n",
    "\n",
    "for i in range(0,targetIdx):\n",
    "    total = 0\n",
    "    values = []\n",
    "    for j in data[i:targetIdx]:\n",
    "        if i == j:\n",
    "            continue\n",
    "        total += j\n",
    "        values.append(j)\n",
    "        if total == targetNumber:\n",
    "            print(targetNumber, total, values)\n",
    "            print(min(values) + max(values))\n",
    "            break\n",
    "        if total > targetNumber:\n",
    "            break\n"
   ]
  },
  {
   "source": [
    "## Day 10:\n",
    "### --- Adapter Array ---\n",
    "\n",
    "Patched into the aircraft's data port, you discover weather forecasts of a massive tropical storm. Before you can figure out whether it will impact your vacation plans, however, your device suddenly turns off!\n",
    "\n",
    "Its battery is dead.\n",
    "\n",
    "You'll need to plug it in. There's only one problem: the charging outlet near your seat produces the wrong number of jolts. Always prepared, you make a list of all of the joltage adapters in your bag.\n",
    "\n",
    "Each of your joltage adapters is rated for a specific output joltage (your puzzle input). Any given adapter can take an input 1, 2, or 3 jolts lower than its rating and still produce its rated output joltage.\n",
    "\n",
    "In addition, your device has a built-in joltage adapter rated for 3 jolts higher than the highest-rated adapter in your bag. (If your adapter list were 3, 9, and 6, your device's built-in adapter would be rated for 12 jolts.)\n",
    "\n",
    "Treat the charging outlet near your seat as having an effective joltage rating of 0.\n",
    "\n",
    "Since you have some time to kill, you might as well test all of your adapters. Wouldn't want to get to your resort and realize you can't even charge your device!\n",
    "\n",
    "If you use every adapter in your bag at once, what is the distribution of joltage differences between the charging outlet, the adapters, and your device?\n",
    "\n",
    "For example, suppose that in your bag, you have adapters with the following joltage ratings:\n",
    "\n",
    "16\n",
    "10\n",
    "15\n",
    "5\n",
    "1\n",
    "11\n",
    "7\n",
    "19\n",
    "6\n",
    "12\n",
    "4\n",
    "\n",
    "With these adapters, your device's built-in joltage adapter would be rated for 19 + 3 = 22 jolts, 3 higher than the highest-rated adapter.\n",
    "\n",
    "Because adapters can only connect to a source 1-3 jolts lower than its rating, in order to use every adapter, you'd need to choose them like this:\n",
    "\n",
    "    The charging outlet has an effective rating of 0 jolts, so the only adapters that could connect to it directly would need to have a joltage rating of 1, 2, or 3 jolts. Of these, only one you have is an adapter rated 1 jolt (difference of 1).\n",
    "    From your 1-jolt rated adapter, the only choice is your 4-jolt rated adapter (difference of 3).\n",
    "    From the 4-jolt rated adapter, the adapters rated 5, 6, or 7 are valid choices. However, in order to not skip any adapters, you have to pick the adapter rated 5 jolts (difference of 1).\n",
    "    Similarly, the next choices would need to be the adapter rated 6 and then the adapter rated 7 (with difference of 1 and 1).\n",
    "    The only adapter that works with the 7-jolt rated adapter is the one rated 10 jolts (difference of 3).\n",
    "    From 10, the choices are 11 or 12; choose 11 (difference of 1) and then 12 (difference of 1).\n",
    "    After 12, only valid adapter has a rating of 15 (difference of 3), then 16 (difference of 1), then 19 (difference of 3).\n",
    "    Finally, your device's built-in adapter is always 3 higher than the highest adapter, so its rating is 22 jolts (always a difference of 3).\n",
    "\n",
    "In this example, when using every adapter, there are 7 differences of 1 jolt and 5 differences of 3 jolts.\n",
    "\n",
    "Here is a larger example:\n",
    "\n",
    "28\n",
    "33\n",
    "18\n",
    "42\n",
    "31\n",
    "14\n",
    "46\n",
    "20\n",
    "48\n",
    "47\n",
    "24\n",
    "23\n",
    "49\n",
    "45\n",
    "19\n",
    "38\n",
    "39\n",
    "11\n",
    "1\n",
    "32\n",
    "25\n",
    "35\n",
    "8\n",
    "17\n",
    "7\n",
    "9\n",
    "4\n",
    "2\n",
    "34\n",
    "10\n",
    "3\n",
    "\n",
    "In this larger example, in a chain that uses all of the adapters, there are 22 differences of 1 jolt and 10 differences of 3 jolts.\n",
    "\n",
    "Find a chain that uses all of your adapters to connect the charging outlet to your device's built-in adapter and count the joltage differences between the charging outlet, the adapters, and your device. What is the number of 1-jolt differences multiplied by the number of 3-jolt differences?\n",
    "\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# read data file\n",
    "f = open('d10-input.txt', 'r')\n",
    "data = f.readlines()\n",
    "\n",
    "# test data\n",
    "data = [16,10,15,5,1,11,7,19,6,12,4]\n",
    "# data = [28,33,18,42,31,14,46,20,48,47,24,23,49,45,19,38,39,11,1,32,25,35,8,17,7,9,4,2,34,10,3]\n",
    "\n",
    "# convert data to integers\n",
    "#for i in range(0,len(data)):\n",
    "#    data[i] = int(data[i].strip(\"\\n\"))\n",
    "\n",
    "\t# start solution\n",
    "rating = 0\n",
    "selectedAdaptors = []\n",
    "differences = [0,0,0,0]\n",
    "for i in data:\n",
    "\tpossibleAdaptors = []\n",
    "\tfor j in data:\n",
    "\t\tif j in selectedAdaptors:\n",
    "\t\t\tcontinue\n",
    "\t\tif (j - rating) <=3:\n",
    "\t\t\tpossibleAdaptors.append(j)\n",
    "\tdifferences[1] += (min(possibleAdaptors) - rating) == 1\n",
    "\tdifferences[2] += (min(possibleAdaptors) - rating) == 2\n",
    "\tdifferences[3] += (min(possibleAdaptors) - rating) == 3\n",
    "\trating += min(possibleAdaptors) - rating\n",
    "\tselectedAdaptors.append(data[data.index(min(possibleAdaptors))])\n",
    "# rating increased by 3\n",
    "rating += 3\n",
    "# number of differences of 3 increased by 1\n",
    "differences[3] += 1\n",
    "\n",
    "print(rating)\n",
    "print(differences)\n",
    "print(differences[1] * differences[3])\n"
   ]
  },
  {
   "source": [
    "### --- Adapter Array ---\n",
    "### --- Part Two ---\n",
    "\n",
    "To completely determine whether you have enough adapters, you'll need to figure out how many different ways they can be arranged. Every arrangement needs to connect the charging outlet to your device. The previous rules about when adapters can successfully connect still apply.\n",
    "\n",
    "The first example above (the one that starts with 16, 10, 15) supports the following arrangements:\n",
    "\n",
    "(0), 1, 4, 5, 6, 7, 10, 11, 12, 15, 16, 19, (22)\n",
    "(0), 1, 4, 5, 6, 7, 10, 12, 15, 16, 19, (22)\n",
    "(0), 1, 4, 5, 7, 10, 11, 12, 15, 16, 19, (22)\n",
    "(0), 1, 4, 5, 7, 10, 12, 15, 16, 19, (22)\n",
    "(0), 1, 4, 6, 7, 10, 11, 12, 15, 16, 19, (22)\n",
    "(0), 1, 4, 6, 7, 10, 12, 15, 16, 19, (22)\n",
    "(0), 1, 4, 7, 10, 11, 12, 15, 16, 19, (22)\n",
    "(0), 1, 4, 7, 10, 12, 15, 16, 19, (22)\n",
    "(The charging outlet and your device's built-in adapter are shown in parentheses.) Given the adapters from the first example, the total number of arrangements that connect the charging outlet to your device is 8.\n",
    "\n",
    "The second example above (the one that starts with 28, 33, 18) has many arrangements. Here are a few:\n",
    "\n",
    "(0), 1, 2, 3, 4, 7, 8, 9, 10, 11, 14, 17, 18, 19, 20, 23, 24, 25, 28, 31,\n",
    "32, 33, 34, 35, 38, 39, 42, 45, 46, 47, 48, 49, (52)\n",
    "\n",
    "(0), 1, 2, 3, 4, 7, 8, 9, 10, 11, 14, 17, 18, 19, 20, 23, 24, 25, 28, 31,\n",
    "32, 33, 34, 35, 38, 39, 42, 45, 46, 47, 49, (52)\n",
    "\n",
    "(0), 1, 2, 3, 4, 7, 8, 9, 10, 11, 14, 17, 18, 19, 20, 23, 24, 25, 28, 31,\n",
    "32, 33, 34, 35, 38, 39, 42, 45, 46, 48, 49, (52)\n",
    "\n",
    "(0), 1, 2, 3, 4, 7, 8, 9, 10, 11, 14, 17, 18, 19, 20, 23, 24, 25, 28, 31,\n",
    "32, 33, 34, 35, 38, 39, 42, 45, 46, 49, (52)\n",
    "\n",
    "(0), 1, 2, 3, 4, 7, 8, 9, 10, 11, 14, 17, 18, 19, 20, 23, 24, 25, 28, 31,\n",
    "32, 33, 34, 35, 38, 39, 42, 45, 47, 48, 49, (52)\n",
    "\n",
    "(0), 3, 4, 7, 10, 11, 14, 17, 20, 23, 25, 28, 31, 34, 35, 38, 39, 42, 45,\n",
    "46, 48, 49, (52)\n",
    "\n",
    "(0), 3, 4, 7, 10, 11, 14, 17, 20, 23, 25, 28, 31, 34, 35, 38, 39, 42, 45,\n",
    "46, 49, (52)\n",
    "\n",
    "(0), 3, 4, 7, 10, 11, 14, 17, 20, 23, 25, 28, 31, 34, 35, 38, 39, 42, 45,\n",
    "47, 48, 49, (52)\n",
    "\n",
    "(0), 3, 4, 7, 10, 11, 14, 17, 20, 23, 25, 28, 31, 34, 35, 38, 39, 42, 45,\n",
    "47, 49, (52)\n",
    "\n",
    "(0), 3, 4, 7, 10, 11, 14, 17, 20, 23, 25, 28, 31, 34, 35, 38, 39, 42, 45,\n",
    "48, 49, (52)\n",
    "In total, this set of adapters can connect the charging outlet to your device in 19208 distinct arrangements.\n",
    "\n",
    "You glance back down at your bag and try to remember why you brought so many adapters; there must be more than a trillion valid ways to arrange them! Surely, there must be an efficient way to count the arrangements.\n",
    "\n",
    "What is the total number of distinct ways you can arrange the adapters to connect the charging outlet to your device?\n",
    "\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# read data file\n",
    "f = open('d10-input.txt', 'r')\n",
    "data = [int(line.rstrip()) for line in f.readlines()]\n",
    "\n",
    "# test data\n",
    "# data = [16,10,15,5,1,11,7,19,6,12,4]\n",
    "# data = [28,33,18,42,31,14,46,20,48,47,24,23,49,45,19,38,39,11,1,32,25,35,8,17,7,9,4,2,34,10,3]\n",
    "\n",
    "# sort data\n",
    "data.sort()\n",
    "\n",
    "# start solution\n",
    "rating = 0\n",
    "selectedAdaptors = []\n",
    "differences = [0,0,0,0]\n",
    "for i in data:\n",
    "\tpossibleAdaptors = []\n",
    "\tfor j in data:\n",
    "\t\tif j in selectedAdaptors:\n",
    "\t\t\tcontinue\n",
    "\t\tif (j - rating) <=3:\n",
    "\t\t\tpossibleAdaptors.append(j)\n",
    "\tdifferences[1] += (min(possibleAdaptors) - rating) == 1\n",
    "\tdifferences[2] += (min(possibleAdaptors) - rating) == 2\n",
    "\tdifferences[3] += (min(possibleAdaptors) - rating) == 3\n",
    "\trating += min(possibleAdaptors) - rating\n",
    "\tselectedAdaptors.append(data[data.index(min(possibleAdaptors))])\n",
    "# rating increased by 3\n",
    "rating += 3\n",
    "# number of differences of 3 increased by 1\n",
    "differences[3] += 1\n",
    "\n",
    "print(rating)\n",
    "print(differences)\n",
    "print(differences[1] * differences[3])\n",
    "\n",
    "# part 2\n",
    "sol = {0:1}\n",
    "for line in sorted(data):\n",
    "\tsol[line] = 0\n",
    "\tif line - 1 in sol:\n",
    "\t\tsol[line] += sol[line-1]\n",
    "\tif line -2 in sol:\n",
    "\t\tsol[line] += sol[line-2]\n",
    "\tif line -3 in sol:\n",
    "\t\tsol[line] += sol[line-3]\n",
    "print(sol[max(data)])\n"
   ]
  },
  {
   "source": [
    "## Day 11:\n",
    "### --- Seating System ---\n",
    "\n",
    "Your plane lands with plenty of time to spare. The final leg of your journey is a ferry that goes directly to the tropical island where you can finally start your vacation. As you reach the waiting area to board the ferry, you realize you're so early, nobody else has even arrived yet!\n",
    "\n",
    "By modeling the process people use to choose (or abandon) their seat in the waiting area, you're pretty sure you can predict the best place to sit. You make a quick map of the seat layout (your puzzle input).\n",
    "\n",
    "The seat layout fits neatly on a grid. Each position is either floor (.), an empty seat (L), or an occupied seat (#). For example, the initial seat layout might look like this:\n",
    "\n",
    "L.LL.LL.LL\n",
    "LLLLLLL.LL\n",
    "L.L.L..L..\n",
    "LLLL.LL.LL\n",
    "L.LL.LL.LL\n",
    "L.LLLLL.LL\n",
    "..L.L.....\n",
    "LLLLLLLLLL\n",
    "L.LLLLLL.L\n",
    "L.LLLLL.LL\n",
    "\n",
    "Now, you just need to model the people who will be arriving shortly. Fortunately, people are entirely predictable and always follow a simple set of rules. All decisions are based on the number of occupied seats adjacent to a given seat (one of the eight positions immediately up, down, left, right, or diagonal from the seat). The following rules are applied to every seat simultaneously:\n",
    "\n",
    "    If a seat is empty (L) and there are no occupied seats adjacent to it, the seat becomes occupied.\n",
    "    If a seat is occupied (#) and four or more seats adjacent to it are also occupied, the seat becomes empty.\n",
    "    Otherwise, the seat's state does not change.\n",
    "\n",
    "Floor (.) never changes; seats don't move, and nobody sits on the floor.\n",
    "\n",
    "After one round of these rules, every seat in the example layout becomes occupied:\n",
    "\n",
    "#.##.##.##\n",
    "#######.##\n",
    "#.#.#..#..\n",
    "####.##.##\n",
    "#.##.##.##\n",
    "#.#####.##\n",
    "..#.#.....\n",
    "##########\n",
    "#.######.#\n",
    "#.#####.##\n",
    "\n",
    "After a second round, the seats with four or more occupied adjacent seats become empty again:\n",
    "\n",
    "#.LL.L#.##\n",
    "#LLLLLL.L#\n",
    "L.L.L..L..\n",
    "#LLL.LL.L#\n",
    "#.LL.LL.LL\n",
    "#.LLLL#.##\n",
    "..L.L.....\n",
    "#LLLLLLLL#\n",
    "#.LLLLLL.L\n",
    "#.#LLLL.##\n",
    "\n",
    "This process continues for three more rounds:\n",
    "\n",
    "#.##.L#.##\n",
    "#L###LL.L#\n",
    "L.#.#..#..\n",
    "#L##.##.L#\n",
    "#.##.LL.LL\n",
    "#.###L#.##\n",
    "..#.#.....\n",
    "#L######L#\n",
    "#.LL###L.L\n",
    "#.#L###.##\n",
    "\n",
    "#.#L.L#.##\n",
    "#LLL#LL.L#\n",
    "L.L.L..#..\n",
    "#LLL.##.L#\n",
    "#.LL.LL.LL\n",
    "#.LL#L#.##\n",
    "..L.L.....\n",
    "#L#LLLL#L#\n",
    "#.LLLLLL.L\n",
    "#.#L#L#.##\n",
    "\n",
    "#.#L.L#.##\n",
    "#LLL#LL.L#\n",
    "L.#.L..#..\n",
    "#L##.##.L#\n",
    "#.#L.LL.LL\n",
    "#.#L#L#.##\n",
    "..L.L.....\n",
    "#L#L##L#L#\n",
    "#.LLLLLL.L\n",
    "#.#L#L#.##\n",
    "\n",
    "At this point, something interesting happens: the chaos stabilizes and further applications of these rules cause no seats to change state! Once people stop moving around, you count 37 occupied seats.\n",
    "\n",
    "Simulate your seating area by applying the seating rules repeatedly until no seats change state. How many seats end up occupied?\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "There are 2251 valid seats.\n"
     ]
    }
   ],
   "source": [
    "# read data file\n",
    "f = open('d11-input.txt', 'r')\n",
    "data = [line.rstrip() for line in f.readlines()]\n",
    "\n",
    "#test data\n",
    "#data = [\"L.LL.LL.LL\",\"LLLLLLL.LL\",\"L.L.L..L..\",\"LLLL.LL.LL\",\"L.LL.LL.LL\",\"L.LLLLL.LL\",\"..L.L.....\",\"LLLLLLLLLL\",\"L.LLLLLL.L\",\"L.LLLLL.LL\"]\n",
    "\n",
    "# ensure input data in list\n",
    "data = [list(line) for line in data]\n",
    "\n",
    "rowWidth = len(data[0])\n",
    "numRows = len(data)\n",
    "deltas = [(-1,-1),(-1,0),(-1,1),(0,-1),(0,1),(1,-1),(1,0),(1,1)]\n",
    "\n",
    "def count_occupied(row,col,grid):\n",
    "\tcount = 0\n",
    "\tfor i,j in deltas:\n",
    "\t\txi,xj = row+i,col+j \n",
    "\t\tif 0<=xi<numRows and 0 <=xj<rowWidth and grid[xi][xj] == \"#\":\n",
    "\t\t\tcount += 1\n",
    "\treturn count\n",
    "\n",
    "def check_occupied(lines, thresh = 4):\n",
    "\twhile True:\n",
    "\t\tvalid = True\n",
    "\t\ttemp_grid=[r.copy() for r in lines]\n",
    "\t\tfor i,r in enumerate(temp_grid):\n",
    "\t\t\tfor j,c in enumerate(r):\n",
    "\t\t\t\tcount = count_occupied(i,j,temp_grid)\n",
    "\t\t\t\tif c == \"L\" and count ==0:\n",
    "\t\t\t\t\tlines[i][j] = \"#\"\n",
    "\t\t\t\telif c == \"#\" and count >=thresh:\n",
    "\t\t\t\t\tlines[i][j]=\"L\"\n",
    "\t\t\t\tvalid&=(r[j]==lines[i][j])\n",
    "\t\tif valid:\n",
    "\t\t\tbreak\n",
    "\tans = 0\n",
    "\tfor i in range(numRows):\n",
    "\t\tfor j in range(rowWidth):\n",
    "\t\t\tif lines[i][j] == \"#\":\n",
    "\t\t\t\tans += 1\n",
    "\tprint(f\"There are {ans} valid seats.\")\n",
    "check_occupied(data)"
   ]
  },
  {
   "source": [
    "### --- Seating System ---\n",
    "### --- Part Two ---\n",
    "\n",
    "As soon as people start to arrive, you realize your mistake. People don't just care about adjacent seats - they care about the first seat they can see in each of those eight directions!\n",
    "\n",
    "Now, instead of considering just the eight immediately adjacent seats, consider the first seat in each of those eight directions. For example, the empty seat below would see eight occupied seats:\n",
    "\n",
    ".......#.\n",
    "...#.....\n",
    ".#.......\n",
    ".........\n",
    "..#L....#\n",
    "....#....\n",
    ".........\n",
    "#........\n",
    "...#.....\n",
    "\n",
    "The leftmost empty seat below would only see one empty seat, but cannot see any of the occupied ones:\n",
    "\n",
    ".............\n",
    ".L.L.#.#.#.#.\n",
    ".............\n",
    "\n",
    "The empty seat below would see no occupied seats:\n",
    "\n",
    ".##.##.\n",
    "#.#.#.#\n",
    "##...##\n",
    "...L...\n",
    "##...##\n",
    "#.#.#.#\n",
    ".##.##.\n",
    "\n",
    "Also, people seem to be more tolerant than you expected: it now takes five or more visible occupied seats for an occupied seat to become empty (rather than four or more from the previous rules). The other rules still apply: empty seats that see no occupied seats become occupied, seats matching no rule don't change, and floor never changes.\n",
    "\n",
    "Given the same starting layout as above, these new rules cause the seating area to shift around as follows:\n",
    "\n",
    "L.LL.LL.LL\n",
    "LLLLLLL.LL\n",
    "L.L.L..L..\n",
    "LLLL.LL.LL\n",
    "L.LL.LL.LL\n",
    "L.LLLLL.LL\n",
    "..L.L.....\n",
    "LLLLLLLLLL\n",
    "L.LLLLLL.L\n",
    "L.LLLLL.LL\n",
    "\n",
    "#.##.##.##\n",
    "#######.##\n",
    "#.#.#..#..\n",
    "####.##.##\n",
    "#.##.##.##\n",
    "#.#####.##\n",
    "..#.#.....\n",
    "##########\n",
    "#.######.#\n",
    "#.#####.##\n",
    "\n",
    "#.LL.LL.L#\n",
    "#LLLLLL.LL\n",
    "L.L.L..L..\n",
    "LLLL.LL.LL\n",
    "L.LL.LL.LL\n",
    "L.LLLLL.LL\n",
    "..L.L.....\n",
    "LLLLLLLLL#\n",
    "#.LLLLLL.L\n",
    "#.LLLLL.L#\n",
    "\n",
    "#.L#.##.L#\n",
    "#L#####.LL\n",
    "L.#.#..#..\n",
    "##L#.##.##\n",
    "#.##.#L.##\n",
    "#.#####.#L\n",
    "..#.#.....\n",
    "LLL####LL#\n",
    "#.L#####.L\n",
    "#.L####.L#\n",
    "\n",
    "#.L#.L#.L#\n",
    "#LLLLLL.LL\n",
    "L.L.L..#..\n",
    "##LL.LL.L#\n",
    "L.LL.LL.L#\n",
    "#.LLLLL.LL\n",
    "..L.L.....\n",
    "LLLLLLLLL#\n",
    "#.LLLLL#.L\n",
    "#.L#LL#.L#\n",
    "\n",
    "#.L#.L#.L#\n",
    "#LLLLLL.LL\n",
    "L.L.L..#..\n",
    "##L#.#L.L#\n",
    "L.L#.#L.L#\n",
    "#.L####.LL\n",
    "..#.#.....\n",
    "LLL###LLL#\n",
    "#.LLLLL#.L\n",
    "#.L#LL#.L#\n",
    "\n",
    "#.L#.L#.L#\n",
    "#LLLLLL.LL\n",
    "L.L.L..#..\n",
    "##L#.#L.L#\n",
    "L.L#.LL.L#\n",
    "#.LLLL#.LL\n",
    "..#.L.....\n",
    "LLL###LLL#\n",
    "#.LLLLL#.L\n",
    "#.L#LL#.L#\n",
    "\n",
    "Again, at this point, people stop shifting around and the seating area reaches equilibrium. Once this occurs, you count 26 occupied seats.\n",
    "\n",
    "Given the new visibility method and the rule change for occupied seats becoming empty, once equilibrium is reached, how many seats end up occupied?\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "There are 2019 valid seats.\n"
     ]
    }
   ],
   "source": [
    "# Found help at:\n",
    "# https://github.com/q-viper/Adevent-Of-Code-2020/blob/master/Advent%20of%20code.ipynb\n",
    "\n",
    "# read data file\n",
    "f = open('d11-input.txt', 'r')\n",
    "data = [line.rstrip() for line in f.readlines()]\n",
    "\n",
    "#test data\n",
    "#data = [\"L.LL.LL.LL\",\"LLLLLLL.LL\",\"L.L.L..L..\",\"LLLL.LL.LL\",\"L.LL.LL.LL\",\"L.LLLLL.LL\",\"..L.L.....\",\"LLLLLLLLLL\",\"L.LLLLLL.L\",\"L.LLLLL.LL\"]\n",
    "\n",
    "# ensure input data in list\n",
    "data = [list(line) for line in data]\n",
    "\n",
    "rowWidth = len(data[0])\n",
    "numRows = len(data)\n",
    "deltas = [(-1,-1),(-1,0),(-1,1),(0,-1),(0,1),(1,-1),(1,0),(1,1)]\n",
    "\n",
    "def count_occupied(row,col,grid):\n",
    "\tcount = 0\n",
    "\tfor i,j in deltas:\n",
    "\t\txi,xj = row+i,col+j\n",
    "\t\twhile 0 <= xi < numRows and 0<=xj<rowWidth:\n",
    "\t\t\tif grid[xi][xj] == \"#\":\n",
    "\t\t\t\tcount += 1\n",
    "\t\t\t\tbreak\n",
    "\t\t\telif grid[xi][xj] == \"L\":\n",
    "\t\t\t\tbreak\n",
    "\t\t\txi += i\n",
    "\t\t\txj += j\n",
    "\treturn count\n",
    "\n",
    "def check_occupied(lines, threshold = 5):\n",
    "\twhile True:\n",
    "\t\tvalid = True\n",
    "\t\ttemp_grid=[r.copy() for r in lines]\n",
    "\t\tfor i,r in enumerate(temp_grid):\n",
    "\t\t\tfor j,c in enumerate(r):\n",
    "\t\t\t\tcount = count_occupied(i,j,temp_grid)\n",
    "\t\t\t\tif c == \"L\" and count ==0:\n",
    "\t\t\t\t\tlines[i][j] = \"#\"\n",
    "\t\t\t\telif c == \"#\" and count >=threshold:\n",
    "\t\t\t\t\tlines[i][j]=\"L\"\n",
    "\t\t\t\tvalid&=(r[j]==lines[i][j])\n",
    "\t\tif valid:\n",
    "\t\t\tbreak\n",
    "\tans = 0\n",
    "\tfor i in range(numRows):\n",
    "\t\tfor j in range(rowWidth):\n",
    "\t\t\tif lines[i][j] == \"#\":\n",
    "\t\t\t\tans += 1\n",
    "\tprint(f\"There are {ans} valid seats.\")\n",
    "check_occupied(data)"
   ]
  },
  {
   "source": [
    "## Day 12:\n",
    "### --- Rain Risk ---\n",
    "\n",
    "Your ferry made decent progress toward the island, but the storm came in faster than anyone expected. The ferry needs to take evasive actions!\n",
    "\n",
    "Unfortunately, the ship's navigation computer seems to be malfunctioning; rather than giving a route directly to safety, it produced extremely circuitous instructions. When the captain uses the PA system to ask if anyone can help, you quickly volunteer.\n",
    "\n",
    "The navigation instructions (your puzzle input) consists of a sequence of single-character actions paired with integer input values. After staring at them for a few minutes, you work out what they probably mean:\n",
    "\n",
    "    Action N means to move north by the given value.\n",
    "    Action S means to move south by the given value.\n",
    "    Action E means to move east by the given value.\n",
    "    Action W means to move west by the given value.\n",
    "    Action L means to turn left the given number of degrees.\n",
    "    Action R means to turn right the given number of degrees.\n",
    "    Action F means to move forward by the given value in the direction the ship is currently facing.\n",
    "\n",
    "The ship starts by facing east. Only the L and R actions change the direction the ship is facing. (That is, if the ship is facing east and the next instruction is N10, the ship would move north 10 units, but would still move east if the following action were F.)\n",
    "\n",
    "For example:\n",
    "\n",
    "F10\n",
    "N3\n",
    "F7\n",
    "R90\n",
    "F11\n",
    "\n",
    "These instructions would be handled as follows:\n",
    "\n",
    "    F10 would move the ship 10 units east (because the ship starts by facing east) to east 10, north 0.\n",
    "    N3 would move the ship 3 units north to east 10, north 3.\n",
    "    F7 would move the ship another 7 units east (because the ship is still facing east) to east 17, north 3.\n",
    "    R90 would cause the ship to turn right by 90 degrees and face south; it remains at east 17, north 3.\n",
    "    F11 would move the ship 11 units south to east 17, south 8.\n",
    "\n",
    "At the end of these instructions, the ship's Manhattan distance (sum of the absolute values of its east/west position and its north/south position) from its starting position is 17 + 8 = 25.\n",
    "\n",
    "Figure out where the navigation instructions lead. What is the Manhattan distance between that location and the ship's starting position?\n",
    "\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Manhatten distance is: 1441\n"
     ]
    }
   ],
   "source": [
    "# read data file\n",
    "f = open('d12-input.txt', 'r')\n",
    "data = [line.rstrip() for line in f.readlines()]\n",
    "\n",
    "#test data\n",
    "# data = [\"F10\",\"N3\",\"F7\",\"R90\",\"F11\"]\n",
    "\n",
    "# ensure input data in list\n",
    "# data = [list(line) for line in data]\n",
    "\n",
    "directions = {\"E\",\"S\",\"W\",\"N\"}\n",
    "rotations = {\"L\",\"R\"}\n",
    "current_posn = {\"E\":0, \"S\":0, \"W\":0, \"N\":0}\n",
    "#dictionary of direction and current value\n",
    "# set starting facing direction to east\n",
    "# 90 degrees = E, 180 = S, 270 = W, 0/360 = N\n",
    "compass = 90 \n",
    "\n",
    "for line in data:\n",
    "    instruction = line[0]\n",
    "    value = int(line[1:])\n",
    "    if instruction == \"F\":\n",
    "        if compass == 0:\n",
    "            current_posn[\"N\"] += value\n",
    "        if compass == 90:\n",
    "            current_posn[\"E\"] += value\n",
    "        if compass == 180:\n",
    "            current_posn[\"S\"] += value\n",
    "        if compass == 270:\n",
    "            current_posn[\"W\"] += value\n",
    "    if instruction in directions:\n",
    "        current_posn[instruction] += value\n",
    "    if instruction in rotations:\n",
    "        if instruction == \"R\":\n",
    "            compass += value\n",
    "            compass = compass % 360\n",
    "        if instruction == \"L\":\n",
    "            compass -= value\n",
    "            compass = compass % 360\n",
    "    \n",
    "distance = (current_posn[\"E\"]-current_posn[\"W\"]) + (current_posn[\"S\"]- current_posn[\"N\"]) \n",
    "print(f\"Manhatten distance is: {distance}\")\n"
   ]
  },
  {
   "source": [
    "### --- Rain Risk ---\n",
    "### --- Part Two ---\n",
    "\n",
    "Before you can give the destination to the captain, you realize that the actual action meanings were printed on the back of the instructions the whole time.\n",
    "\n",
    "Almost all of the actions indicate how to move a waypoint which is relative to the ship's position:\n",
    "\n",
    "    Action N means to move the waypoint north by the given value.\n",
    "    Action S means to move the waypoint south by the given value.\n",
    "    Action E means to move the waypoint east by the given value.\n",
    "    Action W means to move the waypoint west by the given value.\n",
    "    Action L means to rotate the waypoint around the ship left (counter-clockwise) the given number of degrees.\n",
    "    Action R means to rotate the waypoint around the ship right (clockwise) the given number of degrees.\n",
    "    Action F means to move forward to the waypoint a number of times equal to the given value.\n",
    "\n",
    "The waypoint starts 10 units east and 1 unit north relative to the ship. The waypoint is relative to the ship; that is, if the ship moves, the waypoint moves with it.\n",
    "\n",
    "For example, using the same instructions as above:\n",
    "\n",
    "    F10 moves the ship to the waypoint 10 times (a total of 100 units east and 10 units north), leaving the ship at east 100, north 10. The waypoint stays 10 units east and 1 unit north of the ship.\n",
    "    N3 moves the waypoint 3 units north to 10 units east and 4 units north of the ship. The ship remains at east 100, north 10.\n",
    "    F7 moves the ship to the waypoint 7 times (a total of 70 units east and 28 units north), leaving the ship at east 170, north 38. The waypoint stays 10 units east and 4 units north of the ship.\n",
    "    R90 rotates the waypoint around the ship clockwise 90 degrees, moving it to 4 units east and 10 units south of the ship. The ship remains at east 170, north 38.\n",
    "    F11 moves the ship to the waypoint 11 times (a total of 44 units east and 110 units south), leaving the ship at east 214, south 72. The waypoint stays 4 units east and 10 units south of the ship.\n",
    "\n",
    "After these operations, the ship's Manhattan distance from its starting position is 214 + 72 = 286.\n",
    "\n",
    "Figure out where the navigation instructions actually lead. What is the Manhattan distance between that location and the ship's starting position?\n",
    "\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Manhatten distance is: 61616\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "# read data file\n",
    "f = open('d12-input.txt', 'r')\n",
    "data = [line.rstrip() for line in f.readlines()]\n",
    "\n",
    "# routine to rotate waypoint in E-N (x-y) plane\n",
    "def rotate(origin, point, angle):\n",
    "    # source: https://stackoverflow.com/a/34374437\n",
    "    ox, oy = origin\n",
    "    px, py = point\n",
    "    qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\n",
    "    qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\n",
    "    return int(round(qx)), int(round(qy))\n",
    "\n",
    "#test data\n",
    "#data = [\"F10\",\"N3\",\"F7\",\"R90\",\"F11\"]\n",
    "\n",
    "# ensure input data in list\n",
    "# data = [list(line) for line in data]\n",
    "\n",
    "directions = {\"E\",\"S\",\"W\",\"N\"}\n",
    "rotations = {\"L\",\"R\"}\n",
    "\n",
    "#dictionary of directions and set initial value\n",
    "shipPosn = {\"E\":0 , \"N\":0} # W and S indicated by negative values\n",
    "waypoint = {\"E\":10, \"N\":1} # W and S indicated by negative\n",
    "\n",
    "for line in data:\n",
    "\tinstruction = line[0]\n",
    "\tvalue = int(line[1:])\n",
    "\tif instruction == \"F\":\n",
    "\t\tshipPosn[\"N\"] += waypoint[\"N\"] * value\n",
    "\t\tshipPosn[\"E\"] += waypoint[\"E\"] * value\n",
    "\tif instruction in directions:\n",
    "\t\tif instruction in {\"W\", \"S\"}:\n",
    "\t\t\tvalue = -value\n",
    "\t\t\tif instruction == \"W\":\n",
    "\t\t\t\tinstruction = \"E\"\n",
    "\t\t\telif instruction == \"S\":\n",
    "\t\t\t\tinstruction = \"N\"\n",
    "\t\twaypoint[instruction] += value\n",
    "\tif instruction in rotations:\n",
    "\t\tif instruction == \"R\":\n",
    "\t\t\tvalue = - value\n",
    "\t\twaypoint['E'], waypoint['N'] = rotate((0, 0), (waypoint['E'], waypoint['N']), math.radians(value))\n",
    "\t\n",
    "distance = abs(shipPosn[\"E\"]) + abs(shipPosn[\"N\"])\n",
    "print(f\"Manhatten distance is: {distance}\")\n"
   ]
  },
  {
   "source": [
    "## Day 13:\n",
    "### --- Shuttle Search ---\n",
    "\n",
    "Your ferry can make it safely to a nearby port, but it won't get much further. When you call to book another ship, you discover that no ships embark from that port to your vacation island. You'll need to get from the port to the nearest airport.\n",
    "\n",
    "Fortunately, a shuttle bus service is available to bring you from the sea port to the airport! Each bus has an ID number that also indicates how often the bus leaves for the airport.\n",
    "\n",
    "Bus schedules are defined based on a timestamp that measures the number of minutes since some fixed reference point in the past. At timestamp 0, every bus simultaneously departed from the sea port. After that, each bus travels to the airport, then various other locations, and finally returns to the sea port to repeat its journey forever.\n",
    "\n",
    "The time this loop takes a particular bus is also its ID number: the bus with ID 5 departs from the sea port at timestamps 0, 5, 10, 15, and so on. The bus with ID 11 departs at 0, 11, 22, 33, and so on. If you are there when the bus departs, you can ride that bus to the airport!\n",
    "\n",
    "Your notes (your puzzle input) consist of two lines. The first line is your estimate of the earliest timestamp you could depart on a bus. The second line lists the bus IDs that are in service according to the shuttle company; entries that show x must be out of service, so you decide to ignore them.\n",
    "\n",
    "To save time once you arrive, your goal is to figure out the earliest bus you can take to the airport. (There will be exactly one such bus.)\n",
    "\n",
    "For example, suppose you have the following notes:\n",
    "\n",
    "939\n",
    "7,13,x,x,59,x,31,19\n",
    "Here, the earliest timestamp you could depart is 939, and the bus IDs in service are 7, 13, 59, 31, and 19. Near timestamp 939, these bus IDs depart at the times marked D:\n",
    "\n",
    "time   bus 7   bus 13  bus 59  bus 31  bus 19\n",
    "929      .       .       .       .       .\n",
    "930      .       .       .       D       .\n",
    "931      D       .       .       .       D\n",
    "932      .       .       .       .       .\n",
    "933      .       .       .       .       .\n",
    "934      .       .       .       .       .\n",
    "935      .       .       .       .       .\n",
    "936      .       D       .       .       .\n",
    "937      .       .       .       .       .\n",
    "938      D       .       .       .       .\n",
    "939      .       .       .       .       .\n",
    "940      .       .       .       .       .\n",
    "941      .       .       .       .       .\n",
    "942      .       .       .       .       .\n",
    "943      .       .       .       .       .\n",
    "944      .       .       D       .       .\n",
    "945      D       .       .       .       .\n",
    "946      .       .       .       .       .\n",
    "947      .       .       .       .       .\n",
    "948      .       .       .       .       .\n",
    "949      .       D       .       .       .\n",
    "The earliest bus you could take is bus ID 59. It doesn't depart until timestamp 944, so you would need to wait 944 - 939 = 5 minutes before it departs. Multiplying the bus ID by the number of minutes you'd need to wait gives 295.\n",
    "\n",
    "What is the ID of the earliest bus you can take to the airport multiplied by the number of minutes you'll need to wait for that bus?"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "earliest departure time: 1015297, delay: 5min, catch bus: 643\nanswer = 3215\n"
     ]
    }
   ],
   "source": [
    "# read data file\n",
    "f = open('d13-input.txt', 'r')\n",
    "data = [line.rstrip() for line in f.readlines()]\n",
    "# Test data\n",
    "# data = [\"939\",\"7,13,x,x,59,x,31,19\"]\n",
    "\n",
    "# splice timestamp from data\n",
    "timestamp = int(data[0])\n",
    "# split buscodes at ',' and remove 'x' and convert to integers\n",
    "buscodes = [int(line) for line in data[1].split(\",\") if line != \"x\"]\n",
    "\n",
    "noBus = True\n",
    "time = timestamp - 1\n",
    "while noBus:\n",
    "\ttime += 1\t\n",
    "\tfor bus in buscodes:\n",
    "\t\tif time % bus == 0:\n",
    "\t\t\tnoBus = False\n",
    "\t\t\tbreak\n",
    "\t\t\t\n",
    "print(f\"earliest departure time: {time}, delay: {time-timestamp}min, catch bus: {bus}\")\n",
    "print(f\"answer = {bus * (time-timestamp)}\")"
   ]
  },
  {
   "source": [
    "### --- Shuttle Search ---\n",
    "### --- Part Two ---\n",
    "\n",
    "The shuttle company is running a contest: one gold coin for anyone that can find the earliest timestamp such that the first bus ID departs at that time and each subsequent listed bus ID departs at that subsequent minute. (The first line in your input is no longer relevant.)\n",
    "\n",
    "For example, suppose you have the same list of bus IDs as above:\n",
    "\n",
    "7,13,x,x,59,x,31,19\n",
    "An x in the schedule means there are no constraints on what bus IDs must depart at that time.\n",
    "\n",
    "This means you are looking for the earliest timestamp (called t) such that:\n",
    "\n",
    "Bus ID 7 departs at timestamp t.\n",
    "Bus ID 13 departs one minute after timestamp t.\n",
    "There are no requirements or restrictions on departures at two or three minutes after timestamp t.\n",
    "Bus ID 59 departs four minutes after timestamp t.\n",
    "There are no requirements or restrictions on departures at five minutes after timestamp t.\n",
    "Bus ID 31 departs six minutes after timestamp t.\n",
    "Bus ID 19 departs seven minutes after timestamp t.\n",
    "The only bus departures that matter are the listed bus IDs at their specific offsets from t. Those bus IDs can depart at other times, and other bus IDs can depart at those times. For example, in the list above, because bus ID 19 must depart seven minutes after the timestamp at which bus ID 7 departs, bus ID 7 will always also be departing with bus ID 19 at seven minutes after timestamp t.\n",
    "\n",
    "In this example, the earliest timestamp at which this occurs is 1068781:\n",
    "\n",
    "time     bus 7   bus 13  bus 59  bus 31  bus 19\n",
    "1068773    .       .       .       .       .\n",
    "1068774    D       .       .       .       .\n",
    "1068775    .       .       .       .       .\n",
    "1068776    .       .       .       .       .\n",
    "1068777    .       .       .       .       .\n",
    "1068778    .       .       .       .       .\n",
    "1068779    .       .       .       .       .\n",
    "1068780    .       .       .       .       .\n",
    "1068781    D       .       .       .       .\n",
    "1068782    .       D       .       .       .\n",
    "1068783    .       .       .       .       .\n",
    "1068784    .       .       .       .       .\n",
    "1068785    .       .       D       .       .\n",
    "1068786    .       .       .       .       .\n",
    "1068787    .       .       .       D       .\n",
    "1068788    D       .       .       .       D\n",
    "1068789    .       .       .       .       .\n",
    "1068790    .       .       .       .       .\n",
    "1068791    .       .       .       .       .\n",
    "1068792    .       .       .       .       .\n",
    "1068793    .       .       .       .       .\n",
    "1068794    .       .       .       .       .\n",
    "1068795    D       D       .       .       .\n",
    "1068796    .       .       .       .       .\n",
    "1068797    .       .       .       .       .\n",
    "In the above example, bus ID 7 departs at timestamp 1068788 (seven minutes after t). This is fine; the only requirement on that minute is that bus ID 19 departs then, and it does.\n",
    "\n",
    "Here are some other examples:\n",
    "\n",
    "The earliest timestamp that matches the list 17,x,13,19 is 3417.\n",
    "67,7,59,61 first occurs at timestamp 754018.\n",
    "67,x,7,59,61 first occurs at timestamp 779210.\n",
    "67,7,x,59,61 first occurs at timestamp 1261476.\n",
    "1789,37,47,1889 first occurs at timestamp 1202161486.\n",
    "However, with so many bus IDs in your list, surely the actual earliest timestamp will be larger than 100000000000000!\n",
    "\n",
    "What is the earliest timestamp such that all of the listed bus IDs depart at offsets matching their positions in the list?"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "answer = 1001569619313439\n"
     ]
    }
   ],
   "source": [
    "# read data file\n",
    "f = open('d13-input.txt', 'r')\n",
    "data = [line.rstrip() for line in f.readlines()]\n",
    "# Test data\n",
    "# data = [\"939\",\"7,13,x,x,59,x,31,19\"]\n",
    "\n",
    "# splice timestamp from data\n",
    "timestamp = int(data[0])\n",
    "# split buscodes at ',' and remove 'x' and convert to integers\n",
    "buscodes = [\"x\" if line == \"x\" else int(line) for line in data[1].split(\",\")]\n",
    "\n",
    "mods = {bus: -i % bus for i, bus in enumerate(buscodes) if bus != \"x\"}\n",
    "times = list(reversed(sorted(mods)))\n",
    "timestamp = mods[times[0]]\n",
    "r = times[0]\n",
    "for b in times[1:]:\n",
    "\twhile timestamp % b != mods[b]:\n",
    "\t\ttimestamp += r\n",
    "\tr *= b\n",
    "\n",
    "print(f\"answer = {timestamp}\")"
   ]
  },
  {
   "source": [
    "## Day 14:\n",
    "### --- Docking Data ---\n",
    "\n",
    "As your ferry approaches the sea port, the captain asks for your help again. The computer system that runs this port isn't compatible with the docking program on the ferry, so the docking parameters aren't being correctly initialized in the docking program's memory.\n",
    "\n",
    "After a brief inspection, you discover that the sea port's computer system uses a strange bitmask system in its initialization program. Although you don't have the correct decoder chip handy, you can emulate it in software!\n",
    "\n",
    "The initialization program (your puzzle input) can either update the bitmask or write a value to memory. Values and memory addresses are both 36-bit unsigned integers. For example, ignoring bitmasks for a moment, a line like mem[8] = 11 would write the value 11 to memory address 8.\n",
    "\n",
    "The bitmask is always given as a string of 36 bits, written with the most significant bit (representing 2^35) on the left and the least significant bit (2^0, that is, the 1s bit) on the right. The current bitmask is applied to values immediately before they are written to memory: a 0 or 1 overwrites the corresponding bit in the value, while an X leaves the bit in the value unchanged.\n",
    "\n",
    "For example, consider the following program:\n",
    "\n",
    "mask = XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X\n",
    "mem[8] = 11\n",
    "mem[7] = 101\n",
    "mem[8] = 0\n",
    "This program starts by specifying a bitmask (mask = ....). The mask it specifies will overwrite two bits in every written value: the 2s bit is overwritten with 0, and the 64s bit is overwritten with 1.\n",
    "\n",
    "The program then attempts to write the value 11 to memory address 8. By expanding everything out to individual bits, the mask is applied as follows:\n",
    "\n",
    "value:  000000000000000000000000000000001011  (decimal 11)\n",
    "mask:   XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X\n",
    "result: 000000000000000000000000000001001001  (decimal 73)\n",
    "So, because of the mask, the value 73 is written to memory address 8 instead. Then, the program tries to write 101 to address 7:\n",
    "\n",
    "value:  000000000000000000000000000001100101  (decimal 101)\n",
    "mask:   XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X\n",
    "result: 000000000000000000000000000001100101  (decimal 101)\n",
    "This time, the mask has no effect, as the bits it overwrote were already the values the mask tried to set. Finally, the program tries to write 0 to address 8:\n",
    "\n",
    "value:  000000000000000000000000000000000000  (decimal 0)\n",
    "mask:   XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X\n",
    "result: 000000000000000000000000000001000000  (decimal 64)\n",
    "64 is written to address 8 instead, overwriting the value that was there previously.\n",
    "\n",
    "To initialize your ferry's docking program, you need the sum of all values left in memory after the initialization program completes. (The entire 36-bit address space begins initialized to the value 0 at every address.) In the above example, only two values in memory are not zero - 101 (at address 7) and 64 (at address 8) - producing a sum of 165.\n",
    "\n",
    "Execute the initialization program. What is the sum of all values left in memory after it completes?"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "sum of values = 11926135976176\n"
     ]
    }
   ],
   "source": [
    "# read data file\n",
    "f = open('d14-input.txt', 'r')\n",
    "data = [line.rstrip() for line in f.readlines()]\n",
    "# Test data\n",
    "# data = [\"mask = XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X\",\"mem[8] = 11\",\"mem[7] = 101\", \"mem[8] = 0\"]\n",
    "\n",
    "# define dictionary to store memory addresses\n",
    "memoryAddresses = []\n",
    "# loop though data and if new memoryadress add to list\n",
    "for line in data:\n",
    "    if line[:4] == \"mem[\":\n",
    "        #splice the memory address and value from string\n",
    "        memAddr = int(line[line.index(\"[\")+1:line.index(\"]\")])\n",
    "        if memAddr in memoryAddresses:\n",
    "            continue\n",
    "        else:\n",
    "            memoryAddresses.append(memAddr)\n",
    "# use list of memory addresses to define dictionary\n",
    "memory = {i:0 for i in memoryAddresses}\n",
    "\n",
    "for line in data:\n",
    "    if line[:4] == \"mask\":\n",
    "        bitmask = line[7:]\n",
    "# convert decimal to 36 bit binary: print(format(32, '#038b').replace(\"0b\",\"\"))\n",
    "    if line[:4] == \"mem[\":\n",
    "        #splice the memory address and value from string\n",
    "        memAddr = int(line[line.index(\"[\")+1:line.index(\"]\")])\n",
    "        value = line[line.index(\"=\")+2:]\n",
    "        # convert value to 36 bit binary (bin adds 0b to end - once removed 38 length number becomes 36)\n",
    "        valueBin = format(int(value), '#038b').replace(\"0b\",\"\")\n",
    "        newValueBin = \"\"\n",
    "        # apply bitmask to valueBin to produce newValueBin\n",
    "        for idx,digit in enumerate(bitmask):\n",
    "            if digit == \"X\":\n",
    "                newValueBin += valueBin[idx]\n",
    "            if digit == \"1\":\n",
    "                newValueBin += \"1\"\n",
    "            if digit == \"0\":\n",
    "                newValueBin += \"0\"\n",
    "        # store newValueBin in memory slot memAddr\n",
    "        memory[memAddr] = int(newValueBin,2)\n",
    "# sum all non-zero value in memory{}\n",
    "total = 0\n",
    "for i in memory:\n",
    "    if memory[i] >0:\n",
    "        total += memory[i]\n",
    "print(f\"sum of values = {total}\")\n"
   ]
  },
  {
   "source": [
    "### --- Docking Data ---\n",
    "### --- Part Two ---\n",
    "\n",
    "For some reason, the sea port's computer system still can't communicate with your ferry's docking program. It must be using version 2 of the decoder chip!\n",
    "\n",
    "A version 2 decoder chip doesn't modify the values being written at all. Instead, it acts as a memory address decoder. Immediately before a value is written to memory, each bit in the bitmask modifies the corresponding bit of the destination memory address in the following way:\n",
    "\n",
    "    If the bitmask bit is 0, the corresponding memory address bit is unchanged.\n",
    "    If the bitmask bit is 1, the corresponding memory address bit is overwritten with 1.\n",
    "    If the bitmask bit is X, the corresponding memory address bit is floating.\n",
    "\n",
    "A floating bit is not connected to anything and instead fluctuates unpredictably. In practice, this means the floating bits will take on all possible values, potentially causing many memory addresses to be written all at once!\n",
    "\n",
    "For example, consider the following program:\n",
    "\n",
    "mask = 000000000000000000000000000000X1001X\n",
    "mem[42] = 100\n",
    "mask = 00000000000000000000000000000000X0XX\n",
    "mem[26] = 1\n",
    "\n",
    "When this program goes to write to memory address 42, it first applies the bitmask:\n",
    "\n",
    "address: 000000000000000000000000000000101010  (decimal 42)\n",
    "mask:    000000000000000000000000000000X1001X\n",
    "result:  000000000000000000000000000000X1101X\n",
    "\n",
    "After applying the mask, four bits are overwritten, three of which are different, and two of which are floating. Floating bits take on every possible combination of values; with two floating bits, four actual memory addresses are written:\n",
    "\n",
    "000000000000000000000000000000011010  (decimal 26)\n",
    "000000000000000000000000000000011011  (decimal 27)\n",
    "000000000000000000000000000000111010  (decimal 58)\n",
    "000000000000000000000000000000111011  (decimal 59)\n",
    "\n",
    "Next, the program is about to write to memory address 26 with a different bitmask:\n",
    "\n",
    "address: 000000000000000000000000000000011010  (decimal 26)\n",
    "mask:    00000000000000000000000000000000X0XX\n",
    "result:  00000000000000000000000000000001X0XX\n",
    "\n",
    "This results in an address with three floating bits, causing writes to eight memory addresses:\n",
    "\n",
    "000000000000000000000000000000010000  (decimal 16)\n",
    "000000000000000000000000000000010001  (decimal 17)\n",
    "000000000000000000000000000000010010  (decimal 18)\n",
    "000000000000000000000000000000010011  (decimal 19)\n",
    "000000000000000000000000000000011000  (decimal 24)\n",
    "000000000000000000000000000000011001  (decimal 25)\n",
    "000000000000000000000000000000011010  (decimal 26)\n",
    "000000000000000000000000000000011011  (decimal 27)\n",
    "\n",
    "The entire 36-bit address space still begins initialized to the value 0 at every address, and you still need the sum of all values left in memory at the end of the program. In this example, the sum is 208.\n",
    "\n",
    "Execute the initialization program using an emulator for a version 2 decoder chip. What is the sum of all values left in memory after it completes?\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"d14-input.txt\", 'r') as fp:\n",
    "    lines = [line.rstrip() for line in fp.readlines()]\n",
    "masks=[]\n",
    "memory = {}\n",
    "for line in lines:\n",
    "    k, v = line.split(\" = \")\n",
    "    if k == \"mask\":\n",
    "        masks.append(v)\n",
    "        curr_mask = v\n",
    "    else:\n",
    "        # get address\n",
    "        curr_address = int(k[4:-1])\n",
    "        curr_value = int(v)       \n",
    "        \n",
    "        bin_add = list(bin(curr_address)[2:].zfill(36))\n",
    "        new_add = [\"0\"] * 36\n",
    "        \n",
    "        v = len(list(bin(curr_address)[2:]))\n",
    "                \n",
    "        for i, (mask, value) in enumerate(zip(curr_mask, bin_add)):\n",
    "            # if mask bit is floating then keep it floating on new address too\n",
    "            if mask == \"X\":\n",
    "                new_add[i] = \"X\"\n",
    "            elif mask == \"0\":\n",
    "                \n",
    "                # change value to mask else\n",
    "                new_add[i] = value\n",
    "            elif mask == \"1\":\n",
    "                new_add[i] = \"1\"\n",
    "        \n",
    "        new_add = \"\".join(new_add)\n",
    "        \n",
    "        # count floatings\n",
    "        num_poss = new_add.count(\"X\")\n",
    "        \n",
    "        flucts = []\n",
    "        for i in range(2**num_poss):\n",
    "            flucts.append( list(bin(i)[2:].zfill(num_poss)))\n",
    "\n",
    "        for fluct in flucts:\n",
    "            i = 0\n",
    "            nadd = \"\"\n",
    "            for a in new_add:\n",
    "                if a == \"X\":\n",
    "                    nadd+=str(fluct[i])\n",
    "                    i+=1\n",
    "                else:\n",
    "                    nadd+=str(a)\n",
    "            memory[int(nadd, 2)]=curr_value\n",
    "print(sum(memory.values()))\n"
   ]
  },
  {
   "source": [
    "## Day 15:\n",
    "### --- Rambunctious Recitation ---\n",
    "\n",
    "You catch the airport shuttle and try to book a new flight to your vacation island. Due to the storm, all direct flights have been cancelled, but a route is available to get around the storm. You take it.\n",
    "\n",
    "While you wait for your flight, you decide to check in with the Elves back at the North Pole. They're playing a memory game and are ever so excited to explain the rules!\n",
    "\n",
    "In this game, the players take turns saying numbers. They begin by taking turns reading from a list of starting numbers (your puzzle input). Then, each turn consists of considering the most recently spoken number:\n",
    "\n",
    "    If that was the first time the number has been spoken, the current player says 0.\n",
    "    Otherwise, the number had been spoken before; the current player announces how many turns apart the number is from when it was previously spoken.\n",
    "\n",
    "So, after the starting numbers, each turn results in that player speaking aloud either 0 (if the last number is new) or an age (if the last number is a repeat).\n",
    "\n",
    "For example, suppose the starting numbers are 0,3,6:\n",
    "\n",
    "    Turn 1: The 1st number spoken is a starting number, 0.\n",
    "    Turn 2: The 2nd number spoken is a starting number, 3.\n",
    "    Turn 3: The 3rd number spoken is a starting number, 6.\n",
    "    Turn 4: Now, consider the last number spoken, 6. Since that was the first time the number had been spoken, the 4th number spoken is 0.\n",
    "    Turn 5: Next, again consider the last number spoken, 0. Since it had been spoken before, the next number to speak is the difference between the turn number when it was last spoken (the previous turn, 4) and the turn number of the time it was most recently spoken before then (turn 1). Thus, the 5th number spoken is 4 - 1, 3.\n",
    "    Turn 6: The last number spoken, 3 had also been spoken before, most recently on turns 5 and 2. So, the 6th number spoken is 5 - 2, 3.\n",
    "    Turn 7: Since 3 was just spoken twice in a row, and the last two turns are 1 turn apart, the 7th number spoken is 1.\n",
    "    Turn 8: Since 1 is new, the 8th number spoken is 0.\n",
    "    Turn 9: 0 was last spoken on turns 8 and 4, so the 9th number spoken is the difference between them, 4.\n",
    "    Turn 10: 4 is new, so the 10th number spoken is 0.\n",
    "\n",
    "(The game ends when the Elves get sick of playing or dinner is ready, whichever comes first.)\n",
    "\n",
    "Their question for you is: what will be the 2020th number spoken? In the example above, the 2020th number spoken will be 436.\n",
    "\n",
    "Here are a few more examples:\n",
    "\n",
    "    Given the starting numbers 1,3,2, the 2020th number spoken is 1.\n",
    "    Given the starting numbers 2,1,3, the 2020th number spoken is 10.\n",
    "    Given the starting numbers 1,2,3, the 2020th number spoken is 27.\n",
    "    Given the starting numbers 2,3,1, the 2020th number spoken is 78.\n",
    "    Given the starting numbers 3,2,1, the 2020th number spoken is 438.\n",
    "    Given the starting numbers 3,1,2, the 2020th number spoken is 1836.\n",
    "\n",
    "Given your starting numbers, what will be the 2020th number spoken?\n",
    "\n",
    "Your puzzle input is 0,5,4,1,10,14,7."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2020 203\n"
     ]
    }
   ],
   "source": [
    "# given data set of starting numbers\n",
    "data = [0,5,4,1,10,14,7]\n",
    "\n",
    "# test data\n",
    "# data = [0,3,6]\n",
    "\n",
    "spokenNumbers = {} #{i:0 for i in data}\n",
    "turn = 0\n",
    "spoken= data[0]\n",
    "\n",
    "# loop through starting numbers\n",
    "for idx, number in enumerate(data):\n",
    "\tturn += 1\n",
    "\tspoken = number\n",
    "\t# if in the dictionary, the difference in turns since last spoken becomes new spoken and update the turn spoken in dictionary\n",
    "\tif spoken in spokenNumbers.keys():\n",
    "\t\tspokenNumbers[spoken]=turn - spokenNumbers[spoken]\n",
    "\tif not(spoken in spokenNumbers.keys()):\n",
    "\t\tspokenNumbers[spoken]=turn\n",
    "\t\tspoken = 0\n",
    "\n",
    "# loop to target value\n",
    "while turn < 2020:\n",
    "\tturn += 1\n",
    "\tif turn == 2020: print(turn, spoken)\n",
    "\n",
    "\t# if in the dictionary, the difference in turns since last spoken becomes new spoken and update the turn spoken in dictionary\n",
    "\tif spoken in spokenNumbers.keys():\n",
    "\t\tnextspoken = turn - spokenNumbers[spoken]\n",
    "\t\tspokenNumbers[spoken]=turn\n",
    "\n",
    "\telse:\n",
    "\t\tspokenNumbers[spoken]=turn\n",
    "\t\tnextspoken=0\n",
    "\tspoken = nextspoken\n",
    "\n"
   ]
  },
  {
   "source": [
    "### --- Rambunctious Recitation ---\n",
    "### --- Part Two ---\n",
    "\n",
    "Impressed, the Elves issue you a challenge: determine the 30000000th number spoken. For example, given the same starting numbers as above:\n",
    "\n",
    "Given 0,3,6, the 30000000th number spoken is 175594.\n",
    "Given 1,3,2, the 30000000th number spoken is 2578.\n",
    "Given 2,1,3, the 30000000th number spoken is 3544142.\n",
    "Given 1,2,3, the 30000000th number spoken is 261214.\n",
    "Given 2,3,1, the 30000000th number spoken is 6895259.\n",
    "Given 3,2,1, the 30000000th number spoken is 18.\n",
    "Given 3,1,2, the 30000000th number spoken is 362.\n",
    "Given your starting numbers, what will be the 30000000th number spoken?\n",
    "\n",
    "Answer:  \n",
    "\n",
    "Your puzzle input is still 0,5,4,1,10,14,7."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "30000000 9007186\n"
     ]
    }
   ],
   "source": [
    "# given data set of starting numbers\n",
    "data = [0,5,4,1,10,14,7]\n",
    "\n",
    "# test data\n",
    "# data = [0,3,6]\n",
    "\n",
    "spokenNumbers = {} #{i:0 for i in data}\n",
    "turn = 0\n",
    "spoken= data[0]\n",
    "\n",
    "# loop through starting numbers\n",
    "for idx, number in enumerate(data):\n",
    "\tturn += 1\n",
    "\tspoken = number\n",
    "\t# if in the dictionary, the difference in turns since last spoken becomes new spoken and update the turn spoken in dictionary\n",
    "\tif spoken in spokenNumbers.keys():\n",
    "\t\tspokenNumbers[spoken]=turn - spokenNumbers[spoken]\n",
    "\tif not(spoken in spokenNumbers.keys()):\n",
    "\t\tspokenNumbers[spoken]=turn\n",
    "\t\tspoken = 0\n",
    "\n",
    "# loop to target value\n",
    "# part 1 target = 2020, part 2 target = 3e7\n",
    "target = 3e7\n",
    "while turn < target:\n",
    "\tturn += 1\n",
    "\tif turn == target:\n",
    "\t\tprint(turn, spoken)\n",
    "\n",
    "\t# if in the dictionary, the difference in turns since last spoken becomes new spoken and update the turn spoken in dictionary\n",
    "\tif spoken in spokenNumbers.keys():\n",
    "\t\tnextspoken = turn - spokenNumbers[spoken]\n",
    "\t\tspokenNumbers[spoken]=turn\n",
    "\t# if not in dictionary, add to dictionary, give value of the turn added and next number to speak becomes zero\n",
    "\telse:\n",
    "\t\tspokenNumbers[spoken]=turn\n",
    "\t\tnextspoken=0\n",
    "\tspoken = nextspoken\n"
   ]
  },
  {
   "source": [
    "## Day 16:\n",
    "### --- Ticket Translation ---\n",
    "\n",
    "As you're walking to yet another connecting flight, you realize that one of the legs of your re-routed trip coming up is on a high-speed train. However, the train ticket you were given is in a language you don't understand. You should probably figure out what it says before you get to the train station after the next flight.\n",
    "\n",
    "Unfortunately, you can't actually read the words on the ticket. You can, however, read the numbers, and so you figure out the fields these tickets must have and the valid ranges for values in those fields.\n",
    "\n",
    "You collect the rules for ticket fields, the numbers on your ticket, and the numbers on other nearby tickets for the same train service (via the airport security cameras) together into a single document you can reference (your puzzle input).\n",
    "\n",
    "The rules for ticket fields specify a list of fields that exist somewhere on the ticket and the valid ranges of values for each field. For example, a rule like class: 1-3 or 5-7 means that one of the fields in every ticket is named class and can be any value in the ranges 1-3 or 5-7 (inclusive, such that 3 and 5 are both valid in this field, but 4 is not).\n",
    "\n",
    "Each ticket is represented by a single line of comma-separated values. The values are the numbers on the ticket in the order they appear; every ticket has the same format. For example, consider this ticket:\n",
    "\n",
    ".--------------------------------------------------------.\n",
    "| ????: 101    ?????: 102   ??????????: 103     ???: 104 |\n",
    "|                                                        |\n",
    "| ??: 301  ??: 302             ???????: 303      ??????? |\n",
    "| ??: 401  ??: 402           ???? ????: 403    ????????? |\n",
    "'--------------------------------------------------------'\n",
    "\n",
    "Here, ? represents text in a language you don't understand. This ticket might be represented as 101,102,103,104,301,302,303,401,402,403; of course, the actual train tickets you're looking at are much more complicated. In any case, you've extracted just the numbers in such a way that the first number is always the same specific field, the second number is always a different specific field, and so on - you just don't know what each position actually means!\n",
    "\n",
    "Start by determining which tickets are completely invalid; these are tickets that contain values which aren't valid for any field. Ignore your ticket for now.\n",
    "\n",
    "For example, suppose you have the following notes:\n",
    "\n",
    "class: 1-3 or 5-7\n",
    "row: 6-11 or 33-44\n",
    "seat: 13-40 or 45-50\n",
    "\n",
    "your ticket:\n",
    "7,1,14\n",
    "\n",
    "nearby tickets:\n",
    "7,3,47\n",
    "40,4,50\n",
    "55,2,20\n",
    "38,6,12\n",
    "\n",
    "It doesn't matter which position corresponds to which field; you can identify invalid nearby tickets by considering only whether tickets contain values that are not valid for any field. In this example, the values on the first nearby ticket are all valid for at least one field. This is not true of the other three nearby tickets: the values 4, 55, and 12 are are not valid for any field. Adding together all of the invalid values produces your ticket scanning error rate: 4 + 55 + 12 = 71.\n",
    "\n",
    "Consider the validity of the nearby tickets you scanned. What is your ticket scanning error rate?\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "ticket scanning error rate = 21996\n"
     ]
    }
   ],
   "source": [
    "# read data file\n",
    "f = open('d16-input.txt', 'r')\n",
    "data = [line.rstrip() for line in f.readlines()]\n",
    "# Test data\n",
    "# data = [\"class: 1-3 or 5-7\",\"row: 6-11 or 33-44\",\"seat: 13-40 or 45-50\",\"your ticket:\",\"7,1,14\",\"\",\"nearby tickets:\",\"7,3,47\",\"40,4,50\",\"55,2,20\",\"38,6,12\"]\n",
    "\n",
    "# Split data into areas - fields, my ticket, nearby tickets\n",
    "fields, myTicket, nearbyTickets = {}, [], []\n",
    "# split fields into dictionary with class type, min and max values\n",
    "for idx, line in enumerate(data):\n",
    "    if line == \"\": continue\n",
    "    if line[:11] == \"your ticket\":\n",
    "        break\n",
    "    # split the line into text before the colon to form the key, then the value pairs afer the colon seperated by ' or ' to form value pairs\n",
    "    fields[line.split(\": \")[0]] = (line.split(\": \")[1].split(\" or \")[0], line.split(\": \")[1].split(\" or \")[1])\n",
    "    #the min of the min value\n",
    "    min_min = int(fields[line.split(\": \")[0]][0].split(\"-\")[0])\n",
    "    # the max of the min value\n",
    "    min_max = int(fields[line.split(\": \")[0]][0].split(\"-\")[1])\n",
    "    #the min of the max value\n",
    "    max_min = int(fields[line.split(\": \")[0]][1].split(\"-\")[0])\n",
    "    #the max of the max value\n",
    "    max_max = int(fields[line.split(\": \")[0]][1].split(\"-\")[1])\n",
    "    # redefine the dictionary entry with new min/max values\n",
    "    fields[line.split(\": \")[0]] = (min_min, min_max, max_min, max_max)\n",
    "# split myTicket data into list\n",
    "for line in data[idx+1:]:\n",
    "    if line == \"\": continue\n",
    "    if line[:14] == \"nearby tickets\":\n",
    "        break\n",
    "    myTicket.append(line)\n",
    "# split nearbyTicket data into list\n",
    "for line in data[idx+4:]:\n",
    "    if line == \"\": continue\n",
    "    nearbyTickets.append(line)\n",
    "\n",
    "# ignore my ticket\n",
    "# loop though each field, and compare ticket values to given parameters\n",
    "# store sum of invalid parameters\n",
    "# can combine all parameters into one set to compare with each line of list\n",
    "validParams = set() # define empty set\n",
    "ticketScanningErrorRate = 0\n",
    "# add paramteters to set as union of sets of values from fields\n",
    "for keys in fields:\n",
    "    for idx in range(0,len(fields[keys])-1,2):\n",
    "        validParams = validParams | set(range(fields[keys][idx],fields[keys][idx+1]+1))\n",
    "# loop though nearbyTickets and sum values not in parameters\n",
    "for line in nearbyTickets:\n",
    "    values = line.split(\",\")\n",
    "    for value in values:\n",
    "        ticketScanningErrorRate += int(not(int(value) in validParams)) * int(value)\n",
    "print(\"ticket scanning error rate =\",ticketScanningErrorRate)"
   ]
  },
  {
   "source": [
    "### --- Ticket Translation ---\n",
    "### --- Part Two ---\n",
    "\n",
    "Now that you've identified which tickets contain invalid values, discard those tickets entirely. Use the remaining valid tickets to determine which field is which.\n",
    "\n",
    "Using the valid ranges for each field, determine what order the fields appear on the tickets. The order is consistent between all tickets: if seat is the third field, it is the third field on every ticket, including your ticket.\n",
    "\n",
    "For example, suppose you have the following notes:\n",
    "\n",
    "class: 0-1 or 4-19\n",
    "row: 0-5 or 8-19\n",
    "seat: 0-13 or 16-19\n",
    "\n",
    "your ticket:\n",
    "11,12,13\n",
    "\n",
    "nearby tickets:\n",
    "3,9,18\n",
    "15,1,5\n",
    "5,14,9\n",
    "\n",
    "Based on the nearby tickets in the above example, the first position must be row, the second position must be class, and the third position must be seat; you can conclude that in your ticket, class is 12, row is 11, and seat is 13.\n",
    "\n",
    "Once you work out which field is which, look for the six fields on your ticket that start with the word departure. What do you get if you multiply those six values together?\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "error",
     "ename": "StopIteration",
     "evalue": "",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-c4e36756521d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     77\u001b[0m \u001b[0;31m## answer calculated as 650080463519\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     78\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msorted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpossibleFields\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpossibleFields\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 79\u001b[0;31m     \u001b[0mthisField\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpossibleFields\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     80\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mpossibleFields\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     81\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mj\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# read data file\n",
    "f = open('d16-input.txt', 'r')\n",
    "data = [line.rstrip() for line in f.readlines()]\n",
    "# Test data\n",
    "# data = [\"class: 1-3 or 5-7\",\"row: 6-11 or 33-44\",\"seat: 13-40 or 45-50\",\"your ticket:\",\"7,1,14\",\"\",\"nearby tickets:\",\"7,3,47\",\"40,4,50\",\"55,2,20\",\"38,6,12\"]\n",
    "\n",
    "# Split data into areas - fields, my ticket, nearby tickets\n",
    "fields, myTicket, nearbyTickets = {}, [], []\n",
    "# split fields into dictionary with class type, min and max values\n",
    "for idx, line in enumerate(data):\n",
    "    if line == \"\": continue\n",
    "    if line[:11] == \"your ticket\":\n",
    "        break\n",
    "    # split the line into text before the colon to form the key, then the value pairs afer the colon seperated by ' or ' to form value pairs\n",
    "    fields[line.split(\": \")[0]] = (line.split(\": \")[1].split(\" or \")[0], line.split(\": \")[1].split(\" or \")[1])\n",
    "    #the min of the min value\n",
    "    min_min = int(fields[line.split(\": \")[0]][0].split(\"-\")[0])\n",
    "    # the max of the min value\n",
    "    min_max = int(fields[line.split(\": \")[0]][0].split(\"-\")[1])\n",
    "    #the min of the max value\n",
    "    max_min = int(fields[line.split(\": \")[0]][1].split(\"-\")[0])\n",
    "    #the max of the max value\n",
    "    max_max = int(fields[line.split(\": \")[0]][1].split(\"-\")[1])\n",
    "    # redefine the dictionary entry with new min/max values\n",
    "    fields[line.split(\": \")[0]] = (min_min, min_max, max_min, max_max)\n",
    "# split myTicket data into list\n",
    "for line in data[idx+1:]:\n",
    "    if line == \"\": continue\n",
    "    if line[:14] == \"nearby tickets\":\n",
    "        break\n",
    "    myTicket.append(line)\n",
    "# split nearbyTicket data into list\n",
    "for line in data[idx+4:]:\n",
    "    if line == \"\": continue\n",
    "    nearbyTickets.append(line)\n",
    "# ignore my ticket\n",
    "# loop though each field, and compare ticket values to given parameters\n",
    "# store sum of invalid parameters\n",
    "# can combine all parameters into one set to compare with each line of list\n",
    "validParams = set() # define empty set\n",
    "ticketScanningErrorRate = 0\n",
    "# add paramteters to set as union of sets of values from fields\n",
    "for keys in fields:\n",
    "    validParams = validParams.union(set(range(fields[keys][0],fields[keys][1]+1)),set(range(fields[keys][2],fields[keys][3]+1)))\n",
    "# loop though nearbyTickets and identify invalid tickets\n",
    "inValid = set()\n",
    "validTickets = set()\n",
    "for ticket in nearbyTickets:\n",
    "    values = ticket.split(\",\")\n",
    "    for value in values:\n",
    "        if not(int(value) in validParams):\n",
    "            inValid.add(ticket)\n",
    "# remove inValid tickets and generaate list of validTickets\n",
    "validTickets = set(nearbyTickets).difference(inValid)\n",
    "\n",
    "# got some help here:\n",
    "# code below adapted from q-viper\n",
    "# a dictionary to hold possible fields for each col\n",
    "valid_tickets = list(validTickets)\n",
    "possibleFields = {i: set(fields.keys()) for i in range(len(validTickets))}\n",
    "for ticket in validTickets:\n",
    "    for i, value in enumerate(ticket.split(\",\")):\n",
    "        for keys in fields:\n",
    "            #validParaams is intersection of set on lower-range values and set of upper-range values\n",
    "            validParams = set(range(fields[keys][0],fields[keys][1]+1)) | set(range(fields[keys][2],fields[keys][3]+1))\n",
    "            possible = False\n",
    "            if int(value) in validParams:\n",
    "                possible = True\n",
    "            if not possible:\n",
    "                possibleFields[i].discard(keys)\n",
    "# remove repeated fields\n",
    "## having problem with this segment of code - returns StopIteration error at line 73\n",
    "## unable to trace source - something to do witht he way I've setup the lists???\n",
    "## used code from https://github.com/q-viper/Adevent-Of-Code-2020/blob/master/Advent%20of%20code.ipynb\n",
    "## and https://github.com/jakobsen/advent-of-code-2020/blob/master/16.py\n",
    "## to help check and develop my code - still stuck here...\n",
    "## answer calculated as 650080463519\n",
    "for i in sorted(possibleFields, key=lambda k: len(possibleFields[k])):\n",
    "    thisField = next(iter(possibleFields[i]))\n",
    "    for j in possibleFields:\n",
    "        if j != i:\n",
    "            possibleFields[j].discard(thisField)\n",
    "            \n",
    "myTicket = [int(x) for x in lines[22].split(\",\")]\n",
    "ans = 1\n",
    "for i in possibleFields:\n",
    "    if possibleFields[i].pop().startswith(\"departure\"):\n",
    "        ans *= myTicket[i]\n",
    "\n",
    "print(\"Part 2:\", ans)\n",
    "\n"
   ]
  },
  {
   "source": [
    "## Day 17:\n",
    "### --- Conway Cubes ---\n",
    "\n",
    "As your flight slowly drifts through the sky, the Elves at the Mythical Information Bureau at the North Pole contact you. They'd like some help debugging a malfunctioning experimental energy source aboard one of their super-secret imaging satellites.\n",
    "\n",
    "The experimental energy source is based on cutting-edge technology: a set of Conway Cubes contained in a pocket dimension! When you hear it's having problems, you can't help but agree to take a look.\n",
    "\n",
    "The pocket dimension contains an infinite 3-dimensional grid. At every integer 3-dimensional coordinate (x,y,z), there exists a single cube which is either active or inactive.\n",
    "\n",
    "In the initial state of the pocket dimension, almost all cubes start inactive. The only exception to this is a small flat region of cubes (your puzzle input); the cubes in this region start in the specified active (#) or inactive (.) state.\n",
    "\n",
    "The energy source then proceeds to boot up by executing six cycles.\n",
    "\n",
    "Each cube only ever considers its neighbors: any of the 26 other cubes where any of their coordinates differ by at most 1. For example, given the cube at x=1,y=2,z=3, its neighbors include the cube at x=2,y=2,z=2, the cube at x=0,y=2,z=3, and so on.\n",
    "\n",
    "During a cycle, all cubes simultaneously change their state according to the following rules:\n",
    "\n",
    "    If a cube is active and exactly 2 or 3 of its neighbors are also active, the cube remains active. Otherwise, the cube becomes inactive.\n",
    "    If a cube is inactive but exactly 3 of its neighbors are active, the cube becomes active. Otherwise, the cube remains inactive.\n",
    "\n",
    "The engineers responsible for this experimental energy source would like you to simulate the pocket dimension and determine what the configuration of cubes should be at the end of the six-cycle boot process.\n",
    "\n",
    "For example, consider the following initial state:\n",
    "```\n",
    ".#.\n",
    "..#\n",
    "###\n",
    "```\n",
    "\n",
    "Even though the pocket dimension is 3-dimensional, this initial state represents a small 2-dimensional slice of it. (In particular, this initial state defines a 3x3x1 region of the 3-dimensional space.)\n",
    "\n",
    "Simulating a few cycles from this initial state produces the following configurations, where the result of each cycle is shown layer-by-layer at each given z coordinate (and the frame of view follows the active cells in each cycle):\n",
    "\n",
    "Before any cycles:\n",
    "```\n",
    "z=0\n",
    ".#.\n",
    "..#\n",
    "###\n",
    "```\n",
    "\n",
    "After 1 cycle:\n",
    "```\n",
    "z=-1\n",
    "#..\n",
    "..#\n",
    ".#.\n",
    "\n",
    "z=0\n",
    "> #.#\n",
    "> .##\n",
    "> .#.\n",
    "\n",
    "z=1\n",
    "> #..\n",
    "> ..#\n",
    "> .#.\n",
    "```\n",
    "\n",
    "After 2 cycles:\n",
    "```\n",
    "z=-2\n",
    "> .....\n",
    "> .....\n",
    "> ..#..\n",
    "> .....\n",
    "> .....\n",
    "\n",
    "z=-1\n",
    "> ..#..\n",
    "> .#..#\n",
    "> ....#\n",
    "> .#...\n",
    "> .....\n",
    "\n",
    "z=0\n",
    "> ##...\n",
    "> ##...\n",
    "> #....\n",
    "> ....#\n",
    "> .###.\n",
    "\n",
    "z=1\n",
    "> ..#..\n",
    "> .#..#\n",
    "> ....#\n",
    "> .#...\n",
    "> .....\n",
    "\n",
    "z=2\n",
    "> .....\n",
    "> .....\n",
    "> ..#..\n",
    "> .....\n",
    "> .....\n",
    "```\n",
    "\n",
    "After 3 cycles:\n",
    "```\n",
    "z=-2\n",
    "> .......\n",
    "> .......\n",
    "> ..##...\n",
    "> ..###..\n",
    "> .......\n",
    "> .......\n",
    "> .......\n",
    "\n",
    "z=-1\n",
    "> ..#....\n",
    "> ...#...\n",
    "> #......\n",
    "> .....##\n",
    "> .#...#.\n",
    "> ..#.#..\n",
    "> ...#...\n",
    "\n",
    "z=0\n",
    "> ...#...\n",
    "> .......\n",
    "> #......\n",
    "> .......\n",
    "> .....##\n",
    "> .##.#..\n",
    "> ...#...\n",
    "\n",
    "z=1\n",
    "> ..#....\n",
    "> ...#...\n",
    "> #......\n",
    "> .....##\n",
    "> .#...#.\n",
    "> ..#.#..\n",
    "> ...#...\n",
    "\n",
    "z=2\n",
    "> .......\n",
    "> .......\n",
    "> ..##...\n",
    "> ..###..\n",
    "> .......\n",
    "> .......\n",
    "> .......\n",
    "```\n",
    "After the full six-cycle boot process completes, 112 cubes are left in the active state.\n",
    "\n",
    "Starting with your given initial configuration, simulate six cycles. How many cubes are left in the active state after the sixth cycle?\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Part 1 Solution: 353\n",
      "Part 2 Solution: 2472\n"
     ]
    }
   ],
   "source": [
    "def part1():\n",
    "    with open(\"d17-input.txt\") as fp:\n",
    "        lines = [fline.rstrip() for fline in fp.readlines()]\n",
    "        \n",
    "    f = lines \n",
    "    cubes = {(i, j, 0):lines[i][j] \n",
    "             for i in range(len(lines)) \n",
    "             for j in range(len(lines[0]))}\n",
    "    for i in range(6):\n",
    "        cubes = simulate(cubes)\n",
    "\n",
    "    print(f\"Part 1 Solution: {list(cubes.values()).count('#')}\")\n",
    "\n",
    "\n",
    "def simulate(cubes):\n",
    "    new_cube = {}\n",
    "    for c in cubes:\n",
    "        x = checkNeighbors(c, cubes)\n",
    "        if cubes[c] == '#':\n",
    "            if x == 2 or x == 3:\n",
    "                new_cube[c] = '#'\n",
    "            else:\n",
    "                new_cube[c] = '.'\n",
    "            n = findNeighbors(c)\n",
    "            for x in n:\n",
    "                if x not in cubes:\n",
    "                    k = checkNeighbors(x, cubes)\n",
    "                    if k == 3:\n",
    "                        new_cube[x] = '#'\n",
    "        elif cubes[c] == '.':\n",
    "            if x == 3:\n",
    "                new_cube[c] = '#'\n",
    "            else:\n",
    "                new_cube[c] = '.'\n",
    "    return new_cube\n",
    "\n",
    "\n",
    "def findNeighbors(c):\n",
    "    neighbors = [(c[0]+i, c[1]+j, c[2]+k) \n",
    "                 for i in range(-1, 2) \n",
    "                 for j in range(-1, 2) \n",
    "                 for k in range(-1, 2) \n",
    "                 if not (i == 0 and j == 0 and k == 0)]\n",
    "    return neighbors\n",
    "\n",
    "\n",
    "def checkNeighbors(c, cubes):\n",
    "    n = findNeighbors(c)\n",
    "    neighbors_count = len([x for x in n if cubes.get(x)==\"#\"])\n",
    "    return neighbors_count\n",
    "\n",
    "\n",
    "def part2():\n",
    "    with open(\"d17-input.txt\") as fp:\n",
    "        lines = [fline.rstrip() for fline in fp.readlines()]\n",
    "    f = lines \n",
    "    cubes = {(i, j, 0, 0):lines[i][j] \n",
    "             for i in range(len(lines)) \n",
    "             for j in range(len(lines[0]))}\n",
    "    for i in range(6):\n",
    "        cubes = simulate4d(cubes)\n",
    "    \n",
    "    print(f\"Part 2 Solution: {list(cubes.values()).count('#')}\")\n",
    "\n",
    "\n",
    "def simulate4d(cubes):\n",
    "    new = {}\n",
    "    for c in cubes:\n",
    "        x = checkNeighbors4d(c, cubes)\n",
    "        if cubes[c] == '#':\n",
    "            if x == 2 or x == 3:\n",
    "                new[c] = '#'\n",
    "            else:\n",
    "                new[c] = '.'\n",
    "            n = findNeighbors4d(c)\n",
    "            for x in n:\n",
    "                if x not in cubes:\n",
    "                    k = checkNeighbors4d(x, cubes)\n",
    "                    if k == 3:\n",
    "                        new[x] = '#'\n",
    "        elif cubes[c] == '.':\n",
    "            if x == 3:\n",
    "                new[c] = '#'\n",
    "            else:\n",
    "                new[c] = '.'\n",
    "    return new\n",
    "\n",
    "\n",
    "def findNeighbors4d(c):\n",
    "    neighbors = [(c[0]+i, c[1]+j, c[2]+k, c[3]+w) \n",
    "                 for i in range(-1, 2) \n",
    "                 for j in range(-1, 2) \n",
    "                 for k in range(-1, 2) \n",
    "                 for w in range(-1, 2) \n",
    "                 if not (i == 0 and j == 0 and k == 0 and w == 0)]\n",
    "    return neighbors\n",
    "\n",
    "\n",
    "def checkNeighbors4d(c, cubes):\n",
    "    n = findNeighbors4d(c)\n",
    "    neighbors_count = len([x for x in n if cubes.get(x)==\"#\"])\n",
    "    return neighbors_count\n",
    "part1()\n",
    "part2()"
   ]
  },
  {
   "source": [
    "## Day 17:\n",
    "# ### --- Part Two ---\n",
    "\n",
    "For some reason, your simulated results don't match what the experimental energy source engineers expected. Apparently, the pocket dimension actually has four spatial dimensions, not three.\n",
    "\n",
    "The pocket dimension contains an infinite 4-dimensional grid. At every integer 4-dimensional coordinate (x,y,z,w), there exists a single cube (really, a hypercube) which is still either active or inactive.\n",
    "\n",
    "Each cube only ever considers its neighbors: any of the 80 other cubes where any of their coordinates differ by at most 1. For example, given the cube at x=1,y=2,z=3,w=4, its neighbors include the cube at x=2,y=2,z=3,w=3, the cube at x=0,y=2,z=3,w=4, and so on.\n",
    "\n",
    "The initial state of the pocket dimension still consists of a small flat region of cubes. Furthermore, the same rules for cycle updating still apply: during each cycle, consider the number of active neighbors of each cube.\n",
    "\n",
    "For example, consider the same initial state as in the example above. Even though the pocket dimension is 4-dimensional, this initial state represents a small 2-dimensional slice of it. (In particular, this initial state defines a 3x3x1x1 region of the 4-dimensional space.)\n",
    "\n",
    "Simulating a few cycles from this initial state produces the following configurations, where the result of each cycle is shown layer-by-layer at each given z and w coordinate:\n",
    "\n",
    "Before any cycles:\n",
    "```\n",
    "z=0, w=0\n",
    ".#.\n",
    "..#\n",
    "###\n",
    "```\n",
    "\n",
    "After 1 cycle:\n",
    "```\n",
    "z=-1, w=-1\n",
    "#..\n",
    "..#\n",
    ".#.\n",
    "\n",
    "z=0, w=-1\n",
    "#..\n",
    "..#\n",
    ".#.\n",
    "\n",
    "z=1, w=-1\n",
    "#..\n",
    "..#\n",
    ".#.\n",
    "\n",
    "z=-1, w=0\n",
    "#..\n",
    "..#\n",
    ".#.\n",
    "\n",
    "z=0, w=0\n",
    "#.#\n",
    ".##\n",
    ".#.\n",
    "\n",
    "z=1, w=0\n",
    "#..\n",
    "..#\n",
    ".#.\n",
    "\n",
    "z=-1, w=1\n",
    "#..\n",
    "..#\n",
    ".#.\n",
    "\n",
    "z=0, w=1\n",
    "#..\n",
    "..#\n",
    ".#.\n",
    "\n",
    "z=1, w=1\n",
    "#..\n",
    "..#\n",
    ".#.\n",
    "```\n",
    "\n",
    "After 2 cycles:\n",
    "```\n",
    "z=-2, w=-2\n",
    ".....\n",
    ".....\n",
    "..#..\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=-1, w=-2\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=0, w=-2\n",
    "###..\n",
    "##.##\n",
    "#...#\n",
    ".#..#\n",
    ".###.\n",
    "\n",
    "z=1, w=-2\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=2, w=-2\n",
    ".....\n",
    ".....\n",
    "..#..\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=-2, w=-1\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=-1, w=-1\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=0, w=-1\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=1, w=-1\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=2, w=-1\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=-2, w=0\n",
    "###..\n",
    "##.##\n",
    "#...#\n",
    ".#..#\n",
    ".###.\n",
    "\n",
    "z=-1, w=0\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=0, w=0\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=1, w=0\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=2, w=0\n",
    "###..\n",
    "##.##\n",
    "#...#\n",
    ".#..#\n",
    ".###.\n",
    "\n",
    "z=-2, w=1\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=-1, w=1\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=0, w=1\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=1, w=1\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=2, w=1\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=-2, w=2\n",
    ".....\n",
    ".....\n",
    "..#..\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=-1, w=2\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=0, w=2\n",
    "###..\n",
    "##.##\n",
    "#...#\n",
    ".#..#\n",
    ".###.\n",
    "\n",
    "z=1, w=2\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    ".....\n",
    "\n",
    "z=2, w=2\n",
    ".....\n",
    ".....\n",
    "..#..\n",
    ".....\n",
    ".....\n",
    "```\n",
    "After the full six-cycle boot process completes, 848 cubes are left in the active state.\n",
    "\n",
    "Starting with your given initial configuration, simulate six cycles in a 4-dimensional space. How many cubes are left in the active state after the sixth cycle?\n",
    "\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## Day 18:\n",
    "### --- Operation Order ---\n",
    "\n",
    "As you look out the window and notice a heavily-forested continent slowly appear over the horizon, you are interrupted by the child sitting next to you. They're curious if you could help them with their math homework.\n",
    "\n",
    "Unfortunately, it seems like this \"math\" follows different rules than you remember.\n",
    "\n",
    "The homework (your puzzle input) consists of a series of expressions that consist of addition (+), multiplication (*), and parentheses ((...)). Just like normal math, parentheses indicate that the expression inside must be evaluated before it can be used by the surrounding expression. Addition still finds the sum of the numbers on both sides of the operator, and multiplication still finds the product.\n",
    "\n",
    "However, the rules of operator precedence have changed. Rather than evaluating multiplication before addition, the operators have the same precedence, and are evaluated left-to-right regardless of the order in which they appear.\n",
    "\n",
    "For example, the steps to evaluate the expression 1 + 2 * 3 + 4 * 5 + 6 are as follows:\n",
    "\n",
    "1 + 2 * 3 + 4 * 5 + 6\n",
    "  3   * 3 + 4 * 5 + 6\n",
    "      9   + 4 * 5 + 6\n",
    "         13   * 5 + 6\n",
    "             65   + 6\n",
    "                 71\n",
    "Parentheses can override this order; for example, here is what happens if parentheses are added to form 1 + (2 * 3) + (4 * (5 + 6)):\n",
    "\n",
    "1 + (2 * 3) + (4 * (5 + 6))\n",
    "1 +    6    + (4 * (5 + 6))\n",
    "     7      + (4 * (5 + 6))\n",
    "     7      + (4 *   11   )\n",
    "     7      +     44\n",
    "            51\n",
    "Here are a few more examples:\n",
    "\n",
    "2 * 3 + (4 * 5) becomes 26.\n",
    "5 + (8 * 3 + 9 + 3 * 4 * 3) becomes 437.\n",
    "5 * 9 * (7 * 3 * 3 + 9 * 3 + (8 + 6 * 4)) becomes 12240.\n",
    "((2 + 4 * 9) * (6 + 9 * 8 + 6) + 6) + 2 + 4 * 2 becomes 13632.\n",
    "Before you can help with the homework, you need to understand it yourself. Evaluate the expression on each line of the homework; what is the sum of the resulting values?"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Part 1: 16332191652452\nPart 2: 351175492232654\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "class Solver(int):\n",
    "    def __mul__(self, inp):\n",
    "        return Solver(int(self) + inp)\n",
    "    def __add__(self, inp):\n",
    "        return Solver(int(self) + inp)\n",
    "    def __sub__(self, inp):\n",
    "        return Solver(int(self) * inp)\n",
    "\n",
    "def evaluate1(expression):\n",
    "    expression = re.sub(r\"(\\d+)\", r\"Solver(\\1)\", expression)\n",
    "    expression = expression.replace(\"*\", \"-\")\n",
    "    return eval(expression, {}, {\"Solver\": Solver})\n",
    "\n",
    "def evaluate2(expr):\n",
    "    expr = re.sub(r\"(\\d+)\", r\"Solver(\\1)\", expr)\n",
    "    expr = expr.replace(\"*\", \"-\")\n",
    "    expr = expr.replace(\"+\", \"*\")\n",
    "    return eval(expr, {}, {\"Solver\": Solver})\n",
    "\n",
    "with open(\"d18-input.txt\") as fp:\n",
    "    lines = [line.split(\"\\n\")[0] for line in fp.readlines()]\n",
    "print(\"Part 1:\", sum(evaluate1(l) for l in lines))\n",
    "print(\"Part 2:\", sum(evaluate2(l) for l in lines))"
   ]
  },
  {
   "source": [
    "## Day 18\n",
    "### --- Part Two ---\n",
    "\n",
    "You manage to answer the child's questions and they finish part 1 of their homework, but get stuck when they reach the next section: advanced math.\n",
    "\n",
    "Now, addition and multiplication have different precedence levels, but they're not the ones you're familiar with. Instead, addition is evaluated before multiplication.\n",
    "\n",
    "For example, the steps to evaluate the expression 1 + 2 * 3 + 4 * 5 + 6 are now as follows:\n",
    "\n",
    "1 + 2 * 3 + 4 * 5 + 6\n",
    "  3   * 3 + 4 * 5 + 6\n",
    "  3   *   7   * 5 + 6\n",
    "  3   *   7   *  11\n",
    "     21       *  11\n",
    "         231\n",
    "Here are the other examples from above:\n",
    "\n",
    "1 + (2 * 3) + (4 * (5 + 6)) still becomes 51.\n",
    "2 * 3 + (4 * 5) becomes 46.\n",
    "5 + (8 * 3 + 9 + 3 * 4 * 3) becomes 1445.\n",
    "5 * 9 * (7 * 3 * 3 + 9 * 3 + (8 + 6 * 4)) becomes 669060.\n",
    "((2 + 4 * 9) * (6 + 9 * 8 + 6) + 6) + 2 + 4 * 2 becomes 23340.\n",
    "What do you get if you add up the results of evaluating the homework problems using these new rules?"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## Day 19:\n",
    "### --- Monster Messages ---\n",
    "\n",
    "You land in an airport surrounded by dense forest. As you walk to your high-speed train, the Elves at the Mythical Information Bureau contact you again. They think their satellite has collected an image of a sea monster! Unfortunately, the connection to the satellite is having problems, and many of the messages sent back from the satellite have been corrupted.\n",
    "\n",
    "They sent you a list of the rules valid messages should obey and a list of received messages they've collected so far (your puzzle input).\n",
    "\n",
    "The rules for valid messages (the top part of your puzzle input) are numbered and build upon each other. For example:\n",
    "```\n",
    "0: 1 2\n",
    "1: \"a\"\n",
    "2: 1 3 | 3 1\n",
    "3: \"b\"\n",
    "```\n",
    "Some rules, like 3: \"b\", simply match a single character (in this case, b).\n",
    "\n",
    "The remaining rules list the sub-rules that must be followed; for example, the rule 0: 1 2 means that to match rule 0, the text being checked must match rule 1, and the text after the part that matched rule 1 must then match rule 2.\n",
    "\n",
    "Some of the rules have multiple lists of sub-rules separated by a pipe (|). This means that at least one list of sub-rules must match. (The ones that match might be different each time the rule is encountered.) For example, the rule 2: 1 3 | 3 1 means that to match rule 2, the text being checked must match rule 1 followed by rule 3 or it must match rule 3 followed by rule 1.\n",
    "\n",
    "Fortunately, there are no loops in the rules, so the list of possible matches will be finite. Since rule 1 matches a and rule 3 matches b, rule 2 matches either ab or ba. Therefore, rule 0 matches aab or aba.\n",
    "\n",
    "Here's a more interesting example:\n",
    "```\n",
    "0: 4 1 5\n",
    "1: 2 3 | 3 2\n",
    "2: 4 4 | 5 5\n",
    "3: 4 5 | 5 4\n",
    "4: \"a\"\n",
    "5: \"b\"\n",
    "```\n",
    "Here, because rule 4 matches a and rule 5 matches b, rule 2 matches two letters that are the same (aa or bb), and rule 3 matches two letters that are different (ab or ba).\n",
    "\n",
    "Since rule 1 matches rules 2 and 3 once each in either order, it must match two pairs of letters, one pair with matching letters and one pair with different letters. This leaves eight possibilities: aaab, aaba, bbab, bbba, abaa, abbb, baaa, or babb.\n",
    "\n",
    "Rule 0, therefore, matches a (rule 4), then any of the eight options from rule 1, then b (rule 5): aaaabb, aaabab, abbabb, abbbab, aabaab, aabbbb, abaaab, or ababbb.\n",
    "\n",
    "The received messages (the bottom part of your puzzle input) need to be checked against the rules so you can determine which are valid and which are corrupted. Including the rules and the messages together, this might look like:\n",
    "```\n",
    "0: 4 1 5\n",
    "1: 2 3 | 3 2\n",
    "2: 4 4 | 5 5\n",
    "3: 4 5 | 5 4\n",
    "4: \"a\"\n",
    "5: \"b\"\n",
    "\n",
    "ababbb\n",
    "bababa\n",
    "abbbab\n",
    "aaabbb\n",
    "aaaabbb\n",
    "```\n",
    "Your goal is to determine the number of messages that completely match rule 0. In the above example, ababbb and abbbab match, but bababa, aaabbb, and aaaabbb do not, producing the answer 2. The whole message must match all of rule 0; there can't be extra unmatched characters in the message. (For example, aaaabbb might appear to match rule 0 above, but it has an extra unmatched b on the end.)\n",
    "\n",
    "How many messages completely match rule 0?"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Part 1: 269\n",
      "Part 2: 403\n"
     ]
    }
   ],
   "source": [
    "def rule_maker(raw_rules):\n",
    "    rules = {}\n",
    "    for rule in raw_rules:\n",
    "        key, value = rule.split(': ')\n",
    "        if value[0] == '\"':\n",
    "            rules[int(key)] = value[1:-1]\n",
    "        else:\n",
    "            values = value.split(' | ')\n",
    "            temp_v = []\n",
    "            for v in values:\n",
    "                temp_v.append([int(vv) for vv in v.split(' ')])\n",
    "            rules[int(key)] = temp_v\n",
    "    return rules\n",
    "\n",
    "def match_rule(expr, stack):\n",
    "    if len(stack) > len(expr):\n",
    "        return False\n",
    "    elif len(stack) == 0 or len(expr) == 0:\n",
    "        return len(stack) == 0 and len(expr) == 0\n",
    "    \n",
    "    c = stack.pop()\n",
    "    if isinstance(c, str):\n",
    "        if expr[0] == c:\n",
    "            return match_rule(expr[1:], stack.copy())\n",
    "    else:\n",
    "        for rule in rules[c]:\n",
    "            if match_rule(expr, stack + list(reversed(rule))):\n",
    "                return True\n",
    "    return False\n",
    "\n",
    "def count_messages(rules, messages):\n",
    "    total = 0\n",
    "    for message in messages:\n",
    "        if match_rule(message, list(reversed(rules[0][0]))):\n",
    "            total += 1\n",
    "    return total\n",
    "\n",
    "with open(\"d19-input.txt\") as fp:\n",
    "    raw_rules, message = fp.read().split('\\n\\n')\n",
    "    raw_rules = raw_rules.splitlines()\n",
    "    message = message.splitlines()\n",
    "\n",
    "rules = rule_maker(raw_rules)\n",
    "    \n",
    "print(f\"Part 1: {count_messages(rules, message)}\")\n",
    "rules[8] = [[42], [42, 8]]\n",
    "rules[11] = [[42, 31], [42, 11, 31]]\n",
    "print(f\"Part 2: {count_messages(rules, message)}\")\n"
   ]
  },
  {
   "source": [
    "## Day 19:\n",
    "### --- Part Two ---\n",
    "\n",
    "As you look over the list of messages, you realize your matching rules aren't quite right. To fix them, completely replace rules 8: 42 and 11: 42 31 with the following:\n",
    "```\n",
    "8: 42 | 42 8\n",
    "11: 42 31 | 42 11 31\n",
    "```\n",
    "This small change has a big impact: now, the rules do contain loops, and the list of messages they could hypothetically match is infinite. You'll need to determine how these changes affect which messages are valid.\n",
    "\n",
    "Fortunately, many of the rules are unaffected by this change; it might help to start by looking at which rules always match the same set of values and how those rules (especially rules 42 and 31) are used by the new versions of rules 8 and 11.\n",
    "\n",
    "(Remember, you only need to handle the rules you have; building a solution that could handle any hypothetical combination of rules would be significantly more difficult.)\n",
    "\n",
    "For example:\n",
    "```\n",
    "42: 9 14 | 10 1\n",
    "9: 14 27 | 1 26\n",
    "10: 23 14 | 28 1\n",
    "1: \"a\"\n",
    "11: 42 31\n",
    "5: 1 14 | 15 1\n",
    "19: 14 1 | 14 14\n",
    "12: 24 14 | 19 1\n",
    "16: 15 1 | 14 14\n",
    "31: 14 17 | 1 13\n",
    "6: 14 14 | 1 14\n",
    "2: 1 24 | 14 4\n",
    "0: 8 11\n",
    "13: 14 3 | 1 12\n",
    "15: 1 | 14\n",
    "17: 14 2 | 1 7\n",
    "23: 25 1 | 22 14\n",
    "28: 16 1\n",
    "4: 1 1\n",
    "20: 14 14 | 1 15\n",
    "3: 5 14 | 16 1\n",
    "27: 1 6 | 14 18\n",
    "14: \"b\"\n",
    "21: 14 1 | 1 14\n",
    "25: 1 1 | 1 14\n",
    "22: 14 14\n",
    "8: 42\n",
    "26: 14 22 | 1 20\n",
    "18: 15 15\n",
    "7: 14 5 | 1 21\n",
    "24: 14 1\n",
    "```\n",
    "```\n",
    "abbbbbabbbaaaababbaabbbbabababbbabbbbbbabaaaa\n",
    "bbabbbbaabaabba\n",
    "babbbbaabbbbbabbbbbbaabaaabaaa\n",
    "aaabbbbbbaaaabaababaabababbabaaabbababababaaa\n",
    "bbbbbbbaaaabbbbaaabbabaaa\n",
    "bbbababbbbaaaaaaaabbababaaababaabab\n",
    "ababaaaaaabaaab\n",
    "ababaaaaabbbaba\n",
    "baabbaaaabbaaaababbaababb\n",
    "abbbbabbbbaaaababbbbbbaaaababb\n",
    "aaaaabbaabaaaaababaa\n",
    "aaaabbaaaabbaaa\n",
    "aaaabbaabbaaaaaaabbbabbbaaabbaabaaa\n",
    "babaaabbbaaabaababbaabababaaab\n",
    "aabbbbbaabbbaaaaaabbbbbababaaaaabbaaabba\n",
    "```\n",
    "Without updating rules 8 and 11, these rules only match three messages: bbabbbbaabaabba, ababaaaaaabaaab, and ababaaaaabbbaba.\n",
    "\n",
    "However, after updating rules 8 and 11, a total of 12 messages match:\n",
    "```\n",
    "    bbabbbbaabaabba\n",
    "    babbbbaabbbbbabbbbbbaabaaabaaa\n",
    "    aaabbbbbbaaaabaababaabababbabaaabbababababaaa\n",
    "    bbbbbbbaaaabbbbaaabbabaaa\n",
    "    bbbababbbbaaaaaaaabbababaaababaabab\n",
    "    ababaaaaaabaaab\n",
    "    ababaaaaabbbaba\n",
    "    baabbaaaabbaaaababbaababb\n",
    "    abbbbabbbbaaaababbbbbbaaaababb\n",
    "    aaaaabbaabaaaaababaa\n",
    "    aaaabbaabbaaaaaaabbbabbbaaabbaabaaa\n",
    "    aabbbbbaabbbaaaaaabbbbbababaaaaabbaaabba\n",
    "```\n",
    "After updating rules 8 and 11, how many messages completely match rule 0?\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## Day 20:\n",
    "### --- Jurassic Jigsaw ---\n",
    "\n",
    "The high-speed train leaves the forest and quickly carries you south. You can even see a desert in the distance! Since you have some spare time, you might as well see if there was anything interesting in the image the Mythical Information Bureau satellite captured.\n",
    "\n",
    "After decoding the satellite messages, you discover that the data actually contains many small images created by the satellite's camera array. The camera array consists of many cameras; rather than produce a single square image, they produce many smaller square image tiles that need to be @reassembled back into a single image.\n",
    "\n",
    "Each camera in the camera array returns a single monochrome image tile with a random unique ID number. The tiles (your puzzle input) arrived in a random order.\n",
    "\n",
    "Worse yet, the camera array appears to be malfunctioning: each image tile has been rotated and flipped to a random orientation. Your first task is to reassemble the original image by orienting the tiles so they fit together.\n",
    "\n",
    "To show how the tiles should be reassembled, each tile's image data includes a border that should line up exactly with its adjacent tiles. All tiles have this border, and the border lines up exactly when the tiles are both oriented correctly. Tiles at the edge of the image also have this border, but the outermost edges won't line up with any other tiles.\n",
    "\n",
    "For example, suppose you have the following nine tiles:\n",
    "```\n",
    "Tile 2311:\n",
    "..##.#..#.\n",
    "##..#.....\n",
    "#...##..#.\n",
    "####.#...#\n",
    "##.##.###.\n",
    "##...#.###\n",
    ".#.#.#..##\n",
    "..#....#..\n",
    "###...#.#.\n",
    "..###..###\n",
    "\n",
    "Tile 1951:\n",
    "#.##...##.\n",
    "#.####...#\n",
    ".....#..##\n",
    "#...######\n",
    ".##.#....#\n",
    ".###.#####\n",
    "###.##.##.\n",
    ".###....#.\n",
    "..#.#..#.#\n",
    "#...##.#..\n",
    "\n",
    "Tile 1171:\n",
    "####...##.\n",
    "#..##.#..#\n",
    "##.#..#.#.\n",
    ".###.####.\n",
    "..###.####\n",
    ".##....##.\n",
    ".#...####.\n",
    "#.##.####.\n",
    "####..#...\n",
    ".....##...\n",
    "\n",
    "Tile 1427:\n",
    "###.##.#..\n",
    ".#..#.##..\n",
    ".#.##.#..#\n",
    "#.#.#.##.#\n",
    "....#...##\n",
    "...##..##.\n",
    "...#.#####\n",
    ".#.####.#.\n",
    "..#..###.#\n",
    "..##.#..#.\n",
    "\n",
    "Tile 1489:\n",
    "##.#.#....\n",
    "..##...#..\n",
    ".##..##...\n",
    "..#...#...\n",
    "#####...#.\n",
    "#..#.#.#.#\n",
    "...#.#.#..\n",
    "##.#...##.\n",
    "..##.##.##\n",
    "###.##.#..\n",
    "\n",
    "Tile 2473:\n",
    "#....####.\n",
    "#..#.##...\n",
    "#.##..#...\n",
    "######.#.#\n",
    ".#...#.#.#\n",
    ".#########\n",
    ".###.#..#.\n",
    "########.#\n",
    "##...##.#.\n",
    "..###.#.#.\n",
    "\n",
    "Tile 2971:\n",
    "..#.#....#\n",
    "#...###...\n",
    "#.#.###...\n",
    "##.##..#..\n",
    ".#####..##\n",
    ".#..####.#\n",
    "#..#.#..#.\n",
    "..####.###\n",
    "..#.#.###.\n",
    "...#.#.#.#\n",
    "\n",
    "Tile 2729:\n",
    "...#.#.#.#\n",
    "####.#....\n",
    "..#.#.....\n",
    "....#..#.#\n",
    ".##..##.#.\n",
    ".#.####...\n",
    "####.#.#..\n",
    "##.####...\n",
    "##..#.##..\n",
    "#.##...##.\n",
    "\n",
    "Tile 3079:\n",
    "#.#.#####.\n",
    ".#..######\n",
    "..#.......\n",
    "######....\n",
    "####.#..#.\n",
    ".#...#.##.\n",
    "#.#####.##\n",
    "..#.###...\n",
    "..#.......\n",
    "..#.###...\n",
    "```\n",
    "By rotating, flipping, and rearranging them, you can find a square arrangement that causes all adjacent borders to line up:\n",
    "\n",
    "```\n",
    "#...##.#.. ..###..### #.#.#####.\n",
    "..#.#..#.# ###...#.#. .#..######\n",
    ".###....#. ..#....#.. ..#.......\n",
    "###.##.##. .#.#.#..## ######....\n",
    ".###.##### ##...#.### ####.#..#.\n",
    ".##.#....# ##.##.###. .#...#.##.\n",
    "#...###### ####.#...# #.#####.##\n",
    ".....#..## #...##..#. ..#.###...\n",
    "#.####...# ##..#..... ..#.......\n",
    "#.##...##. ..##.#..#. ..#.###...\n",
    "\n",
    "#.##...##. ..##.#..#. ..#.###...\n",
    "##..#.##.. ..#..###.# ##.##....#\n",
    "##.####... .#.####.#. ..#.###..#\n",
    "####.#.#.. ...#.##### ###.#..###\n",
    ".#.####... ...##..##. .######.##\n",
    ".##..##.#. ....#...## #.#.#.#...\n",
    "....#..#.# #.#.#.##.# #.###.###.\n",
    "..#.#..... .#.##.#..# #.###.##..\n",
    "####.#.... .#..#.##.. .######...\n",
    "...#.#.#.# ###.##.#.. .##...####\n",
    "\n",
    "...#.#.#.# ###.##.#.. .##...####\n",
    "..#.#.###. ..##.##.## #..#.##..#\n",
    "..####.### ##.#...##. .#.#..#.##\n",
    "#..#.#..#. ...#.#.#.. .####.###.\n",
    ".#..####.# #..#.#.#.# ####.###..\n",
    ".#####..## #####...#. .##....##.\n",
    "##.##..#.. ..#...#... .####...#.\n",
    "#.#.###... .##..##... .####.##.#\n",
    "#...###... ..##...#.. ...#..####\n",
    "..#.#....# ##.#.#.... ...##.....\n",
    "```\n",
    "For reference, the IDs of the above tiles are:\n",
    "\n",
    "1951    2311    3079\n",
    "2729    1427    2473\n",
    "2971    1489    1171\n",
    "To check that you've assembled the image correctly, multiply the IDs of the four corner tiles together. If you do this with the assembled tiles from the example above, you get 1951 * 3079 * 2971 * 1171 = 20899048083289.\n",
    "\n",
    "Assemble the tiles into an image. What do you get if you multiply together the IDs of the four corner tiles?"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "108603771107737\n",
      "2129\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "import re\n",
    "\n",
    "\n",
    "def transposed(tile):\n",
    "\treturn list(''.join(row) for row in zip(*tile))\n",
    "\n",
    "\n",
    "def reversed_tile(tile):\n",
    "\treturn [''.join(reversed(row)) for row in tile]\n",
    "\n",
    "\n",
    "def rotations(tile):\n",
    "\t# print(tile)\n",
    "\tans = [tile]\n",
    "\tfor _ in range(3):\n",
    "\t\tans.append(reversed_tile(transposed(ans[-1])))\n",
    "\t# print(ans)\n",
    "\treturn ans\n",
    "\n",
    "\n",
    "def group(tile):\n",
    "\treturn rotations(tile) + rotations(transposed(tile))\n",
    "\n",
    "\n",
    "tiles = {}\n",
    "for tile in open('d20-input.txt').read().split('\\n\\n'):\n",
    "\tlines = tile.strip().split('\\n')\n",
    "\ttile_id = int(re.fullmatch(r'Tile (\\d+):', lines[0]).group(1))\n",
    "\trows = lines[1:]\n",
    "\ttiles[tile_id] = group(rows)\n",
    "\n",
    "n = int(math.sqrt(len(tiles)))\n",
    "arranged = [[0] * n for _ in range(n)]\n",
    "stack = list(reversed(list((r, c) for c in range(n) for r in range(n))))\n",
    "\n",
    "\n",
    "def solve():\n",
    "\tif not stack:\n",
    "\t\tprint(arranged[0][0][0] * arranged[-1][0][0] * arranged[0][-1][0] * arranged[-1][-1][0])\n",
    "\t\treturn True\n",
    "\t(r, c) = stack.pop()\n",
    "\tfor tile_id in list(tiles):\n",
    "\t\ttile_group = tiles[tile_id]\n",
    "\t\tdel tiles[tile_id]\n",
    "\t\tfor tile in tile_group:\n",
    "\t\t\tif r > 0:\n",
    "\t\t\t\tif arranged[r - 1][c][1][-1] != tile[0]:\n",
    "\t\t\t\t\tcontinue\n",
    "\t\t\tif c > 0:\n",
    "\t\t\t\tif list(row[-1] for row in arranged[r][c - 1][1]) != list(row[0] for row in tile):\n",
    "\t\t\t\t\tcontinue\n",
    "\t\t\tarranged[r][c] = (tile_id, tile)\n",
    "\t\t\tif solve():\n",
    "\t\t\t\treturn True\n",
    "\t\ttiles[tile_id] = tile_group\n",
    "\tstack.append((r, c))\n",
    "\n",
    "\n",
    "solve()\n",
    "\n",
    "\n",
    "def remove_border(tile):\n",
    "\treturn [row[1:-1] for row in tile[1:-1]]\n",
    "\n",
    "\n",
    "board = [[remove_border(tile[1]) for tile in row] for row in arranged]\n",
    "tile_n = len(board[0][0])\n",
    "\n",
    "\n",
    "def get(r, c):\n",
    "\treturn board[r // tile_n][c // tile_n][r % tile_n][c % tile_n]\n",
    "\n",
    "\n",
    "board = [''.join(get(r, c) for c in range(n * tile_n)) for r in range(n * tile_n)]\n",
    "\n",
    "for pattern in group(['                  # ', '#    ##    ##    ###', ' #  #  #  #  #  #   ']):\n",
    "\tmatches = 0\n",
    "\tfor dr in range(len(board) - len(pattern) + 1):\n",
    "\t\tfor dc in range(len(board[0]) - len(pattern[0]) + 1):\n",
    "\t\t\tmatches += all(pattern[r][c] == ' ' or board[r + dr][c + dc] == '#'\n",
    "\t\t\t\tfor r in range(len(pattern))\n",
    "\t\t\t\tfor c in range(len(pattern[0])))\n",
    "\tif matches:\n",
    "\t\tprint(''.join(board).count('#') - ''.join(pattern).count('#') * matches)\n",
    "\t\tbreak"
   ]
  },
  {
   "source": [
    "## Day 20:\n",
    "### --- Part Two ---\n",
    "\n",
    "Now, you're ready to check the image for sea monsters.\n",
    "\n",
    "The borders of each tile are not part of the actual image; start by removing them.\n",
    "\n",
    "In the example above, the tiles become:\n",
    "```\n",
    ".#.#..#. ##...#.# #..#####\n",
    "###....# .#....#. .#......\n",
    "##.##.## #.#.#..# #####...\n",
    "###.#### #...#.## ###.#..#\n",
    "##.#.... #.##.### #...#.##\n",
    "...##### ###.#... .#####.#\n",
    "....#..# ...##..# .#.###..\n",
    ".####... #..#.... .#......\n",
    "```\n",
    "```\n",
    "#..#.##. .#..###. #.##....\n",
    "#.####.. #.####.# .#.###..\n",
    "###.#.#. ..#.#### ##.#..##\n",
    "#.####.. ..##..## ######.#\n",
    "##..##.# ...#...# .#.#.#..\n",
    "...#..#. .#.#.##. .###.###\n",
    ".#.#.... #.##.#.. .###.##.\n",
    "###.#... #..#.##. ######..\n",
    "```\n",
    "```\n",
    ".#.#.### .##.##.# ..#.##..\n",
    ".####.## #.#...## #.#..#.#\n",
    "..#.#..# ..#.#.#. ####.###\n",
    "#..####. ..#.#.#. ###.###.\n",
    "#####..# ####...# ##....##\n",
    "#.##..#. .#...#.. ####...#\n",
    ".#.###.. ##..##.. ####.##.\n",
    "...###.. .##...#. ..#..###\n",
    "```\n",
    "Remove the gaps to form the actual image:\n",
    "\n",
    "```\n",
    ".#.#..#.##...#.##..#####\n",
    "###....#.#....#..#......\n",
    "##.##.###.#.#..######...\n",
    "###.#####...#.#####.#..#\n",
    "##.#....#.##.####...#.##\n",
    "...########.#....#####.#\n",
    "....#..#...##..#.#.###..\n",
    ".####...#..#.....#......\n",
    "#..#.##..#..###.#.##....\n",
    "#.####..#.####.#.#.###..\n",
    "###.#.#...#.######.#..##\n",
    "#.####....##..########.#\n",
    "##..##.#...#...#.#.#.#..\n",
    "...#..#..#.#.##..###.###\n",
    ".#.#....#.##.#...###.##.\n",
    "###.#...#..#.##.######..\n",
    ".#.#.###.##.##.#..#.##..\n",
    ".####.###.#...###.#..#.#\n",
    "..#.#..#..#.#.#.####.###\n",
    "#..####...#.#.#.###.###.\n",
    "#####..#####...###....##\n",
    "#.##..#..#...#..####...#\n",
    ".#.###..##..##..####.##.\n",
    "...###...##...#...#..###\n",
    "```\n",
    "\n",
    "Now, you're ready to search for sea monsters! Because your image is monochrome, a sea monster will look like this:\n",
    "\n",
    "```\n",
    "                  # \n",
    "#    ##    ##    ###\n",
    " #  #  #  #  #  #   \n",
    "```\n",
    "When looking for this pattern in the image, the spaces can be anything; only the # need to match. Also, you might need to rotate or flip your image before it's oriented correctly to find sea monsters. In the above image, after flipping and rotating it to the appropriate orientation, there are two sea monsters (marked with O):\n",
    "```\n",
    ".####...#####..#...###..\n",
    "#####..#..#.#.####..#.#.\n",
    ".#.#...#.###...#.##.O#..\n",
    "#.O.##.OO#.#.OO.##.OOO##\n",
    "..#O.#O#.O##O..O.#O##.##\n",
    "...#.#..##.##...#..#..##\n",
    "#.##.#..#.#..#..##.#.#..\n",
    ".###.##.....#...###.#...\n",
    "#.####.#.#....##.#..#.#.\n",
    "##...#..#....#..#...####\n",
    "..#.##...###..#.#####..#\n",
    "....#.##.#.#####....#...\n",
    "..##.##.###.....#.##..#.\n",
    "#...#...###..####....##.\n",
    ".#.##...#.##.#.#.###...#\n",
    "#.###.#..####...##..#...\n",
    "#.###...#.##...#.##O###.\n",
    ".O##.#OO.###OO##..OOO##.\n",
    "..O#.O..O..O.#O##O##.###\n",
    "#.#..##.########..#..##.\n",
    "#.#####..#.#...##..#....\n",
    "#....##..#.#########..##\n",
    "#...#.....#..##...###.##\n",
    "#..###....##.#...##.##.#\n",
    "```\n",
    "Determine how rough the waters are in the sea monsters' habitat by counting the number of # that are not part of a sea monster. In the above example, the habitat's water roughness is 273.\n",
    "\n",
    "How many # are not part of a sea monster?"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## Day 21:\n",
    "### --- Allergen Assessment ---\n",
    "\n",
    "You reach the train's last stop and the closest you can get to your vacation island without getting wet. There aren't even any boats here, but nothing can stop you now: you build a raft. You just need a few days' worth of food for your journey.\n",
    "\n",
    "You don't speak the local language, so you can't read any ingredients lists. However, sometimes, allergens are listed in a language you do understand. You should be able to use this information to determine which ingredient contains which allergen and work out which foods are safe to take with you on your trip.\n",
    "\n",
    "You start by compiling a list of foods (your puzzle input), one food per line. Each line includes that food's ingredients list followed by some or all of the allergens the food contains.\n",
    "\n",
    "Each allergen is found in exactly one ingredient. Each ingredient contains zero or one allergen. Allergens aren't always marked; when they're listed (as in (contains nuts, shellfish) after an ingredients list), the ingredient that contains each listed allergen will be somewhere in the corresponding ingredients list. However, even if an allergen isn't listed, the ingredient that contains that allergen could still be present: maybe they forgot to label it, or maybe it was labeled in a language you don't know.\n",
    "\n",
    "For example, consider the following list of foods:\n",
    "\n",
    "mxmxvkd kfcds sqjhc nhms (contains dairy, fish)\n",
    "trh fvjkl sbzzf mxmxvkd (contains dairy)\n",
    "sqjhc fvjkl (contains soy)\n",
    "sqjhc mxmxvkd sbzzf (contains fish)\n",
    "The first food in the list has four ingredients (written in a language you don't understand): mxmxvkd, kfcds, sqjhc, and nhms. While the food might contain other allergens, a few allergens the food definitely contains are listed afterward: dairy and fish.\n",
    "\n",
    "The first step is to determine which ingredients can't possibly contain any of the allergens in any food in your list. In the above example, none of the ingredients kfcds, nhms, sbzzf, or trh can contain an allergen. Counting the number of times any of these ingredients appear in any ingredients list produces 5: they all appear once each except sbzzf, which appears twice.\n",
    "\n",
    "Determine which ingredients cannot possibly contain any of the allergens in your list. How many times do any of those ingredients appear?"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Safe ingredients: 2176\nlvvMy dangerous list: ,xblchxMy dangerous list: ,trMy dangerous list: ,gzvsgMy dangerous list: ,jlsqxMy dangerous list: ,fnntrMy dangerous list: ,pmzMy dangerous list: ,csqc\n"
     ]
    }
   ],
   "source": [
    "with open(\"d21-input.txt\") as fp:\n",
    "    lines = fp.read().splitlines()\n",
    "\n",
    "food_dict = {}\n",
    "safe_ingredient = set()\n",
    "all_ingredients = []\n",
    "for food in lines:\n",
    "    ingredients, allergens = food.split(\" (contains \")\n",
    "    allergens = allergens[:-1]\n",
    "    ingredients = ingredients.split(\" \")\n",
    "    all_ingredients.extend(ingredients)\n",
    "    unique_in = set(ingredients)\n",
    "    safe_ingredient=safe_ingredient.union(unique_in)\n",
    "    allergens = allergens.split(\", \")\n",
    "    \n",
    "    for allergen in allergens:\n",
    "        if food_dict.get(allergen) is None:\n",
    "            food_dict[allergen] = unique_in\n",
    "        else:\n",
    "            food_dict[allergen] = food_dict[allergen].intersection(unique_in)\n",
    "\n",
    "safe_ingredient = safe_ingredient.difference(set(k for value in food_dict.values() for k in value))\n",
    "safe_count = sum([ingredient in safe_ingredient for ingredient in all_ingredients])\n",
    "print(f\"Safe ingredients: {safe_count}\")\n",
    "\n",
    "unsafe_ingredients = set([v for v in all_ingredients if v not in safe_ingredient])\n",
    "food_dict = {key:food_dict[key] for key in sorted(food_dict.keys())}\n",
    "food_dict, unsafe_ingredients\n",
    "\n",
    "allergens = food_dict\n",
    "while any([len(i) > 1 for i in food_dict.values()]):    \n",
    "    for a, i in food_dict.items():                      \n",
    "        if len(i) == 1:                                 \n",
    "            alg = list(i)[0]                            \n",
    "            for a2, i2 in food_dict.items():            \n",
    "                if a2 == a:                             \n",
    "                    continue                            \n",
    "                if len(i2) > 1:                         \n",
    "                    if alg in i2:                       \n",
    "                        food_dict[a2].remove(alg)       \n",
    "\n",
    "                                                             \n",
    "\n",
    "names = list(food_dict.keys())                          \n",
    "names.sort()                                            \n",
    "print(\"My dangerous list: \"\",\".join([\",\".join(food_dict[i]) for i in names]))"
   ]
  },
  {
   "source": [
    "## Day 21:\n",
    "### --- Part Two ---\n",
    "\n",
    "Now that you've isolated the inert ingredients, you should have enough information to figure out which ingredient contains which allergen.\n",
    "\n",
    "In the above example:\n",
    "\n",
    "mxmxvkd contains dairy.\n",
    "sqjhc contains fish.\n",
    "fvjkl contains soy.\n",
    "Arrange the ingredients alphabetically by their allergen and separate them by commas to produce your canonical dangerous ingredient list. (There should not be any spaces in your canonical dangerous ingredient list.) In the above example, this would be mxmxvkd,sqjhc,fvjkl.\n",
    "\n",
    "Time to stock your raft with supplies. What is your canonical dangerous ingredient list?"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## Day 22:\n",
    "### --- Crab Combat ---\n",
    "\n",
    "It only takes a few hours of sailing the ocean on a raft for boredom to sink in. Fortunately, you brought a small deck of space cards! You'd like to play a game of Combat, and there's even an opponent available: a small crab that climbed aboard your raft before you left.\n",
    "\n",
    "Fortunately, it doesn't take long to teach the crab the rules.\n",
    "\n",
    "Before the game starts, split the cards so each player has their own deck (your puzzle input). Then, the game consists of a series of rounds: both players draw their top card, and the player with the higher-valued card wins the round. The winner keeps both cards, placing them on the bottom of their own deck so that the winner's card is above the other card. If this causes a player to have all of the cards, they win, and the game ends.\n",
    "\n",
    "For example, consider the following starting decks:\n",
    "```\n",
    "Player 1:\n",
    "9\n",
    "2\n",
    "6\n",
    "3\n",
    "1\n",
    "\n",
    "Player 2:\n",
    "5\n",
    "8\n",
    "4\n",
    "7\n",
    "10\n",
    "```\n",
    "This arrangement means that player 1's deck contains 5 cards, with 9 on top and 1 on the bottom; player 2's deck also contains 5 cards, with 5 on top and 10 on the bottom.\n",
    "\n",
    "The first round begins with both players drawing the top card of their decks: 9 and 5. Player 1 has the higher card, so both cards move to the bottom of player 1's deck such that 9 is above 5. In total, it takes 29 rounds before a player has all of the cards:\n",
    "```\n",
    "-- Round 1 --\n",
    "Player 1's deck: 9, 2, 6, 3, 1\n",
    "Player 2's deck: 5, 8, 4, 7, 10\n",
    "Player 1 plays: 9\n",
    "Player 2 plays: 5\n",
    "Player 1 wins the round!\n",
    "\n",
    "-- Round 2 --\n",
    "Player 1's deck: 2, 6, 3, 1, 9, 5\n",
    "Player 2's deck: 8, 4, 7, 10\n",
    "Player 1 plays: 2\n",
    "Player 2 plays: 8\n",
    "Player 2 wins the round!\n",
    "\n",
    "-- Round 3 --\n",
    "Player 1's deck: 6, 3, 1, 9, 5\n",
    "Player 2's deck: 4, 7, 10, 8, 2\n",
    "Player 1 plays: 6\n",
    "Player 2 plays: 4\n",
    "Player 1 wins the round!\n",
    "\n",
    "-- Round 4 --\n",
    "Player 1's deck: 3, 1, 9, 5, 6, 4\n",
    "Player 2's deck: 7, 10, 8, 2\n",
    "Player 1 plays: 3\n",
    "Player 2 plays: 7\n",
    "Player 2 wins the round!\n",
    "\n",
    "-- Round 5 --\n",
    "Player 1's deck: 1, 9, 5, 6, 4\n",
    "Player 2's deck: 10, 8, 2, 7, 3\n",
    "Player 1 plays: 1\n",
    "Player 2 plays: 10\n",
    "Player 2 wins the round!\n",
    "\n",
    "...several more rounds pass...\n",
    "\n",
    "-- Round 27 --\n",
    "Player 1's deck: 5, 4, 1\n",
    "Player 2's deck: 8, 9, 7, 3, 2, 10, 6\n",
    "Player 1 plays: 5\n",
    "Player 2 plays: 8\n",
    "Player 2 wins the round!\n",
    "\n",
    "-- Round 28 --\n",
    "Player 1's deck: 4, 1\n",
    "Player 2's deck: 9, 7, 3, 2, 10, 6, 8, 5\n",
    "Player 1 plays: 4\n",
    "Player 2 plays: 9\n",
    "Player 2 wins the round!\n",
    "\n",
    "-- Round 29 --\n",
    "Player 1's deck: 1\n",
    "Player 2's deck: 7, 3, 2, 10, 6, 8, 5, 9, 4\n",
    "Player 1 plays: 1\n",
    "Player 2 plays: 7\n",
    "Player 2 wins the round!\n",
    "```\n",
    "\n",
    "== Post-game results ==\n",
    "Player 1's deck: \n",
    "Player 2's deck: 3, 2, 10, 6, 8, 5, 9, 4, 7, 1\n",
    "Once the game ends, you can calculate the winning player's score. The bottom card in their deck is worth the value of the card multiplied by 1, the second-from-the-bottom card is worth the value of the card multiplied by 2, and so on. With 10 cards, the top card is worth the value on the card multiplied by 10. In this example, the winning player's score is:\n",
    "```\n",
    "   3 * 10\n",
    "+  2 *  9\n",
    "+ 10 *  8\n",
    "+  6 *  7\n",
    "+  8 *  6\n",
    "+  5 *  5\n",
    "+  9 *  4\n",
    "+  4 *  3\n",
    "+  7 *  2\n",
    "+  1 *  1\n",
    "= 306\n",
    "```\n",
    "So, once the game ends, the winning player's score is 306.\n",
    "\n",
    "Play the small crab in a game of Combat using the two decks you just dealt. What is the winning player's score?"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "32102\n"
     ]
    }
   ],
   "source": [
    "with open(\"d22-input.txt\") as f:\n",
    "    lines = f.read().split(\"\\n\\n\")\n",
    "lines = {line.split(\":\")[0]: line.split(\":\")[1].strip() for line in lines}\n",
    "lines = {key: list(map(lambda x: int(x), value.split(\"\\n\"))) for key, value in lines.items()}\n",
    "card_dict = lines.copy()\n",
    "\n",
    "p1 = card_dict[\"Player 1\"]\n",
    "p2 = card_dict[\"Player 2\"]\n",
    "\n",
    "i=0\n",
    "while len(p1) != 0 or len(p2) != 0:\n",
    "\t# play the top card\n",
    "\tcard1 = p1[0]\n",
    "\tcard2 = p2[0]\n",
    "\t# remove top card from the hand\n",
    "\tdel(p1[0])\n",
    "\tdel(p2[0])\n",
    "\t# player1 card wins append player 1 card to bottom of hand followed by player 2 card\n",
    "\tif card1 > card2:\n",
    "\t\tp1.append(card1)\n",
    "\t\tp1.append(card2)\n",
    "\telse:\n",
    "\t# player 2 card wins append player 2 card bottom of hand followed by player 1 card\n",
    "\t\tp2.append(card2)\n",
    "\t\tp2.append(card1)\n",
    "\ti += 1\n",
    "\tif len(p1) == 0 or len (p2) == 0:\n",
    "\t\tbreak\n",
    "if len(p1) == 0: # player 2 wins\n",
    "\twinnerSum = sum([((i+1)*j) for i,j in enumerate(p2[::-1])])\n",
    "else: # player 1 wins\n",
    "\twinnerSum = sum([((i+1)*j) for i,j in enumerate(p1[::-1])])\n",
    "print(winnerSum)\n"
   ]
  },
  {
   "source": [
    "## Day 22:\n",
    "### --- Part Two ---\n",
    "\n",
    "You lost to the small crab! Fortunately, crabs aren't very good at recursion. To defend your honor as a Raft Captain, you challenge the small crab to a game of Recursive Combat.\n",
    "\n",
    "Recursive Combat still starts by splitting the cards into two decks (you offer to play with the same starting decks as before - it's only fair). Then, the game consists of a series of rounds with a few changes:\n",
    "\n",
    "Before either player deals a card, if there was a previous round in this game that had exactly the same cards in the same order in the same players' decks, the game instantly ends in a win for player 1. Previous rounds from other games are not considered. (This prevents infinite games of Recursive Combat, which everyone agrees is a bad idea.)\n",
    "Otherwise, this round's cards must be in a new configuration; the players begin the round by each drawing the top card of their deck as normal.\n",
    "If both players have at least as many cards remaining in their deck as the value of the card they just drew, the winner of the round is determined by playing a new game of Recursive Combat (see below).\n",
    "Otherwise, at least one player must not have enough cards left in their deck to recurse; the winner of the round is the player with the higher-value card.\n",
    "As in regular Combat, the winner of the round (even if they won the round by winning a sub-game) takes the two cards dealt at the beginning of the round and places them on the bottom of their own deck (again so that the winner's card is above the other card). Note that the winner's card might be the lower-valued of the two cards if they won the round due to winning a sub-game. If collecting cards by winning the round causes a player to have all of the cards, they win, and the game ends.\n",
    "\n",
    "Here is an example of a small game that would loop forever without the infinite game prevention rule:\n",
    "```\n",
    "Player 1:\n",
    "43\n",
    "19\n",
    "\n",
    "Player 2:\n",
    "2\n",
    "29\n",
    "14\n",
    "```\n",
    "During a round of Recursive Combat, if both players have at least as many cards in their own decks as the number on the card they just dealt, the winner of the round is determined by recursing into a sub-game of Recursive Combat. (For example, if player 1 draws the 3 card, and player 2 draws the 7 card, this would occur if player 1 has at least 3 cards left and player 2 has at least 7 cards left, not counting the 3 and 7 cards that were drawn.)\n",
    "\n",
    "To play a sub-game of Recursive Combat, each player creates a new deck by making a copy of the next cards in their deck (the quantity of cards copied is equal to the number on the card they drew to trigger the sub-game). During this sub-game, the game that triggered it is on hold and completely unaffected; no cards are removed from players' decks to form the sub-game. (For example, if player 1 drew the 3 card, their deck in the sub-game would be copies of the next three cards in their deck.)\n",
    "\n",
    "Here is a complete example of gameplay, where Game 1 is the primary game of Recursive Combat:\n",
    "\n",
    "=== Game 1 ===\n",
    "```\n",
    "-- Round 1 (Game 1) --\n",
    "Player 1's deck: 9, 2, 6, 3, 1\n",
    "Player 2's deck: 5, 8, 4, 7, 10\n",
    "Player 1 plays: 9\n",
    "Player 2 plays: 5\n",
    "Player 1 wins round 1 of game 1!\n",
    "\n",
    "-- Round 2 (Game 1) --\n",
    "Player 1's deck: 2, 6, 3, 1, 9, 5\n",
    "Player 2's deck: 8, 4, 7, 10\n",
    "Player 1 plays: 2\n",
    "Player 2 plays: 8\n",
    "Player 2 wins round 2 of game 1!\n",
    "\n",
    "-- Round 3 (Game 1) --\n",
    "Player 1's deck: 6, 3, 1, 9, 5\n",
    "Player 2's deck: 4, 7, 10, 8, 2\n",
    "Player 1 plays: 6\n",
    "Player 2 plays: 4\n",
    "Player 1 wins round 3 of game 1!\n",
    "\n",
    "-- Round 4 (Game 1) --\n",
    "Player 1's deck: 3, 1, 9, 5, 6, 4\n",
    "Player 2's deck: 7, 10, 8, 2\n",
    "Player 1 plays: 3\n",
    "Player 2 plays: 7\n",
    "Player 2 wins round 4 of game 1!\n",
    "\n",
    "-- Round 5 (Game 1) --\n",
    "Player 1's deck: 1, 9, 5, 6, 4\n",
    "Player 2's deck: 10, 8, 2, 7, 3\n",
    "Player 1 plays: 1\n",
    "Player 2 plays: 10\n",
    "Player 2 wins round 5 of game 1!\n",
    "\n",
    "-- Round 6 (Game 1) --\n",
    "Player 1's deck: 9, 5, 6, 4\n",
    "Player 2's deck: 8, 2, 7, 3, 10, 1\n",
    "Player 1 plays: 9\n",
    "Player 2 plays: 8\n",
    "Player 1 wins round 6 of game 1!\n",
    "\n",
    "-- Round 7 (Game 1) --\n",
    "Player 1's deck: 5, 6, 4, 9, 8\n",
    "Player 2's deck: 2, 7, 3, 10, 1\n",
    "Player 1 plays: 5\n",
    "Player 2 plays: 2\n",
    "Player 1 wins round 7 of game 1!\n",
    "\n",
    "-- Round 8 (Game 1) --\n",
    "Player 1's deck: 6, 4, 9, 8, 5, 2\n",
    "Player 2's deck: 7, 3, 10, 1\n",
    "Player 1 plays: 6\n",
    "Player 2 plays: 7\n",
    "Player 2 wins round 8 of game 1!\n",
    "\n",
    "-- Round 9 (Game 1) --\n",
    "Player 1's deck: 4, 9, 8, 5, 2\n",
    "Player 2's deck: 3, 10, 1, 7, 6\n",
    "Player 1 plays: 4\n",
    "Player 2 plays: 3\n",
    "Playing a sub-game to determine the winner...\n",
    "\n",
    "=== Game 2 ===\n",
    "\n",
    "-- Round 1 (Game 2) --\n",
    "Player 1's deck: 9, 8, 5, 2\n",
    "Player 2's deck: 10, 1, 7\n",
    "Player 1 plays: 9\n",
    "Player 2 plays: 10\n",
    "Player 2 wins round 1 of game 2!\n",
    "\n",
    "-- Round 2 (Game 2) --\n",
    "Player 1's deck: 8, 5, 2\n",
    "Player 2's deck: 1, 7, 10, 9\n",
    "Player 1 plays: 8\n",
    "Player 2 plays: 1\n",
    "Player 1 wins round 2 of game 2!\n",
    "\n",
    "-- Round 3 (Game 2) --\n",
    "Player 1's deck: 5, 2, 8, 1\n",
    "Player 2's deck: 7, 10, 9\n",
    "Player 1 plays: 5\n",
    "Player 2 plays: 7\n",
    "Player 2 wins round 3 of game 2!\n",
    "\n",
    "-- Round 4 (Game 2) --\n",
    "Player 1's deck: 2, 8, 1\n",
    "Player 2's deck: 10, 9, 7, 5\n",
    "Player 1 plays: 2\n",
    "Player 2 plays: 10\n",
    "Player 2 wins round 4 of game 2!\n",
    "\n",
    "-- Round 5 (Game 2) --\n",
    "Player 1's deck: 8, 1\n",
    "Player 2's deck: 9, 7, 5, 10, 2\n",
    "Player 1 plays: 8\n",
    "Player 2 plays: 9\n",
    "Player 2 wins round 5 of game 2!\n",
    "\n",
    "-- Round 6 (Game 2) --\n",
    "Player 1's deck: 1\n",
    "Player 2's deck: 7, 5, 10, 2, 9, 8\n",
    "Player 1 plays: 1\n",
    "Player 2 plays: 7\n",
    "Player 2 wins round 6 of game 2!\n",
    "The winner of game 2 is player 2!\n",
    "\n",
    "...anyway, back to game 1.\n",
    "Player 2 wins round 9 of game 1!\n",
    "\n",
    "-- Round 10 (Game 1) --\n",
    "Player 1's deck: 9, 8, 5, 2\n",
    "Player 2's deck: 10, 1, 7, 6, 3, 4\n",
    "Player 1 plays: 9\n",
    "Player 2 plays: 10\n",
    "Player 2 wins round 10 of game 1!\n",
    "\n",
    "-- Round 11 (Game 1) --\n",
    "Player 1's deck: 8, 5, 2\n",
    "Player 2's deck: 1, 7, 6, 3, 4, 10, 9\n",
    "Player 1 plays: 8\n",
    "Player 2 plays: 1\n",
    "Player 1 wins round 11 of game 1!\n",
    "\n",
    "-- Round 12 (Game 1) --\n",
    "Player 1's deck: 5, 2, 8, 1\n",
    "Player 2's deck: 7, 6, 3, 4, 10, 9\n",
    "Player 1 plays: 5\n",
    "Player 2 plays: 7\n",
    "Player 2 wins round 12 of game 1!\n",
    "\n",
    "-- Round 13 (Game 1) --\n",
    "Player 1's deck: 2, 8, 1\n",
    "Player 2's deck: 6, 3, 4, 10, 9, 7, 5\n",
    "Player 1 plays: 2\n",
    "Player 2 plays: 6\n",
    "Playing a sub-game to determine the winner...\n",
    "\n",
    "=== Game 3 ===\n",
    "\n",
    "-- Round 1 (Game 3) --\n",
    "Player 1's deck: 8, 1\n",
    "Player 2's deck: 3, 4, 10, 9, 7, 5\n",
    "Player 1 plays: 8\n",
    "Player 2 plays: 3\n",
    "Player 1 wins round 1 of game 3!\n",
    "\n",
    "-- Round 2 (Game 3) --\n",
    "Player 1's deck: 1, 8, 3\n",
    "Player 2's deck: 4, 10, 9, 7, 5\n",
    "Player 1 plays: 1\n",
    "Player 2 plays: 4\n",
    "Playing a sub-game to determine the winner...\n",
    "\n",
    "=== Game 4 ===\n",
    "\n",
    "-- Round 1 (Game 4) --\n",
    "Player 1's deck: 8\n",
    "Player 2's deck: 10, 9, 7, 5\n",
    "Player 1 plays: 8\n",
    "Player 2 plays: 10\n",
    "Player 2 wins round 1 of game 4!\n",
    "The winner of game 4 is player 2!\n",
    "\n",
    "...anyway, back to game 3.\n",
    "Player 2 wins round 2 of game 3!\n",
    "\n",
    "-- Round 3 (Game 3) --\n",
    "Player 1's deck: 8, 3\n",
    "Player 2's deck: 10, 9, 7, 5, 4, 1\n",
    "Player 1 plays: 8\n",
    "Player 2 plays: 10\n",
    "Player 2 wins round 3 of game 3!\n",
    "\n",
    "-- Round 4 (Game 3) --\n",
    "Player 1's deck: 3\n",
    "Player 2's deck: 9, 7, 5, 4, 1, 10, 8\n",
    "Player 1 plays: 3\n",
    "Player 2 plays: 9\n",
    "Player 2 wins round 4 of game 3!\n",
    "The winner of game 3 is player 2!\n",
    "\n",
    "...anyway, back to game 1.\n",
    "Player 2 wins round 13 of game 1!\n",
    "\n",
    "-- Round 14 (Game 1) --\n",
    "Player 1's deck: 8, 1\n",
    "Player 2's deck: 3, 4, 10, 9, 7, 5, 6, 2\n",
    "Player 1 plays: 8\n",
    "Player 2 plays: 3\n",
    "Player 1 wins round 14 of game 1!\n",
    "\n",
    "-- Round 15 (Game 1) --\n",
    "Player 1's deck: 1, 8, 3\n",
    "Player 2's deck: 4, 10, 9, 7, 5, 6, 2\n",
    "Player 1 plays: 1\n",
    "Player 2 plays: 4\n",
    "Playing a sub-game to determine the winner...\n",
    "\n",
    "=== Game 5 ===\n",
    "\n",
    "-- Round 1 (Game 5) --\n",
    "Player 1's deck: 8\n",
    "Player 2's deck: 10, 9, 7, 5\n",
    "Player 1 plays: 8\n",
    "Player 2 plays: 10\n",
    "Player 2 wins round 1 of game 5!\n",
    "The winner of game 5 is player 2!\n",
    "\n",
    "...anyway, back to game 1.\n",
    "Player 2 wins round 15 of game 1!\n",
    "\n",
    "-- Round 16 (Game 1) --\n",
    "Player 1's deck: 8, 3\n",
    "Player 2's deck: 10, 9, 7, 5, 6, 2, 4, 1\n",
    "Player 1 plays: 8\n",
    "Player 2 plays: 10\n",
    "Player 2 wins round 16 of game 1!\n",
    "\n",
    "-- Round 17 (Game 1) --\n",
    "Player 1's deck: 3\n",
    "Player 2's deck: 9, 7, 5, 6, 2, 4, 1, 10, 8\n",
    "Player 1 plays: 3\n",
    "Player 2 plays: 9\n",
    "Player 2 wins round 17 of game 1!\n",
    "The winner of game 1 is player 2!\n",
    "```\n",
    "\n",
    "== Post-game results ==\n",
    "Player 1's deck: \n",
    "Player 2's deck: 7, 5, 6, 2, 4, 1, 10, 8, 9, 3\n",
    "After the game, the winning player's score is calculated from the cards they have in their original deck using the same rules as regular Combat. In the above game, the winning player's score is 291.\n",
    "\n",
    "Defend your honor as Raft Captain by playing the small crab in a game of Recursive Combat using the same two decks as before. What is the winning player's score?"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "34173\n"
     ]
    }
   ],
   "source": [
    "with open(\"d22-input.txt\") as f:\n",
    "    lines = f.read().split(\"\\n\\n\")\n",
    "lines = {line.split(\":\")[0]: line.split(\":\")[1].strip() for line in lines}\n",
    "lines = {key: list(map(lambda x: int(x), value.split(\"\\n\"))) for key, value in lines.items()}\n",
    "card_dict = lines.copy()\n",
    "\n",
    "p1 = card_dict[\"Player 1\"]\n",
    "p2 = card_dict[\"Player 2\"]\n",
    "\n",
    "i=0\n",
    "\n",
    "# part 2 solution\n",
    "# https://github.com/kermitnirmit/Advent-of-Code-2020/blob/master/day_22 solution.py\n",
    "def recursive_war(p1cards, p2cards, visited):\n",
    "    while(len(p1cards) > 0 and len(p2cards) > 0):\n",
    "        if (tuple(p1cards), tuple(p2cards)) in visited:\n",
    "            return 1, p1cards\n",
    "\n",
    "        visited.add((tuple(p1cards), tuple(p2cards)))\n",
    "        \n",
    "        a, b = p1cards.pop(0), p2cards.pop(0)\n",
    "        if len(p1cards) >= a and len(p2cards) >= b:\n",
    "            winner, _ = recursive_war(p1cards[:a], p2cards[:b], set())\n",
    "        else:\n",
    "            winner = 1 if a > b else 0\n",
    "\n",
    "        if winner == 1:\n",
    "            p1cards.extend([a, b])\n",
    "        else:\n",
    "            p2cards.extend([b, a])\n",
    "    return (1, p1cards) if len(p1cards) > 0 else (0, p2cards)\n",
    "print(sum((i + 1) * x for i, x in enumerate(recursive_war(card_dict[\"Player 1\"], card_dict[\"Player 2\"]\n",
    ", set())[1][::-1])))\n",
    "\t"
   ]
  },
  {
   "source": [
    "## Day 23:\n",
    "### --- Crab Cups ---\n",
    "\n",
    "The small crab challenges you to a game! The crab is going to mix up some cups, and you have to predict where they'll end up.\n",
    "\n",
    "The cups will be arranged in a circle and labeled clockwise (your puzzle input). For example, if your labeling were 32415, there would be five cups in the circle; going clockwise around the circle from the first cup, the cups would be labeled 3, 2, 4, 1, 5, and then back to 3 again.\n",
    "\n",
    "Before the crab starts, it will designate the first cup in your list as the current cup. The crab is then going to do 100 moves.\n",
    "\n",
    "Each move, the crab does the following actions:\n",
    "\n",
    "    The crab picks up the three cups that are immediately clockwise of the current cup. They are removed from the circle; cup spacing is adjusted as necessary to maintain the circle.\n",
    "    The crab selects a destination cup: the cup with a label equal to the current cup's label minus one. If this would select one of the cups that was just picked up, the crab will keep subtracting one until it finds a cup that wasn't just picked up. If at any point in this process the value goes below the lowest value on any cup's label, it wraps around to the highest value on any cup's label instead.\n",
    "    The crab places the cups it just picked up so that they are immediately clockwise of the destination cup. They keep the same order as when they were picked up.\n",
    "    The crab selects a new current cup: the cup which is immediately clockwise of the current cup.\n",
    "\n",
    "For example, suppose your cup labeling were 389125467. If the crab were to do merely 10 moves, the following changes would occur:\n",
    "```\n",
    "-- move 1 --\n",
    "cups: (3) 8  9  1  2  5  4  6  7 \n",
    "pick up: 8, 9, 1\n",
    "destination: 2\n",
    "\n",
    "-- move 2 --\n",
    "cups:  3 (2) 8  9  1  5  4  6  7 \n",
    "pick up: 8, 9, 1\n",
    "destination: 7\n",
    "\n",
    "-- move 3 --\n",
    "cups:  3  2 (5) 4  6  7  8  9  1 \n",
    "pick up: 4, 6, 7\n",
    "destination: 3\n",
    "\n",
    "-- move 4 --\n",
    "cups:  7  2  5 (8) 9  1  3  4  6 \n",
    "pick up: 9, 1, 3\n",
    "destination: 7\n",
    "\n",
    "-- move 5 --\n",
    "cups:  3  2  5  8 (4) 6  7  9  1 \n",
    "pick up: 6, 7, 9\n",
    "destination: 3\n",
    "\n",
    "-- move 6 --\n",
    "cups:  9  2  5  8  4 (1) 3  6  7 \n",
    "pick up: 3, 6, 7\n",
    "destination: 9\n",
    "\n",
    "-- move 7 --\n",
    "cups:  7  2  5  8  4  1 (9) 3  6 \n",
    "pick up: 3, 6, 7\n",
    "destination: 8\n",
    "\n",
    "-- move 8 --\n",
    "cups:  8  3  6  7  4  1  9 (2) 5 \n",
    "pick up: 5, 8, 3\n",
    "destination: 1\n",
    "\n",
    "-- move 9 --\n",
    "cups:  7  4  1  5  8  3  9  2 (6)\n",
    "pick up: 7, 4, 1\n",
    "destination: 5\n",
    "\n",
    "-- move 10 --\n",
    "cups: (5) 7  4  1  8  3  9  2  6 \n",
    "pick up: 7, 4, 1\n",
    "destination: 3\n",
    "\n",
    "-- final --\n",
    "cups:  5 (8) 3  7  4  1  9  2  6 \n",
    "```\n",
    "\n",
    "In the above example, the cups' values are the labels as they appear moving clockwise around the circle; the current cup is marked with ( ).\n",
    "\n",
    "After the crab is done, what order will the cups be in? Starting after the cup labeled 1, collect the other cups' labels clockwise into a single string with no extra characters; each number except 1 should appear exactly once. In the above example, after 10 moves, the cups clockwise from 1 are labeled 9, 2, 6, 5, and so on, producing 92658374. If the crab were to complete all 100 moves, the order after cup 1 would be 67384529.\n",
    "\n",
    "Using your labeling, simulate 100 moves. What are the labels on the cups after cup 1?\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Turn:  1\ncups with pickup removed [3, 2, 5, 4, 6, 7] Pickup:  [8, 9, 1]\ndestination cup 2\ndestination cup corrected 2\n0 3 8 2 1\n1 4 9 3 1\n2 5 1 4 1\n2 [3, 2, 8, 9, 1, 5, 4, 6, 7]\nTurn:  2\ncups with pickup removed [3, 2, 5, 4, 6, 7] Pickup:  [8, 9, 1]\ndestination cup 8\ndestination cup corrected 7\n0 3 8 6 5\n1 4 9 7 5\n2 5 1 8 5\n5 [3, 2, 5, 4, 6, 7, 8, 9, 1]\nTurn:  3\ncups with pickup removed [3, 2, 5, 8, 9, 1] Pickup:  [4, 6, 7]\ndestination cup 4\ndestination cup corrected 3\n0 3 4 1 0\n1 4 6 8 6\n2 5 7 9 6\n8 [4, 2, 5, 8, 9, 1, 3, 6, 7]\nTurn:  4\ncups with pickup removed [4, 2, 5, 8, 6, 7] Pickup:  [9, 1, 3]\ndestination cup 7\ndestination cup corrected 7\n0 3 9 6 5\n1 4 1 7 5\n2 5 3 8 5\n6 [4, 2, 5, 8, 6, 7, 9, 1, 3]\nTurn:  5\ncups with pickup removed [4, 2, 5, 8, 6, 3] Pickup:  [7, 9, 1]\ndestination cup 5\ndestination cup corrected 5\n0 3 7 3 2\n1 4 9 4 2\n2 5 1 5 2\n3 [4, 2, 5, 7, 9, 1, 8, 6, 3]\n"
     ]
    }
   ],
   "source": [
    "# read input file\n",
    "\n",
    "f = open(\"d23-input.txt\",\"r\")\n",
    "data = f.readlines()\n",
    "# split numbers into list and drop 0th entry containing original number read form file\n",
    "for i in range(len(data[0])):\n",
    "    data.append(int(data[0][i]))\n",
    "data.pop(0)\n",
    "\n",
    "# test data\n",
    "data = [int(i) for i in \"389125467\"]\n",
    "\n",
    "cups = data\n",
    "numberCups = len(cups)\n",
    "currentCup = cups[0]\n",
    "for turn in range (0,5):\n",
    "    print(\"Turn: \",turn+1)\n",
    "    #The crab picks up the three cups that are immediately clockwise of the current cup.\n",
    "    pickupCups = [cups[(cups.index(currentCup)+1) % numberCups],cups[(cups.index(currentCup)+2) % numberCups],cups[(cups.index(currentCup)+3) % numberCups]]\n",
    "    # They are removed from the circle; cup spacing is adjusted as necessary to maintain the circle.\n",
    "    cups.remove(pickupCups[0])\n",
    "    cups.remove(pickupCups[1])\n",
    "    cups.remove(pickupCups[2])\n",
    "    print(\"cups with pickup removed\", cups, \"Pickup: \",pickupCups)\n",
    "    # The crab selects a destination cup: the cup with a label equal to the current cup's label minus one.\n",
    "    destinationCup = (currentCup - 1) + ((currentCup - 1 < min(cups)) * max(cups))\n",
    "    print(\"destination cup\", destinationCup)\n",
    "    # If this would select one of the cups that was just picked up, the crab will keep subtracting one until it finds a cup that wasn't just picked up.\n",
    "    while not(destinationCup in cups):\n",
    "        destinationCup -= 1\n",
    "    # If at any point in this process the value goes below the lowest value on any cup's label, it wraps around to the highest value on any cup's label instead.\n",
    "        destinationCup = ((destinationCup >= min(cups)) * destinationCup) + ((destinationCup < min(cups)) * (max(cups)))\n",
    "    print(\"destination cup corrected\", destinationCup)\n",
    "    # The crab places the cups it just picked up so that they are immediately clockwise of the destination cup. They keep the same order as when they were picked up.\n",
    "    for i in range(len(pickupCups)):\n",
    "        # delist the elements of pickupCups and add back to cups\n",
    "        print(i, i+len(pickupCups), pickupCups[i],cups.index(destinationCup)+1+i,cups.index(destinationCup) )\n",
    "        if cups.index(destinationCup) == 0:\n",
    "            # first element becomes last\n",
    "            cups.append(cups[0])\n",
    "            cups.pop(0)\n",
    "            #cup added to front\n",
    "            cups.insert(0, pickupCups[i])\n",
    "        else:\n",
    "            cups.insert(cups.index(destinationCup)+1+i, pickupCups[i])\n",
    "    # The crab selects a new current cup: the cup which is immediately clockwise of the current cup.\n",
    "    currentCup = cups[(cups.index(currentCup)+1) % numberCups]\n",
    "    print(currentCup, cups)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "source": [
    "## Day 24:\n",
    "### --- Lobby Layout ---\n",
    "\n",
    "Your raft makes it to the tropical island; it turns out that the small crab was an excellent navigator. You make your way to the resort.\n",
    "\n",
    "As you enter the lobby, you discover a small problem: the floor is being renovated. You can't even reach the check-in desk until they've finished installing the new tile floor.\n",
    "\n",
    "The tiles are all hexagonal; they need to be arranged in a hex grid with a very specific color pattern. Not in the mood to wait, you offer to help figure out the pattern.\n",
    "\n",
    "The tiles are all white on one side and black on the other. They start with the white side facing up. The lobby is large enough to fit whatever pattern might need to appear there.\n",
    "\n",
    "A member of the renovation crew gives you a list of the tiles that need to be flipped over (your puzzle input). Each line in the list identifies a single tile that needs to be flipped by giving a series of steps starting from a reference tile in the very center of the room. (Every line starts from the same reference tile.)\n",
    "\n",
    "Because the tiles are hexagonal, every tile has six neighbors: east, southeast, southwest, west, northwest, and northeast. These directions are given in your list, respectively, as e, se, sw, w, nw, and ne. A tile is identified by a series of these directions with no delimiters; for example, esenee identifies the tile you land on if you start at the reference tile and then move one tile east, one tile southeast, one tile northeast, and one tile east.\n",
    "\n",
    "Each time a tile is identified, it flips from white to black or from black to white. Tiles might be flipped more than once. For example, a line like esew flips a tile immediately adjacent to the reference tile, and a line like nwwswee flips the reference tile itself.\n",
    "\n",
    "Here is a larger example:\n",
    "```\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",
    "```\n",
    "In the above example, 10 tiles are flipped once (to black), and 5 more are flipped twice (to black, then back to white). After all of these instructions have been followed, a total of 10 tiles are black.\n",
    "\n",
    "Go through the renovation crew's list and determine which tiles they need to flip. After all of the instructions have been followed, how many tiles are left with the black side up?"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## Day 24:\n",
    "### --- Part Two ---\n",
    "\n",
    "The tile floor in the lobby is meant to be a living art exhibit. Every day, the tiles are all flipped according to the following rules:\n",
    "\n",
    "Any black tile with zero or more than 2 black tiles immediately adjacent to it is flipped to white.\n",
    "Any white tile with exactly 2 black tiles immediately adjacent to it is flipped to black.\n",
    "Here, tiles immediately adjacent means the six tiles directly touching the tile in question.\n",
    "\n",
    "The rules are applied simultaneously to every tile; put another way, it is first determined which tiles need to be flipped, then they are all flipped at the same time.\n",
    "\n",
    "In the above example, the number of black tiles that are facing up after the given number of days has passed is as follows:\n",
    "\n",
    "Day 1: 15\n",
    "Day 2: 12\n",
    "Day 3: 25\n",
    "Day 4: 14\n",
    "Day 5: 23\n",
    "Day 6: 28\n",
    "Day 7: 41\n",
    "Day 8: 37\n",
    "Day 9: 49\n",
    "Day 10: 37\n",
    "\n",
    "Day 20: 132\n",
    "Day 30: 259\n",
    "Day 40: 406\n",
    "Day 50: 566\n",
    "Day 60: 788\n",
    "Day 70: 1106\n",
    "Day 80: 1373\n",
    "Day 90: 1844\n",
    "Day 100: 2208\n",
    "After executing this process a total of 100 times, there would be 2208 black tiles facing up.\n",
    "\n",
    "How many tiles will be black after 100 days?"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Total tiles with back side up: 373\n",
      "Total tiles with back side up: 3917\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "from collections import defaultdict\n",
    "\n",
    "with open(\"d24-input.txt\") as fp:\n",
    "\tlines = fp.read().splitlines()\n",
    "\n",
    "curr_floor = defaultdict(lambda: False)\n",
    "for line in lines:\n",
    "\tcoo = re.findall(r\"e|se|sw|w|nw|ne\", line)\n",
    "\tns = coo.count(\"se\") + coo.count(\"sw\") - coo.count(\"ne\") - coo.count(\"nw\")\n",
    "\twe = coo.count(\"e\") + coo.count(\"ne\") - coo.count(\"w\") - coo.count(\"sw\")\n",
    "\t\n",
    "\tcurr_floor[((ns, we))] = not curr_floor[(ns, we)]\n",
    "print(f\"Total tiles with back side up: {sum(list(curr_floor.values()))}\")\n",
    "\n",
    "floor = curr_floor\n",
    "\n",
    "for _ in range(100):\n",
    "\tnew_floor = defaultdict(lambda: False)\n",
    "\n",
    "\t# Add the outer ring of the current floor for consideration.\n",
    "\tfor k, v in floor.items():\n",
    "\t\tfor o in [(0, -1), (1, -1), (1, 0), (0, 1), (-1, 1), (-1, 0)]:\n",
    "\t\t\ttile = (k[0] + o[0], k[1] + o[1])\n",
    "\t\t\tif tile not in new_floor:\n",
    "\t\t\t\tnew_floor[tile] = floor.get(tile, False)\n",
    "\tfor k, v in new_floor.items():\n",
    "\t\t\n",
    "\t\tneighbors = sum([floor[(k[0] + o[0], k[1] + o[1])] for o in [(0, -1), (1, -1), (1, 0), (0, 1), (-1, 1), (-1, 0)]])\n",
    "\t\tif v:\n",
    "\t\t\tif not neighbors or neighbors > 2:\n",
    "\t\t\t\tnew_floor[k] = False\n",
    "\t\telse:\n",
    "\t\t\tif neighbors == 2:\n",
    "\t\t\t\tnew_floor[k] = True\n",
    "\n",
    "\tfloor = new_floor\n",
    "\n",
    "\n",
    "print(f\"Total tiles with back side up: {sum(list(new_floor.values()))}\")\n"
   ]
  },
  {
   "source": [
    "## Day 25:\n",
    "### --- Combo Breaker ---\n",
    "\n",
    "You finally reach the check-in desk. Unfortunately, their registration systems are currently offline, and they cannot check you in. Noticing the look on your face, they quickly add that tech support is already on the way! They even created all the room keys this morning; you can take yours now and give them your room deposit once the registration system comes back online.\n",
    "\n",
    "The room key is a small RFID card. Your room is on the 25th floor and the elevators are also temporarily out of service, so it takes what little energy you have left to even climb the stairs and navigate the halls. You finally reach the door to your room, swipe your card, and - beep - the light turns red.\n",
    "\n",
    "Examining the card more closely, you discover a phone number for tech support.\n",
    "\n",
    "\"Hello! How can we help you today?\" You explain the situation.\n",
    "\n",
    "\"Well, it sounds like the card isn't sending the right command to unlock the door. If you go back to the check-in desk, surely someone there can reset it for you.\" Still catching your breath, you describe the status of the elevator and the exact number of stairs you just had to climb.\n",
    "\n",
    "\"I see! Well, your only other option would be to reverse-engineer the cryptographic handshake the card does with the door and then inject your own commands into the data stream, but that's definitely impossible.\" You thank them for their time.\n",
    "\n",
    "Unfortunately for the door, you know a thing or two about cryptographic handshakes.\n",
    "\n",
    "The handshake used by the card and the door involves an operation that transforms a subject number. To transform a subject number, start with the value 1. Then, a number of times called the loop size, perform the following steps:\n",
    "\n",
    "Set the value to itself multiplied by the subject number.\n",
    "Set the value to the remainder after dividing the value by 20201227.\n",
    "The card always uses a specific, secret loop size when it transforms a subject number. The door always uses a different, secret loop size.\n",
    "\n",
    "The cryptographic handshake works like this:\n",
    "\n",
    "The card transforms the subject number of 7 according to the card's secret loop size. The result is called the card's public key.\n",
    "The door transforms the subject number of 7 according to the door's secret loop size. The result is called the door's public key.\n",
    "The card and door use the wireless RFID signal to transmit the two public keys (your puzzle input) to the other device. Now, the card has the door's public key, and the door has the card's public key. Because you can eavesdrop on the signal, you have both public keys, but neither device's loop size.\n",
    "The card transforms the subject number of the door's public key according to the card's loop size. The result is the encryption key.\n",
    "The door transforms the subject number of the card's public key according to the door's loop size. The result is the same encryption key as the card calculated.\n",
    "If you can use the two public keys to determine each device's loop size, you will have enough information to calculate the secret encryption key that the card and door use to communicate; this would let you send the unlock command directly to the door!\n",
    "\n",
    "For example, suppose you know that the card's public key is 5764801. With a little trial and error, you can work out that the card's loop size must be 8, because transforming the initial subject number of 7 with a loop size of 8 produces 5764801.\n",
    "\n",
    "Then, suppose you know that the door's public key is 17807724. By the same process, you can determine that the door's loop size is 11, because transforming the initial subject number of 7 with a loop size of 11 produces 17807724.\n",
    "\n",
    "At this point, you can use either device's loop size with the other device's public key to calculate the encryption key. Transforming the subject number of 17807724 (the door's public key) with a loop size of 8 (the card's loop size) produces the encryption key, 14897079. (Transforming the subject number of 5764801 (the card's public key) with a loop size of 11 (the door's loop size) produces the same encryption key: 14897079.)\n",
    "\n",
    "What encryption key is the handshake trying to establish?"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## Day 25:\n",
    "### --- Part Two ---\n",
    "\n",
    "The light turns green and the door unlocks. As you collapse onto the bed in your room, your pager goes off!\n",
    "\n",
    "\"It's an emergency!\" the Elf calling you explains. \"The soft serve machine in the cafeteria on sub-basement 7 just failed and you're the only one that knows how to fix it! We've already dispatched a reindeer to your location to pick you up.\"\n",
    "\n",
    "You hear the sound of hooves landing on your balcony.\n",
    "\n",
    "The reindeer carefully explores the contents of your room while you figure out how you're going to pay the 50 stars you owe the resort before you leave. Noticing that you look concerned, the reindeer wanders over to you; you see that it's carrying a small pouch.\n",
    "\n",
    "\"Sorry for the trouble,\" a note in the pouch reads. Sitting at the bottom of the pouch is a gold coin with a little picture of a starfish on it.\n",
    "\n",
    "Looks like you only needed 49 stars after all.\n",
    "\n",
    "You have enough stars to Pay the deposit.\n",
    "\n",
    "You spend all fifty stars to cover the room deposit!\n",
    "\n",
    "As you fix the soft serve machine, Santa offers you a ride in his sleigh; maybe the resort has a chimney you can use...\n",
    "\n",
    "Congratulations! You've finished every puzzle in Advent of Code 2020! I hope you had as much fun solving them as I had making them for you. I'd love to hear about your adventure; you can get in touch with me via contact info on my website or through Twitter.\n",
    "\n",
    "If you'd like to see more things like this in the future, please consider supporting Advent of Code and sharing it with others.\n",
    "\n",
    "To hear about future projects, you can follow me on Twitter.\n",
    "\n",
    "I've highlighted the easter eggs in each puzzle, just in case you missed any. Hover your mouse over them, and the easter egg will appear."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Card's Loopsize: 250288\n",
      "Door's Loopsize: 14519824\n",
      "Part 1: 11707042 (card -> door)\n"
     ]
    }
   ],
   "source": [
    "my_input = \"\"\"\n",
    "15335876\n",
    "15086442\n",
    "\"\"\"\n",
    "\n",
    "test_input = \"\"\"\n",
    "5764801\n",
    "17807724\n",
    "\"\"\"\n",
    "\n",
    "my_input=my_input.split(\"\\n\")[1:-1]\n",
    "\n",
    "\n",
    "card_pkey = int(my_input[0])\n",
    "door_pkey = int(my_input[1])\n",
    "\n",
    "\n",
    "card_loopsize = 0\n",
    "\n",
    "temp = 1\n",
    "while temp != card_pkey:\n",
    "\ttemp = (temp * 7) % 20201227\n",
    "\tcard_loopsize += 1\n",
    "print(f\"Card's Loopsize: {card_loopsize}\")\n",
    "\n",
    "door_loopsize = 0\n",
    "temp = 1\n",
    "while temp != door_pkey:\n",
    "\ttemp = (temp * 7) % 20201227\n",
    "\tdoor_loopsize += 1\n",
    "print(f\"Door's Loopsize: {door_loopsize}\")\n",
    "\n",
    "temp = 1\n",
    "for i in range(card_loopsize):\n",
    "\ttemp = temp * door_pkey % 20201227\n",
    "print(f'Part 1: {temp} (card -> door)')\n"
   ]
  }
 ]
}