src/19/day_19.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "test=\"\"\"Blueprint 1. Each ore robot costs 4 ore. Each clay robot costs 2 ore. Each obsidian robot costs 3 ore and 14 clay. Each geode robot costs 2 ore and 7 obsidian.\n",
    "Blueprint 2. Each ore robot costs 2 ore. Each clay robot costs 3 ore. Each obsidian robot costs 3 ore and 8 clay. Each geode robot costs 3 ore and 12 obsidian.\"\"\"\n",
    "source = test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "source = open(\"./day_19.txt\").read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "import math\n",
    "\n",
    "indicies = [1, 6, 12, 18, 21, 27, 30]\n",
    "def keywords(line):\n",
    "    return [math.floor(float(line[i].replace(\":\", \"\"))) for i in indicies]\n",
    "blueprints = numpy.array([keywords(line.split(\" \")) for line in source.splitlines()])\n",
    "BLUEPRINT_INDEX=0\n",
    "ORE_ROBOT_INDEX=1\n",
    "CLAY_ROBOT_INDEX=2\n",
    "OBSIDIAN_ROBOT_ORE_INDEX=3\n",
    "OBSIDIAN_ROBOT_CLAY_INDEX=4\n",
    "GEODE_ROBOT_ORE_INDEX=5\n",
    "GEODE_ROBOT_OBSIDIAN_INDEX=6\n",
    "\n",
    "ORE_INDEX=0\n",
    "CLAY_INDEX=1\n",
    "OBSIDIAN_INDEX=2\n",
    "GEODE_INDEX=3\n",
    "ORE_ROBOTS_INDEX=4\n",
    "CLAY_ROBOTS_INDEX=5\n",
    "OBSIDIAN_ROBOTS_INDEX=6\n",
    "GEODE_ROBOTS_INDEX=7\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "def can_build_ore_robot(path, blueprint):\n",
    "    ore = path[ORE_INDEX] - blueprint[ORE_ROBOT_INDEX]\n",
    "    return ore >= 0\n",
    "def build_ore_robot(path, blueprint):\n",
    "    output = path.copy()\n",
    "    output[ORE_INDEX] -= blueprint[ORE_ROBOT_INDEX]\n",
    "    output[ORE_ROBOTS_INDEX] += 1\n",
    "    return output\n",
    "def can_build_clay_robot(path, blueprint):\n",
    "    ore = path[ORE_INDEX]\n",
    "    ore -= blueprint[CLAY_ROBOT_INDEX]\n",
    "    return ore >= 0\n",
    "def build_clay_robot(path, blueprint):\n",
    "    output = path.copy()\n",
    "    output[ORE_INDEX] -= blueprint[CLAY_ROBOT_INDEX]\n",
    "    output[CLAY_ROBOTS_INDEX] += 1\n",
    "    return output\n",
    "def can_build_obsidian_robot(path, blueprint):\n",
    "    ore = path[ORE_INDEX]\n",
    "    ore -= blueprint[OBSIDIAN_ROBOT_ORE_INDEX]\n",
    "    clay = path[CLAY_INDEX] - blueprint[OBSIDIAN_ROBOT_CLAY_INDEX]\n",
    "    return ore >= 0 and clay >= 0\n",
    "def build_obsidian_robot(path, blueprint):\n",
    "    output = path.copy()\n",
    "    output[ORE_INDEX] -= blueprint[OBSIDIAN_ROBOT_ORE_INDEX]\n",
    "    output[CLAY_INDEX] -= blueprint[OBSIDIAN_ROBOT_CLAY_INDEX]\n",
    "    output[OBSIDIAN_ROBOTS_INDEX] += 1\n",
    "    return output\n",
    "def can_build_geode_robot(path, blueprint):\n",
    "    ore = path[ORE_INDEX] - blueprint[GEODE_ROBOT_ORE_INDEX]\n",
    "    obsidian = path[OBSIDIAN_INDEX] - blueprint[GEODE_ROBOT_OBSIDIAN_INDEX]\n",
    "    return ore >= 0 and obsidian >= 0\n",
    "def build_geode_robot(path, blueprint):\n",
    "    output = path.copy()\n",
    "    output[ORE_INDEX] -= blueprint[GEODE_ROBOT_ORE_INDEX]\n",
    "    output[OBSIDIAN_INDEX] -= blueprint[GEODE_ROBOT_OBSIDIAN_INDEX]\n",
    "    output[GEODE_ROBOTS_INDEX] += 1\n",
    "    return output\n",
    "def geode_robot_distance(path, blueprint):\n",
    "    ore = (blueprint[GEODE_ROBOT_ORE_INDEX] - path[ORE_INDEX])/path[ORE_INDEX] if path[ORE_INDEX]> 0 else blueprint[GEODE_ROBOT_ORE_INDEX]\n",
    "    obsidian = (blueprint[GEODE_ROBOT_OBSIDIAN_INDEX]-path[OBSIDIAN_INDEX]) / path[OBSIDIAN_INDEX] if path[OBSIDIAN_INDEX]> 0 else blueprint[GEODE_ROBOT_OBSIDIAN_INDEX]\n",
    "    return max(ore, obsidian)\n",
    "def simulate_blueprint(blueprint, steps): \n",
    "    savedPaths = {}\n",
    "    paths = [[0,0,0,0,1,0,0,0]]\n",
    "    for step in range(steps, 0, -1):\n",
    "        output = []\n",
    "        maxGeodes = max([path[GEODE_INDEX] + path[GEODE_ROBOTS_INDEX] for path in paths])\n",
    "        if(len(paths) > 10000): \n",
    "            paths.sort(key=lambda x: x[GEODE_INDEX], reverse=True)\n",
    "            paths = paths[:100000]\n",
    "        for path in [path for path in paths if savedPaths.get(str(path))==None]:\n",
    "            hash = str(path)\n",
    "            if(savedPaths.get(hash)!=None): continue\n",
    "            savedPaths[hash] = path[GEODE_INDEX]\n",
    "            should_bother = True #geode_robot_distance(path, blueprint) < step\n",
    "            should_build_ore_robot = should_bother and path[ORE_ROBOTS_INDEX] < max(blueprint[CLAY_ROBOT_INDEX], blueprint[OBSIDIAN_ROBOT_ORE_INDEX], blueprint[GEODE_ROBOT_ORE_INDEX], blueprint[ORE_ROBOT_INDEX]) and can_build_ore_robot(path, blueprint)\n",
    "            should_build_clay_robot = should_bother and path[CLAY_ROBOTS_INDEX] < blueprint[OBSIDIAN_ROBOT_CLAY_INDEX] and can_build_clay_robot(path, blueprint)\n",
    "            should_build_obsidian_robot = should_bother  and path[OBSIDIAN_ROBOTS_INDEX] < blueprint[GEODE_ROBOT_OBSIDIAN_INDEX] and can_build_obsidian_robot(path, blueprint)\n",
    "            should_build_geode_robot = should_bother and can_build_geode_robot(path, blueprint)\n",
    "            path[ORE_INDEX] += path[ORE_ROBOTS_INDEX]\n",
    "            path[CLAY_INDEX] += path[CLAY_ROBOTS_INDEX]\n",
    "            path[OBSIDIAN_INDEX] += path[OBSIDIAN_ROBOTS_INDEX]\n",
    "            path[GEODE_INDEX] += path[GEODE_ROBOTS_INDEX]\n",
    "            if should_build_ore_robot: output.append(build_ore_robot(path,blueprint))\n",
    "            if should_build_clay_robot: output.append(build_clay_robot(path, blueprint))\n",
    "            if should_build_obsidian_robot: output.append(build_obsidian_robot(path, blueprint))\n",
    "            if should_build_geode_robot: output.append(build_geode_robot(path, blueprint))\n",
    "            output.append(path.copy())\n",
    "        paths = output\n",
    "    return paths\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 1: Run for 24 steps - whole blueprint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Part 1 score is 1653\n"
     ]
    }
   ],
   "source": [
    "doRunPart1 = True\n",
    "if doRunPart1:\n",
    "    part1Score = sum([blueprint[BLUEPRINT_INDEX] * max(numpy.array(simulate_blueprint(blueprint, 24))[:,3]) for blueprint in blueprints])\n",
    "    print(\"Part 1 score is\", part1Score)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 2: Run for 32 steps - top 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Part 2 score is 4212\n"
     ]
    }
   ],
   "source": [
    "# print(blueprints[0:3])\n",
    "\n",
    "doRunPart2 = True\n",
    "if doRunPart2:\n",
    "    part2Score = numpy.prod([max(numpy.array(simulate_blueprint(blueprint, 32))[:,3]) for blueprint in blueprints[0:3]])\n",
    "    print(\"Part 2 score is\", numpy.prod(part2Score))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "b0fa6594d8f4cbf19f97940f81e996739fb7646882a419484c72d19e05852a7e"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}