AdventOfCode_13.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 13 - Distress Signal\n",
    "##### Part 1\n",
    "\n",
    "Find how many pairs of packets are in the right order. Sum the indices of those packets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of parsed packets: 150.\n"
     ]
    }
   ],
   "source": [
    "#with open(\"test.txt\", \"r\") as f:\n",
    "with open(\"aoc_13_input.txt\", \"r\") as f:\n",
    "    lines = f.read().strip().split(\"\\n\\n\")\n",
    "\n",
    "def parse_input(input_list):\n",
    "    if not input_list or input_list == str([]):  \n",
    "        return []\n",
    "    \n",
    "    stack = []\n",
    "    for i, c in enumerate(input_list):\n",
    "        if c == \",\":                                            \n",
    "            stack.append(',')\n",
    "\n",
    "        elif c == \"[\":\n",
    "            if len(stack) > 1 and type(stack[-2]) == str and stack[-2].isnumeric():\n",
    "                stack[-2] = int(stack[-2])\n",
    "            stack.append(\"[\")\n",
    "            \n",
    "        elif c == \"]\":\n",
    "            if type(stack[-1]) == str and stack[-1].isnumeric():\n",
    "                stack[-1] = int(stack[-1])\n",
    "            proc = [\"]\"]\n",
    "            while proc[-1] != \"[\":\n",
    "                proc.append(stack.pop())\n",
    "            stack.append(proc[1:-1:2][::-1])\n",
    "\n",
    "        # otherwise c.isnumeric() == True\n",
    "        else:    \n",
    "            if stack[-1] == ',' and type(stack[-2]) == str:     \n",
    "                stack[-2] = int(stack[-2])\n",
    "            if stack[-1].isnumeric():                           \n",
    "                stack[-1] += c\n",
    "            else:                                               \n",
    "                stack.append(c)\n",
    "    return stack[0]\n",
    "\n",
    "data = []\n",
    "for line in lines:\n",
    "    A, B = line.split(\"\\n\")\n",
    "    a, b = parse_input(A), parse_input(B)\n",
    "    assert \"\".join(str(a)).replace(\" \", \"\") == A\n",
    "    assert \"\".join(str(b)).replace(\" \", \"\") == B\n",
    "    data.append([a,b])\n",
    "\n",
    "num_packets = len(lines)\n",
    "print(f\"Total number of parsed packets: {num_packets}.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Return meaning: \n",
    "#   0 : continue checking\n",
    "#  -1 : right order\n",
    "#   1 : wrong order\n",
    "def compare(A, B):\n",
    "    if type(A) == type(B) == int:       return -1 if A < B else 1 if A > B else 0\n",
    "    elif type(A) == type(B) == list:    return list_compare(A,B)    \n",
    "    elif type(A) == int:                return compare([A], B)\n",
    "    else:                               return compare(A, [B])\n",
    "    \n",
    "def list_compare(C, D):\n",
    "    L = min(len(C), len(D))\n",
    "    for i in range(L):\n",
    "        curr = compare(C[i], D[i])\n",
    "        if curr != 0:                   return curr\n",
    "    if len(C) < len(D):                 return -1\n",
    "    elif len(C) == len(D):              return 0\n",
    "    else:                               return 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Part 1: The sum of all indices of pairs in the right order is: 6070\n"
     ]
    }
   ],
   "source": [
    "correct_indices = list(filter(lambda a : a > 0, [i if list_compare(d[0], d[1]) == -1 else 0 for i,d in enumerate(data, start=1)]))\n",
    "print(f\"Part 1: The sum of all indices of pairs in the right order is: {sum(correct_indices)}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Part 2 - Divider Packets\n",
    "\n",
    "Adding in [[2]] and [[6]] as divider packets, organize all packets into the correct order. Multiply the indices of the divider packets to find and return the decoder key.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t107: [[2]]\n",
      "\t194: [[6]]\n",
      "Part 2: The decoder key for this distress signal is: 107 * 194 = 20758\n"
     ]
    }
   ],
   "source": [
    "import functools \n",
    "\n",
    "# since we are getting rid of all packets > [[6]], the length of sorted_packets is the index of [[6]]\n",
    "sorted_packets = sorted(list(filter(lambda x : list_compare(x, [[6]]) <= 0, [a for d in data for a in d] + [[[2]], [[6]]])), key = functools.cmp_to_key(list_compare))\n",
    "first, second = sorted_packets.index([[2]]) + 1, len(sorted_packets)\n",
    "\n",
    "print(f\"\\t{first}: {sorted_packets[first - 1]}\")\n",
    "print(f\"\\t{second}: {sorted_packets[-1]}\")\n",
    "print(f\"Part 2: The decoder key for this distress signal is: {first} * {second} = {first * second}\")\n",
    "\n",
    "# 9240 too low"
   ]
  }
 ],
 "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.11.1 (tags/v3.11.1:a7a450f, Dec  6 2022, 19:58:39) [MSC v.1934 64 bit (AMD64)]"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "d01e1b6807cdc6c73188860b94d3a57f012fc5e069ee56fb893a142c4a2f0812"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}