2023/Day02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 2\n",
    "\n",
    "Full text of the task can be found on [AoC website](https://adventofcode.com/2023/day/2).\n",
    "\n",
    "We arrive at the `Snow Island`, how exciting! We are greated by an Elf who wants to play a game while we walk!\n",
    "\n",
    "This is how ChatGPT 4 with DALL·E illustrated the description of this tasks.\n",
    "\n",
    "<img src=\"./ChatGPT_illustrations/day02.png\" width=\"400\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part One\n",
    "\n",
    "The game includes the Elf hiding some cubes of different colors in the bag. We then draw sets of cubes from the bag (putting the cubes back after drawing) three times. \n",
    "\n",
    "The input consists of game number and the sets of drawn cubes separated by the semicolon. The questions is to determine whether the number of cubes hidden during a given game is compatible with the given set of cubes. \n",
    "\n",
    "Example:\n",
    "\n",
    "```\n",
    "Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green\n",
    "Game 2: 1 blue, 2 green; 3 green, 4 blue, 1 red; 1 green, 1 blue\n",
    "Game 3: 8 green, 6 blue, 20 red; 5 blue, 4 red, 13 green; 5 green, 1 red\n",
    "Game 4: 1 green, 3 red, 6 blue; 3 green, 6 red; 3 green, 15 blue, 14 red\n",
    "Game 5: 6 red, 1 blue, 3 green; 2 blue, 1 red, 2 green\n",
    "```\n",
    "\n",
    "**Q:** Which games would be possible if only 12 red cubes, 13 green cubes, and 14 blue cubes were hidden in the bag?\n",
    "\n",
    "**A:** 1, 2, and 5.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "example_string = \"\"\"Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green\n",
    "Game 2: 1 blue, 2 green; 3 green, 4 blue, 1 red; 1 green, 1 blue\n",
    "Game 3: 8 green, 6 blue, 20 red; 5 blue, 4 red, 13 green; 5 green, 1 red\n",
    "Game 4: 1 green, 3 red, 6 blue; 3 green, 6 red; 3 green, 15 blue, 14 red\n",
    "Game 5: 6 red, 1 blue, 3 green; 2 blue, 1 red, 2 green\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I will split this task, first I want to process the string with set details into a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'green': 3, 'blue': 7, 'red': 11}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def note_set(ball_set):\n",
    "    \"\"\"\n",
    "    Converts a string of the form 'number color' into a dict of the form {'color': number}\n",
    "    Example: '3 green, 7 blue, 11 red' -> {'green': 3, 'blue': 7, 'red': 11}\n",
    "    \"\"\"\n",
    "    # make sure ball_set is a string\n",
    "    ball_set = str(ball_set)\n",
    "    # strip out of leading and trailing whitespace\n",
    "    ball_set = ball_set.strip()\n",
    "    ball_set = ball_set.split(\", \")\n",
    "    ball_set = [ball.split(\" \") for ball in ball_set]\n",
    "    ball_set = {ball[1]: int(ball[0]) for ball in ball_set}\n",
    "    return ball_set\n",
    "\n",
    "note_set(\"3 green, 7 blue, 11 red\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, given a list of dictionaries I want the highest value for each key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'green': 5, 'blue': 7, 'red': 11}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def take_max_per_key(list_of_dicts):\n",
    "    \"\"\"\n",
    "    Takes a list of dicts and returns a dict with the max value for each key\n",
    "    \"\"\"\n",
    "    # initialize empty dict\n",
    "    max_dict = {}\n",
    "    # loop through each dict in list_of_dicts\n",
    "    for dict_ in list_of_dicts:\n",
    "        # loop through each key in dict_\n",
    "        for key in dict_:\n",
    "            # if key not in max_dict, add it\n",
    "            if key not in max_dict:\n",
    "                max_dict[key] = dict_[key]\n",
    "            # if key in max_dict, compare values and keep the max\n",
    "            else:\n",
    "                if dict_[key] > max_dict[key]:\n",
    "                    max_dict[key] = dict_[key]\n",
    "    return max_dict\n",
    "\n",
    "take_max_per_key([{'green': 3, 'blue': 7, 'red': 11}, {'green': 5, 'blue': 2, 'red': 1}])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, using those two functions I want to process an input string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: {'blue': 6, 'red': 4, 'green': 2},\n",
       " 2: {'blue': 4, 'green': 3, 'red': 1},\n",
       " 3: {'green': 13, 'blue': 6, 'red': 20},\n",
       " 4: {'green': 3, 'red': 14, 'blue': 15},\n",
       " 5: {'red': 6, 'blue': 2, 'green': 3}}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def process_input(input_string):\n",
    "    \"\"\"\n",
    "    Takes a string of the form 'Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green'\n",
    "    and returns a dict of the form {game: {color: number}}\n",
    "    \"\"\"\n",
    "    # create a dictionary of games\n",
    "    games = {}\n",
    "    for line in input_string.splitlines():\n",
    "        if line:\n",
    "            game, cubes = line.split(':')\n",
    "            game = int(game.split(\" \")[1])\n",
    "            cubes = cubes.strip().split(';')\n",
    "            cubes = [note_set(ball_set) for ball_set in cubes]\n",
    "            cubes = take_max_per_key(cubes)\n",
    "            games[game] = cubes\n",
    "    return games\n",
    "\n",
    "test_games = process_input(example_string)\n",
    "test_games"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now, I want to check the test combinations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_combo = {'red': 12, 'green': 13, 'blue': 14}\n",
    "def check_combo(combo, games):\n",
    "    \"\"\"\n",
    "    Checks for which games the combo is a valid solution\n",
    "    \"\"\"\n",
    "    results = [game for game in games if all(combo[key] >= games[game][key] for key in combo)]\n",
    "    return results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, merging those functions together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def part_one(input, combo_text, test = False):\n",
    "    if test:\n",
    "        games = process_input(input)\n",
    "    else:\n",
    "        with open(input, 'r+') as f:\n",
    "            games = process_input(f.read())\n",
    "    combo = note_set(combo_text)\n",
    "    return sum(check_combo(combo, games))\n",
    "\n",
    "assert(part_one(example_string, '12 red, 13 green, 14 blue', test=True) == 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2439"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "part_one(\"./inputs/day02.txt\", \"12 red, 13 green, 14 blue\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's the right answer! You are one gold star ⭐ closer to restoring snow operations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part Two \n",
    "\n",
    "Here, we want to get the power of a minimum set of each of the games. Thankfully, the function with processing the input I wrote for part one is all we need. Then I need to multiply the values, and we are all set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_dict = {'red': 1, 'green': 3, 'blue': 4}\n",
    "from functools import reduce\n",
    "# multiply all values in a dict\n",
    "def calculate_power(dict_):\n",
    "    return reduce(lambda x, y: x*y, dict_.values())\n",
    "\n",
    "calculate_power(test_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def part_two(input, test = False):\n",
    "    if test:\n",
    "        games = process_input(input)\n",
    "    else:\n",
    "        with open(input, 'r+') as f:\n",
    "            games = process_input(f.read())\n",
    "    power = [calculate_power(games[game]) for game in games]\n",
    "    return sum(power)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert(part_two(example_string, test=True) == 2286)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "63711"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "part_two(\"./inputs/day02.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's the right answer! You are one gold star ⭐ closer to restoring snow operations."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}