Day 22 - Monkey Market.ipynb

{
 "cells": [
  {
   "cell_type": "raw",
   "id": "b8ac6495-665c-4899-b150-c47aae4c10cf",
   "metadata": {},
   "source": [
    "Day 22 I learned that \"number%10\" gives you the last digit, and that with defaultdict when you add to a key it automatically creates it. I did manage to create a recursive function, but only after asking ChatGPT why it didn't work the first time (I forgot to return itself)."
   ]
  },
  {
   "cell_type": "raw",
   "id": "909e0add-6806-442f-98d1-ef54e2582e72",
   "metadata": {},
   "source": [
    "Calculate the result of multiplying the secret number by 64. Then, mix this result into the secret number. Finally, prune the secret number.\n",
    "\n",
    "Calculate the result of dividing the secret number by 32. Round the result down to the nearest integer. Then, mix this result into the secret number. Finally, prune the secret number.\n",
    "\n",
    "Calculate the result of multiplying the secret number by 2048. Then, mix this result into the secret number. Finally, prune the secret number.\n",
    "\n",
    "\n",
    "To mix a value into the secret number, calculate the bitwise XOR of the given value and the secret number. Then, the secret number becomes the result of that operation. (If the secret number is 42 and you were to mix 15 into the secret number, the secret number would become 37.)\n",
    "\n",
    "To prune the secret number, calculate the value of the secret number modulo 16777216. Then, the secret number becomes the result of that operation. (If the secret number is 100000000 and you were to prune the secret number, the secret number would become 16113920.)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bbac4c58-9c9d-45e3-85a9-1966e3dd48a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mix_n_prune(number, secret):\n",
    "    secret = number ^ secret\n",
    "    secret = secret % 16777216\n",
    "    return secret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6965799a-2165-4b44-a18a-5a4d8fe6a2c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_next_number(secret):\n",
    "    number = secret * 64\n",
    "    secret = mix_n_prune(number, secret)\n",
    "\n",
    "    number = secret // 32\n",
    "    secret = mix_n_prune(number, secret)\n",
    "\n",
    "    number = secret * 2048\n",
    "    secret = mix_n_prune(number, secret)\n",
    "\n",
    "    return secret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f9189dbb-c439-496a-8b14-4784d300516a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15887950"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calculate_next_number(123)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8644b2a-a59a-483d-87dd-f753a58aa37a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "92732b57-3853-4a0e-baaf-81f734d0cde6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def recurse(secret, depth):\n",
    "    if depth == 0:\n",
    "        print(\"Secret number:\",secret)\n",
    "        return secret\n",
    "\n",
    "    print(secret, depth)\n",
    "    depth -= 1\n",
    "    return recurse(calculate_next_number(secret), depth)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "8970c9f4-b74d-43d8-ae57-855e888f70bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def recurse(secret, depth):\n",
    "    if depth == 0:\n",
    "        return secret\n",
    "\n",
    "    depth -= 1\n",
    "    return recurse(calculate_next_number(secret), depth)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "c48dbd80-2ba3-4a6d-bee8-50ddf8daa08f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 8685429\n",
      "10 4700978\n",
      "100 15273692\n",
      "2024 8667524\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "37327623"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accumulator = 0\n",
    "for number in [1, 10, 100, 2024]:\n",
    "    secret2000 = recurse(number, 2000)\n",
    "    print(number, secret2000)\n",
    "    accumulator += secret2000\n",
    "accumulator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27e62f92-fae7-4309-8aa8-69b4a1c2e222",
   "metadata": {},
   "source": [
    "## Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "f91ff932-d6c9-4c8a-826a-1bee09f2dfd4",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"day_22_input_0.txt\") as fname:\n",
    "    buyers = fname.read().splitlines()\n",
    "\n",
    "buyers = map(int, buyers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "5b1c473e-1255-498f-9dd8-c5afb936dbed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13461553007"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accumulator = 0\n",
    "for number in buyers:\n",
    "    accumulator += recurse(number, 2000)\n",
    "accumulator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6d56f69-1913-4420-9e4c-a78b9be2ef90",
   "metadata": {},
   "source": [
    "## Figuring out part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "d9ad3084-2f42-472b-8156-1712f985ca57",
   "metadata": {},
   "outputs": [],
   "source": [
    "def recurse(secret, depth):\n",
    "    global pricelist\n",
    "    if depth == 0:\n",
    "        return secret\n",
    "\n",
    "    print(secret%10)\n",
    "    pricelist.append(secret%10)\n",
    "    depth -= 1\n",
    "    return recurse(calculate_next_number(secret), depth)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "c3939d2c-12a4-41d8-9e66-157c240d3752",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "0\n",
      "6\n",
      "5\n",
      "4\n",
      "4\n",
      "6\n",
      "4\n",
      "4\n",
      "2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[3, 0, 6, 5, 4, 4, 6, 4, 4, 2]"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "global pricelist\n",
    "pricelist = []\n",
    "recurse(123,10)\n",
    "pricelist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "63d86773-6f20-45ed-85e2-a089d0707d50",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-999, -3, 6, -1, -1, 0, 2, -2, 0, -2]"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "difflist = [-999]\n",
    "for i in range(1,len(pricelist)):\n",
    "    difflist.append(pricelist[i] - pricelist[i-1])\n",
    "difflist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "id": "81dbe0f4-d81c-4d1c-8e4b-f365d52acb74",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 [-999, -3, 6, -1]\n",
      "4 [-3, 6, -1, -1]\n",
      "4 [6, -1, -1, 0]\n",
      "6 [-1, -1, 0, 2]\n",
      "4 [-1, 0, 2, -2]\n",
      "4 [0, 2, -2, 0]\n",
      "2 [2, -2, 0, -2]\n"
     ]
    }
   ],
   "source": [
    "for i in range(4,len(pricelist)+1):\n",
    "    print(pricelist[i-1], difflist[i-4:i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "07bb4341-0b6d-4b4e-970a-a9f131f9db63",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "8345c27e-2e2b-48ed-8271-b0ab1ba76767",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(int,\n",
       "            {(-999, -3, 6, -1): 5,\n",
       "             (-3, 6, -1, -1): 4,\n",
       "             (6, -1, -1, 0): 4,\n",
       "             (-1, -1, 0, 2): 6,\n",
       "             (-1, 0, 2, -2): 4,\n",
       "             (0, 2, -2, 0): 4,\n",
       "             (2, -2, 0, -2): 2})"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_of_sequences = defaultdict(int)\n",
    "seen_seq = set()\n",
    "\n",
    "for i in range(4,len(pricelist)+1):\n",
    "    sequence = tuple(difflist[i-4:i])\n",
    "    price = pricelist[i-1]\n",
    "    if sequence in seen_seq:\n",
    "        continue\n",
    "    else:\n",
    "        seen_seq.add(sequence)\n",
    "        dict_of_sequences[sequence] += price\n",
    "dict_of_sequences"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7720ab39-4bc5-4524-a810-565464c3afb8",
   "metadata": {},
   "source": [
    "### Part 2 example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "id": "8533c1bf-4a8e-4658-9f85-7db75842c026",
   "metadata": {},
   "outputs": [],
   "source": [
    "def recurse(secret, depth):\n",
    "    global pricelist\n",
    "    if depth == 0:\n",
    "        return secret\n",
    "\n",
    "    pricelist.append(secret%10)\n",
    "    depth -= 1\n",
    "    return recurse(calculate_next_number(secret), depth)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "id": "1f52dd2d-4cc4-48d0-b8d5-6b3193d18ec4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_of_sequences = defaultdict(int)\n",
    "\n",
    "global pricelist\n",
    "pricelist = []\n",
    "\n",
    "recurse(1,2000)  # populates pricelist\n",
    "difflist = [-999]\n",
    "\n",
    "for i in range(1,len(pricelist)):\n",
    "    difflist.append(pricelist[i] - pricelist[i-1])\n",
    "    \n",
    "seen_seq = set()\n",
    "\n",
    "for i in range(4,len(pricelist)+1):\n",
    "    sequence = tuple(difflist[i-4:i])\n",
    "    price = pricelist[i-1]\n",
    "    if sequence in seen_seq:\n",
    "        continue\n",
    "    else:\n",
    "        seen_seq.add(sequence)\n",
    "        dict_of_sequences[sequence] += price\n",
    "dict_of_sequences[(-2,1,-1,3)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "id": "81675d04-7699-4103-b5f7-5f52647f0e30",
   "metadata": {},
   "outputs": [],
   "source": [
    "global pricelist\n",
    "buyers = [1,2,3,2024]\n",
    "dict_of_sequences = defaultdict(int)\n",
    "\n",
    "for buyer in buyers:\n",
    "    pricelist = []  # resets for each buyer\n",
    "    seen_seq = set()  # restes for each buyer\n",
    "    difflist = [-999]  # resets for each buyer\n",
    "    \n",
    "    recurse(buyer,2000)  # populates pricelist\n",
    "    \n",
    "    # generate difflist\n",
    "    for i in range(1,len(pricelist)):\n",
    "        difflist.append(pricelist[i] - pricelist[i-1])\n",
    "\n",
    "    # rolling window, get the price and the sequence that led up to it\n",
    "    for i in range(4,len(pricelist)+1):\n",
    "        sequence = tuple(difflist[i-4:i])\n",
    "        price = pricelist[i-1]\n",
    "\n",
    "        if sequence in seen_seq:  # only take the FIRST time we see that sequence\n",
    "            continue\n",
    "        else:\n",
    "            seen_seq.add(sequence)\n",
    "            dict_of_sequences[sequence] += price  # add that sequence price to a running total from all buyers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "id": "88b78394-eb4a-405b-a53c-d2a259b74252",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-2, 1, -1, 3)"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(dict_of_sequences, key=dict_of_sequences.get)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "id": "a5878275-d96c-4669-bb9b-52c93c4aa774",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_of_sequences[max(dict_of_sequences, key=dict_of_sequences.get)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71c4f8d5-18be-4521-8178-d07f9c6203a3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d9f2f188-e8ec-466c-b691-af211f8ca8f1",
   "metadata": {},
   "source": [
    "## Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "id": "240b03ae-1357-4786-b6d8-8fa2b730fd0d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1499"
      ]
     },
     "execution_count": 224,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def recurse(secret, depth):\n",
    "    global pricelist\n",
    "    if depth == 0:\n",
    "        return secret\n",
    "\n",
    "    pricelist.append(secret%10)\n",
    "    depth -= 1\n",
    "    return recurse(calculate_next_number(secret), depth)\n",
    "\n",
    "with open(\"day_22_input_0.txt\") as fname:\n",
    "    buyers = fname.read().splitlines()\n",
    "\n",
    "buyers = map(int, buyers)\n",
    "global pricelist\n",
    "dict_of_sequences = defaultdict(int)\n",
    "\n",
    "for buyer in buyers:\n",
    "    pricelist = []  # resets for each buyer\n",
    "    seen_seq = set()  # restes for each buyer\n",
    "    difflist = [-999]  # resets for each buyer\n",
    "    \n",
    "    recurse(buyer,2000)  # populates pricelist\n",
    "    \n",
    "    # generate difflist\n",
    "    for i in range(1,len(pricelist)):\n",
    "        difflist.append(pricelist[i] - pricelist[i-1])\n",
    "\n",
    "    # rolling window, get the price and the sequence that led up to it\n",
    "    for i in range(4,len(pricelist)+1):\n",
    "        sequence = tuple(difflist[i-4:i])\n",
    "        price = pricelist[i-1]\n",
    "\n",
    "        if sequence in seen_seq:  # only take the FIRST time we see that sequence\n",
    "            continue\n",
    "        else:\n",
    "            seen_seq.add(sequence)\n",
    "            dict_of_sequences[sequence] += price  # add that sequence price to a running total from all buyers\n",
    "\n",
    "dict_of_sequences[max(dict_of_sequences, key=dict_of_sequences.get)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e46a5d38-89a0-4ff1-b7ca-f2b5bf74db90",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}