Advent_of_Code_2024.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPSL1Y5jf8JSLWwd9egMf65",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/scronge/Algorithms/blob/main/Advent_of_Code_2024.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 1**"
      ],
      "metadata": {
        "id": "1g1PkM4deyEn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "--- Day 1: Historian Hysteria ---\n",
        "The Chief Historian is always present for the big Christmas sleigh launch, but nobody has seen him in months! Last anyone heard, he was visiting locations that are historically significant to the North Pole; a group of Senior Historians has asked you to accompany them as they check the places they think he was most likely to visit.\n",
        "\n",
        "As each location is checked, they will mark it on their list with a star. They figure the Chief Historian must be in one of the first fifty places they'll look, so in order to save Christmas, you need to help them get fifty stars on their list before Santa takes off on 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",
        "You haven't even left yet and the group of Elvish Senior Historians has already hit a problem: their list of locations to check is currently empty. Eventually, someone decides that the best place to check first would be the Chief Historian's office.\n",
        "\n",
        "Upon pouring into the office, everyone confirms that the Chief Historian is indeed nowhere to be found. Instead, the Elves discover an assortment of notes and lists of historically significant locations! This seems to be the planning the Chief Historian was doing before he left. Perhaps these notes can be used to determine which locations to search?\n",
        "\n",
        "Throughout the Chief's office, the historically significant locations are listed not by name but by a unique number called the location ID. To make sure they don't miss anything, The Historians split into two groups, each searching the office and trying to create their own complete list of location IDs.\n",
        "\n",
        "There's just one problem: by holding the two lists up side by side (your puzzle input), it quickly becomes clear that the lists aren't very similar. Maybe you can help The Historians reconcile their lists?\n",
        "\n",
        "For example:\n",
        "\n",
        "3   4\n",
        "4   3\n",
        "2   5\n",
        "1   3\n",
        "3   9\n",
        "3   3\n",
        "Maybe the lists are only off by a small amount! To find out, pair up the numbers and measure how far apart they are. Pair up the smallest number in the left list with the smallest number in the right list, then the second-smallest left number with the second-smallest right number, and so on.\n",
        "\n",
        "Within each pair, figure out how far apart the two numbers are; you'll need to add up all of those distances. For example, if you pair up a 3 from the left list with a 7 from the right list, the distance apart is 4; if you pair up a 9 with a 3, the distance apart is 6.\n",
        "\n",
        "In the example list above, the pairs and distances would be as follows:\n",
        "\n",
        "The smallest number in the left list is 1, and the smallest number in the right list is 3. The distance between them is 2.\n",
        "The second-smallest number in the left list is 2, and the second-smallest number in the right list is another 3. The distance between them is 1.\n",
        "The third-smallest number in both lists is 3, so the distance between them is 0.\n",
        "The next numbers to pair up are 3 and 4, a distance of 1.\n",
        "The fifth-smallest numbers in each list are 3 and 5, a distance of 2.\n",
        "Finally, the largest number in the left list is 4, while the largest number in the right list is 9; these are a distance 5 apart.\n",
        "To find the total distance between the left list and the right list, add up the distances between all of the pairs you found. In the example above, this is 2 + 1 + 0 + 1 + 2 + 5, a total distance of 11!\n",
        "\n",
        "Your actual left and right lists contain many location IDs. What is the total distance between your lists?\n"
      ],
      "metadata": {
        "id": "jwrC5SYqg64s"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "gDNZfUD7gaOW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from numpy import genfromtxt\n",
        "\n",
        "data = genfromtxt(\"data1.txt\", delimiter=\"   \").T\n",
        "first_row = data[0]\n",
        "second_row = data[1]\n",
        "\n",
        "first_row_sorted = sorted(first_row)\n",
        "second_row_sorted = sorted(second_row)\n",
        "\n",
        "final_diffs = 0\n",
        "for i in range(len(first_row_sorted)):\n",
        "    final_diffs += abs(first_row_sorted[i] - second_row_sorted[i])\n",
        "\n",
        "print(int(final_diffs))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jhf8EzTidVbZ",
        "outputId": "2e6a7469-518e-489f-d8da-3bd20f7a6692"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1530215\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "--- Part Two ---\n",
        "Your analysis only confirmed what everyone feared: the two lists of location IDs are indeed very different.\n",
        "\n",
        "Or are they?\n",
        "\n",
        "The Historians can't agree on which group made the mistakes or how to read most of the Chief's handwriting, but in the commotion you notice an interesting detail: a lot of location IDs appear in both lists! Maybe the other numbers aren't location IDs at all but rather misinterpreted handwriting.\n",
        "\n",
        "This time, you'll need to figure out exactly how often each number from the left list appears in the right list. Calculate a total similarity score by adding up each number in the left list after multiplying it by the number of times that number appears in the right list.\n",
        "\n",
        "Here are the same example lists again:\n",
        "\n",
        "3   4\n",
        "4   3\n",
        "2   5\n",
        "1   3\n",
        "3   9\n",
        "3   3\n",
        "For these example lists, here is the process of finding the similarity score:\n",
        "\n",
        "The first number in the left list is 3. It appears in the right list three times, so the similarity score increases by 3 * 3 = 9.\n",
        "The second number in the left list is 4. It appears in the right list once, so the similarity score increases by 4 * 1 = 4.\n",
        "The third number in the left list is 2. It does not appear in the right list, so the similarity score does not increase (2 * 0 = 0).\n",
        "The fourth number, 1, also does not appear in the right list.\n",
        "The fifth number, 3, appears in the right list three times; the similarity score increases by 9.\n",
        "The last number, 3, appears in the right list three times; the similarity score again increases by 9.\n",
        "So, for these example lists, the similarity score at the end of this process is 31 (9 + 4 + 0 + 0 + 9 + 9).\n",
        "\n",
        "Once again consider your left and right lists. What is their similarity score?\n"
      ],
      "metadata": {
        "id": "4yttrNXzgzfi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "final_diffs = 0\n",
        "result_map = dict()\n",
        "\n",
        "for i in range(len(first_row)):\n",
        "    num = first_row[i]\n",
        "    if num not in result_map.keys():\n",
        "        result_map[num] = 0\n",
        "        for j in range(len(second_row)):\n",
        "            if num == second_row[j]:\n",
        "                result_map[num] += num\n",
        "    final_diffs += result_map[num]\n",
        "\n",
        "print(int(final_diffs))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8IvqgWioe2Ij",
        "outputId": "f7da15a7-bfc8-4d59-d516-9c74aa6413c5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "26800609\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 2**"
      ],
      "metadata": {
        "id": "1yOTi4PSe2pa"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "--- Day 2: Red-Nosed Reports ---\n",
        "Fortunately, the first location The Historians want to search isn't a long walk from the Chief Historian's office.\n",
        "\n",
        "While the Red-Nosed Reindeer nuclear fusion/fission plant appears to contain no sign of the Chief Historian, the engineers there run up to you as soon as they see you. Apparently, they still talk about the time Rudolph was saved through molecular synthesis from a single electron.\n",
        "\n",
        "They're quick to add that - since you're already here - they'd really appreciate your help analyzing some unusual data from the Red-Nosed reactor. You turn to check if The Historians are waiting for you, but they seem to have already divided into groups that are currently searching every corner of the facility. You offer to help with the unusual data.\n",
        "\n",
        "The unusual data (your puzzle input) consists of many reports, one report per line. Each report is a list of numbers called levels that are separated by spaces. For example:\n",
        "\n",
        "7 6 4 2 1\n",
        "1 2 7 8 9\n",
        "9 7 6 2 1\n",
        "1 3 2 4 5\n",
        "8 6 4 4 1\n",
        "1 3 6 7 9\n",
        "This example data contains six reports each containing five levels.\n",
        "\n",
        "The engineers are trying to figure out which reports are safe. The Red-Nosed reactor safety systems can only tolerate levels that are either gradually increasing or gradually decreasing. So, a report only counts as safe if both of the following are true:\n",
        "\n",
        "The levels are either all increasing or all decreasing.\n",
        "Any two adjacent levels differ by at least one and at most three.\n",
        "In the example above, the reports can be found safe or unsafe by checking those rules:\n",
        "\n",
        "7 6 4 2 1: Safe because the levels are all decreasing by 1 or 2.\n",
        "1 2 7 8 9: Unsafe because 2 7 is an increase of 5.\n",
        "9 7 6 2 1: Unsafe because 6 2 is a decrease of 4.\n",
        "1 3 2 4 5: Unsafe because 1 3 is increasing but 3 2 is decreasing.\n",
        "8 6 4 4 1: Unsafe because 4 4 is neither an increase or a decrease.\n",
        "1 3 6 7 9: Safe because the levels are all increasing by 1, 2, or 3.\n",
        "So, in this example, 2 reports are safe.\n",
        "\n",
        "Analyze the unusual data from the engineers. How many reports are safe?"
      ],
      "metadata": {
        "id": "MuTgfbMkg2xC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def valid_num_diff(num1, num2):\n",
        "    return abs(num1-num2) < 4 and (abs(num1-num2) > 0)\n",
        "\n",
        "def go_through_row(row, tolerance):\n",
        "    for i in range(len(row)):\n",
        "        row[i] = int(row[i])\n",
        "    row_safe = True\n",
        "    is_increasing = True\n",
        "    safe_buffers = set()\n",
        "\n",
        "    if not len(row) < 1:\n",
        "        if row[0]>row[1]:\n",
        "            is_increasing = False\n",
        "        for j in range(len(row) - 1):\n",
        "            num1 = row[j]\n",
        "            num2 = row[j+1]\n",
        "            if not valid_num_diff(num1, num2) or (is_increasing and num1 > num2) or (not is_increasing and num1 < num2):\n",
        "                row_safe = False\n",
        "            if tolerance:\n",
        "                safe_buffers.add(j)\n",
        "                safe_buffers.add(j+1)\n",
        "        if tolerance and not row_safe:\n",
        "            for buffer in safe_buffers:\n",
        "                temp = row.copy()\n",
        "                row.pop(buffer)\n",
        "                row_safe = go_through_row(row, False)\n",
        "                row = temp\n",
        "                if row_safe is True:\n",
        "                    return True\n",
        "        if row_safe:\n",
        "            return True\n",
        "    return False\n",
        "\n",
        "data = open('data2.txt', 'r')\n",
        "safe_rows = 0\n",
        "for line in data:\n",
        "    if go_through_row(line.strip().split(' '), False): safe_rows += 1\n",
        "\n",
        "print(safe_rows)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bmotp_fsfFrf",
        "outputId": "76273af4-cf60-4117-cd5c-1be6bc1226dc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "334\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "--- Part Two ---\n",
        "The engineers are surprised by the low number of safe reports until they realize they forgot to tell you about the Problem Dampener.\n",
        "\n",
        "The Problem Dampener is a reactor-mounted module that lets the reactor safety systems tolerate a single bad level in what would otherwise be a safe report. It's like the bad level never happened!\n",
        "\n",
        "Now, the same rules apply as before, except if removing a single level from an unsafe report would make it safe, the report instead counts as safe.\n",
        "\n",
        "More of the above example's reports are now safe:\n",
        "\n",
        "7 6 4 2 1: Safe without removing any level.\n",
        "1 2 7 8 9: Unsafe regardless of which level is removed.\n",
        "9 7 6 2 1: Unsafe regardless of which level is removed.\n",
        "1 3 2 4 5: Safe by removing the second level, 3.\n",
        "8 6 4 4 1: Safe by removing the third level, 4.\n",
        "1 3 6 7 9: Safe without removing any level.\n",
        "Thanks to the Problem Dampener, 4 reports are actually safe!\n",
        "\n",
        "Update your analysis by handling situations where the Problem Dampener can remove a single level from unsafe reports. How many reports are now safe?"
      ],
      "metadata": {
        "id": "W0EWHuXFg1ki"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data = open('data2.txt', 'r')\n",
        "safe_rows = 0\n",
        "for line in data:\n",
        "    if go_through_row(line.strip().split(' '), True): safe_rows += 1\n",
        "\n",
        "print(safe_rows)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1bXYxka4e9rs",
        "outputId": "85c3bd94-e19e-433e-9ea4-e3127cbf6210"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "400\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "sRsii2tNe99C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 3**"
      ],
      "metadata": {
        "id": "MgnLPuy_e-WN"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "--- Day 3: Mull It Over ---\n",
        "\"Our computers are having issues, so I have no idea if we have any Chief Historians in stock! You're welcome to check the warehouse, though,\" says the mildly flustered shopkeeper at the North Pole Toboggan Rental Shop. The Historians head out to take a look.\n",
        "\n",
        "The shopkeeper turns to you. \"Any chance you can see why our computers are having issues again?\"\n",
        "\n",
        "The computer appears to be trying to run a program, but its memory (your puzzle input) is corrupted. All of the instructions have been jumbled up!\n",
        "\n",
        "It seems like the goal of the program is just to multiply some numbers. It does that with instructions like mul(X,Y), where X and Y are each 1-3 digit numbers. For instance, mul(44,46) multiplies 44 by 46 to get a result of 2024. Similarly, mul(123,4) would multiply 123 by 4.\n",
        "\n",
        "However, because the program's memory has been corrupted, there are also many invalid characters that should be ignored, even if they look like part of a mul instruction. Sequences like mul(4*, mul(6,9!, ?(12,34), or mul ( 2 , 4 ) do nothing.\n",
        "\n",
        "For example, consider the following section of corrupted memory:\n",
        "\n",
        "xmul(2,4)%&mul[3,7]!@^do_not_mul(5,5)+mul(32,64]then(mul(11,8)mul(8,5))\n",
        "Only the four highlighted sections are real mul instructions. Adding up the result of each instruction produces 161 (2*4 + 5*5 + 11*8 + 8*5).\n",
        "\n",
        "Scan the corrupted memory for uncorrupted mul instructions. What do you get if you add up all of the results of the multiplications?"
      ],
      "metadata": {
        "id": "SFEhYqAWgcN8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def check_if_valid(start_index):\n",
        "    current_index = start_index\n",
        "    num1 = ''\n",
        "    num2 = ''\n",
        "\n",
        "    #For edge cases like mul(,5)\n",
        "    if final_string[current_index].isnumeric():\n",
        "        num1 += final_string[current_index]\n",
        "    current_index += 1\n",
        "\n",
        "    while final_string[current_index] != ',':\n",
        "        current_char = final_string[current_index]\n",
        "        if current_char.isnumeric():\n",
        "            num1 += final_string[current_index]\n",
        "            current_index+= 1\n",
        "        else:\n",
        "            return False\n",
        "    #Go past , char\n",
        "    current_index += 1\n",
        "\n",
        "    #For edge cases like mul(5,)\n",
        "    if final_string[current_index].isnumeric():\n",
        "        num2 += final_string[current_index]\n",
        "    current_index += 1\n",
        "\n",
        "    while final_string[current_index] != ')':\n",
        "        current_char = final_string[current_index]\n",
        "        if current_char.isnumeric():\n",
        "            num2 += final_string[current_index]\n",
        "            current_index+= 1\n",
        "        else:\n",
        "            return False\n",
        "    return int(num1)*int(num2)\n",
        "\n",
        "data = open('data3.txt', 'r')\n",
        "final_string = \"\"\n",
        "for line in data:\n",
        "    final_string += line.strip()\n",
        "\n",
        "final_sum = 0\n",
        "for i in range(len(final_string)-8):\n",
        "    if final_string[i:i+4] == \"mul(\":\n",
        "        if check_if_valid(i+4): final_sum += check_if_valid(i+4)\n",
        "\n",
        "print(final_sum)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q2NIiqoJfFNw",
        "outputId": "895f060a-b803-471f-e23e-7fc4106830b7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "178794710\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "--- Part Two ---\n",
        "As you scan through the corrupted memory, you notice that some of the conditional statements are also still intact. If you handle some of the uncorrupted conditional statements in the program, you might be able to get an even more accurate result.\n",
        "\n",
        "There are two new instructions you'll need to handle:\n",
        "\n",
        "The do() instruction enables future mul instructions.\n",
        "The don't() instruction disables future mul instructions.\n",
        "Only the most recent do() or don't() instruction applies. At the beginning of the program, mul instructions are enabled.\n",
        "\n",
        "For example:\n",
        "\n",
        "xmul(2,4)&mul[3,7]!^don't()_mul(5,5)+mul(32,64](mul(11,8)undo()?mul(8,5))\n",
        "This corrupted memory is similar to the example from before, but this time the mul(5,5) and mul(11,8) instructions are disabled because there is a don't() instruction before them. The other mul instructions function normally, including the one at the end that gets re-enabled by a do() instruction.\n",
        "\n",
        "This time, the sum of the results is 48 (2*4 + 8*5).\n",
        "\n",
        "Handle the new instructions; what do you get if you add up all of the results of just the enabled multiplications?"
      ],
      "metadata": {
        "id": "OQix_R4ggsbE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "final_sum = 0\n",
        "mul_enabled = True\n",
        "for i in range(len(final_string)-8):\n",
        "    if final_string[i:i+4] == \"do()\":\n",
        "        mul_enabled = True\n",
        "    if final_string[i:i+7] == \"don't()\":\n",
        "        mul_enabled = False\n",
        "    if mul_enabled and final_string[i:i+4] == \"mul(\":\n",
        "        if check_if_valid(i+4): final_sum += check_if_valid(i+4)\n",
        "\n",
        "print(final_sum)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_onJdApbe_Ag",
        "outputId": "f1312670-8a62-4994-d334-d6f6e37193a7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "76729637\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "F5i_-GK8e_Ot"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 4**"
      ],
      "metadata": {
        "id": "SNJTuqf5e_g3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "--- Day 4: Ceres Search ---\n",
        "\"Looks like the Chief's not here. Next!\" One of The Historians pulls out a device and pushes the only button on it. After a brief flash, you recognize the interior of the Ceres monitoring station!\n",
        "\n",
        "As the search for the Chief continues, a small Elf who lives on the station tugs on your shirt; she'd like to know if you could help her with her word search (your puzzle input). She only has to find one word: XMAS.\n",
        "\n",
        "This word search allows words to be horizontal, vertical, diagonal, written backwards, or even overlapping other words. It's a little unusual, though, as you don't merely need to find one instance of XMAS - you need to find all of them. Here are a few ways XMAS might appear, where irrelevant characters have been replaced with .:\n",
        "\n",
        "\n",
        "..X...\n",
        ".SAMX.\n",
        ".A..A.\n",
        "XMAS.S\n",
        ".X....\n",
        "The actual word search will be full of letters instead. For example:\n",
        "\n",
        "MMMSXXMASM\n",
        "MSAMXMSMSA\n",
        "AMXSXMAAMM\n",
        "MSAMASMSMX\n",
        "XMASAMXAMM\n",
        "XXAMMXXAMA\n",
        "SMSMSASXSS\n",
        "SAXAMASAAA\n",
        "MAMMMXMMMM\n",
        "MXMXAXMASX\n",
        "In this word search, XMAS occurs a total of 18 times; here's the same word search again, but where letters not involved in any XMAS have been replaced with .:\n",
        "\n",
        "....XXMAS.\n",
        ".SAMXMS...\n",
        "...S..A...\n",
        "..A.A.MS.X\n",
        "XMASAMX.MM\n",
        "X.....XA.A\n",
        "S.S.S.S.SS\n",
        ".A.A.A.A.A\n",
        "..M.M.M.MM\n",
        ".X.X.XMASX\n",
        "Take a look at the little Elf's word search. How many times does XMAS appear?"
      ],
      "metadata": {
        "id": "Bc66ZeQchEaC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def check_if_mas(char2, char3, char4):\n",
        "    return char2==\"M\" and char3==\"A\" and char4==\"S\"\n",
        "\n",
        "data = open(\"data4.txt\", 'r')\n",
        "word_search_board = [[]]\n",
        "line_index = 0\n",
        "\n",
        "for line in data:\n",
        "    for char in line.strip():\n",
        "        word_search_board[line_index].append(char)\n",
        "    word_search_board.append([])\n",
        "    line_index += 1\n",
        "\n",
        "max_row = len(word_search_board) - 1\n",
        "max_col = len(word_search_board[0])\n",
        "xmas_count = 0\n",
        "for i in range(max_row):\n",
        "    for j in range(max_col):\n",
        "        if word_search_board[i][j] == 'X':\n",
        "            up_in_range, left_in_range, down_in_range, right_in_range = False, False, False, False\n",
        "            #if statements for every possible way to make xmas\n",
        "            if i - 3 >= 0:\n",
        "                up_in_range = True\n",
        "                if check_if_mas(word_search_board[i-1][j], word_search_board[i-2][j], word_search_board[i-3][j]):\n",
        "                    xmas_count += 1\n",
        "            if j - 3 >= 0:\n",
        "                left_in_range = True\n",
        "                if check_if_mas(word_search_board[i][j-1], word_search_board[i][j-2], word_search_board[i][j-3]):\n",
        "                    xmas_count += 1\n",
        "            if i + 4 <= max_row:\n",
        "                down_in_range = True\n",
        "                if check_if_mas(word_search_board[i+1][j], word_search_board[i+2][j], word_search_board[i+3][j]):\n",
        "                    xmas_count += 1\n",
        "            if j + 4 <= max_col:\n",
        "                right_in_range = True\n",
        "                if check_if_mas(word_search_board[i][j+1], word_search_board[i][j+2], word_search_board[i][j+3]):\n",
        "                    xmas_count += 1\n",
        "            if left_in_range and up_in_range:\n",
        "                if check_if_mas(word_search_board[i-1][j-1], word_search_board[i-2][j-2], word_search_board[i-3][j-3]):\n",
        "                    xmas_count += 1\n",
        "            if right_in_range and up_in_range:\n",
        "                if check_if_mas(word_search_board[i-1][j+1], word_search_board[i-2][j+2], word_search_board[i-3][j+3]):\n",
        "                    xmas_count += 1\n",
        "            if left_in_range and down_in_range:\n",
        "                if check_if_mas(word_search_board[i+1][j-1], word_search_board[i+2][j-2], word_search_board[i+3][j-3]):\n",
        "                    xmas_count += 1\n",
        "            if right_in_range and down_in_range:\n",
        "                if check_if_mas(word_search_board[i+1][j+1], word_search_board[i+2][j+2], word_search_board[i+3][j+3]):\n",
        "                    xmas_count += 1\n",
        "print(xmas_count)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TBSmiTSVhJuS",
        "outputId": "b626a6ce-555d-4d2a-d8da-ee0246f04685"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2414\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "--- Part Two ---\n",
        "The Elf looks quizzically at you. Did you misunderstand the assignment?\n",
        "\n",
        "Looking for the instructions, you flip over the word search to find that this isn't actually an XMAS puzzle; it's an X-MAS puzzle in which you're supposed to find two MAS in the shape of an X. One way to achieve that is like this:\n",
        "\n",
        "M.S\n",
        ".A.\n",
        "M.S\n",
        "Irrelevant characters have again been replaced with . in the above diagram. Within the X, each MAS can be written forwards or backwards.\n",
        "\n",
        "Here's the same example from before, but this time all of the X-MASes have been kept instead:\n",
        "\n",
        ".M.S......\n",
        "..A..MSMS.\n",
        ".M.S.MAA..\n",
        "..A.ASMSM.\n",
        ".M.S.M....\n",
        "..........\n",
        "S.S.S.S.S.\n",
        ".A.A.A.A..\n",
        "M.M.M.M.M.\n",
        "..........\n",
        "In this example, an X-MAS appears 9 times.\n",
        "\n",
        "Flip the word search from the instructions back over to the word search side and try again. How many times does an X-MAS appear?"
      ],
      "metadata": {
        "id": "rX3ewun0hHBT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "xmas_count = 0\n",
        "for i in range(max_row - 2):\n",
        "    for j in range(max_col - 2):\n",
        "        first_half_mas, second_half_mas = False, False\n",
        "        if check_if_mas(word_search_board[i][j], word_search_board[i+1][j+1], word_search_board[i+2][j+2]) or check_if_mas(word_search_board[i+2][j+2], word_search_board[i+1][j+1], word_search_board[i][j]):\n",
        "            first_half_mas = True\n",
        "        if check_if_mas(word_search_board[i][j+2], word_search_board[i+1][j+1], word_search_board[i+2][j]) or check_if_mas(word_search_board[i+2][j], word_search_board[i+1][j+1], word_search_board[i][j+2]):\n",
        "            second_half_mas = True\n",
        "        if first_half_mas and second_half_mas:\n",
        "            xmas_count += 1\n",
        "print(xmas_count)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f0KPLlj-hHTI",
        "outputId": "e732d567-9dd2-4dff-ee57-0f01596c6454"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1871\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 5**"
      ],
      "metadata": {
        "id": "9ljzXlfsjKvX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "--- Day 5: Print Queue ---\n",
        "Satisfied with their search on Ceres, the squadron of scholars suggests subsequently scanning the stationery stacks of sub-basement 17.\n",
        "\n",
        "The North Pole printing department is busier than ever this close to Christmas, and while The Historians continue their search of this historically significant facility, an Elf operating a very familiar printer beckons you over.\n",
        "\n",
        "The Elf must recognize you, because they waste no time explaining that the new sleigh launch safety manual updates won't print correctly. Failure to update the safety manuals would be dire indeed, so you offer your services.\n",
        "\n",
        "Safety protocols clearly indicate that new pages for the safety manuals must be printed in a very specific order. The notation X|Y means that if both page number X and page number Y are to be produced as part of an update, page number X must be printed at some point before page number Y.\n",
        "\n",
        "The Elf has for you both the page ordering rules and the pages to produce in each update (your puzzle input), but can't figure out whether each update has the pages in the right order.\n",
        "\n",
        "For example:\n",
        "\n",
        "47|53\n",
        "97|13\n",
        "97|61\n",
        "97|47\n",
        "75|29\n",
        "61|13\n",
        "75|53\n",
        "29|13\n",
        "97|29\n",
        "53|29\n",
        "61|53\n",
        "97|53\n",
        "61|29\n",
        "47|13\n",
        "75|47\n",
        "97|75\n",
        "47|61\n",
        "75|61\n",
        "47|29\n",
        "75|13\n",
        "53|13\n",
        "\n",
        "75,47,61,53,29\n",
        "97,61,53,29,13\n",
        "75,29,13\n",
        "75,97,47,61,53\n",
        "61,13,29\n",
        "97,13,75,29,47\n",
        "The first section specifies the page ordering rules, one per line. The first rule, 47|53, means that if an update includes both page number 47 and page number 53, then page number 47 must be printed at some point before page number 53. (47 doesn't necessarily need to be immediately before 53; other pages are allowed to be between them.)\n",
        "\n",
        "The second section specifies the page numbers of each update. Because most safety manuals are different, the pages needed in the updates are different too. The first update, 75,47,61,53,29, means that the update consists of page numbers 75, 47, 61, 53, and 29.\n",
        "\n",
        "To get the printers going as soon as possible, start by identifying which updates are already in the right order.\n",
        "\n",
        "In the above example, the first update (75,47,61,53,29) is in the right order:\n",
        "\n",
        "75 is correctly first because there are rules that put each other page after it: 75|47, 75|61, 75|53, and 75|29.\n",
        "47 is correctly second because 75 must be before it (75|47) and every other page must be after it according to 47|61, 47|53, and 47|29.\n",
        "61 is correctly in the middle because 75 and 47 are before it (75|61 and 47|61) and 53 and 29 are after it (61|53 and 61|29).\n",
        "53 is correctly fourth because it is before page number 29 (53|29).\n",
        "29 is the only page left and so is correctly last.\n",
        "Because the first update does not include some page numbers, the ordering rules involving those missing page numbers are ignored.\n",
        "\n",
        "The second and third updates are also in the correct order according to the rules. Like the first update, they also do not include every page number, and so only some of the ordering rules apply - within each update, the ordering rules that involve missing page numbers are not used.\n",
        "\n",
        "The fourth update, 75,97,47,61,53, is not in the correct order: it would print 75 before 97, which violates the rule 97|75.\n",
        "\n",
        "The fifth update, 61,13,29, is also not in the correct order, since it breaks the rule 29|13.\n",
        "\n",
        "The last update, 97,13,75,29,47, is not in the correct order due to breaking several rules.\n",
        "\n",
        "For some reason, the Elves also need to know the middle page number of each update being printed. Because you are currently only printing the correctly-ordered updates, you will need to find the middle page number of each correctly-ordered update. In the above example, the correctly-ordered updates are:\n",
        "\n",
        "75,47,61,53,29\n",
        "97,61,53,29,13\n",
        "75,29,13\n",
        "These have middle page numbers of 61, 53, and 29 respectively. Adding these page numbers together gives 143.\n",
        "\n",
        "Of course, you'll need to be careful: the actual list of page ordering rules is bigger and more complicated than the above example.\n",
        "\n",
        "Determine which updates are already in the correct order. What do you get if you add up the middle page number from those correctly-ordered updates?"
      ],
      "metadata": {
        "id": "-PGixfnFjN3_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import functools\n",
        "\n",
        "f = open(\"data5.txt\", \"r\")\n",
        "contents = f.read().split(\"\\n\\n\")\n",
        "\n",
        "pagelist = []\n",
        "for i in contents[0].split(\"\\n\"):\n",
        "    page = i.split(\"|\")\n",
        "    pagelist.append(page)\n",
        "\n",
        "requirements = {}\n",
        "for value,key in pagelist:\n",
        "    if key not in requirements.keys():\n",
        "        requirements[key] = [value]\n",
        "    elif value not in requirements.values():\n",
        "        requirements[key].append(value)\n",
        "\n",
        "allpage = [i.split(\",\") for i in contents[1].split(\"\\n\")]\n",
        "\n",
        "def paging(x,y):\n",
        "    if x==y:\n",
        "        return 0\n",
        "    if x in requirements:\n",
        "        if y in requirements[x]:\n",
        "            return 1\n",
        "    if y in requirements:\n",
        "        if x in requirements[y]:\n",
        "            return -1\n",
        "    return 0\n",
        "\n",
        "middle = 0\n",
        "wrong = []\n",
        "for i in allpage:\n",
        "    #part1\n",
        "    if i == sorted(i, key = functools.cmp_to_key(paging)):\n",
        "        middle += int(i[len(i)//2])\n",
        "    else:\n",
        "        #part2\n",
        "        wrong.append(i)\n",
        "print(middle)\n"
      ],
      "metadata": {
        "id": "587F1PqfjNE2",
        "outputId": "5701ead6-c04c-4ee8-ca26-49fc54f427e3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5208\n",
            "6732\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "--- Part Two ---\n",
        "While the Elves get to work printing the correctly-ordered updates, you have a little time to fix the rest of them.\n",
        "\n",
        "For each of the incorrectly-ordered updates, use the page ordering rules to put the page numbers in the right order. For the above example, here are the three incorrectly-ordered updates and their correct orderings:\n",
        "\n",
        "75,97,47,61,53 becomes 97,75,47,61,53.\n",
        "61,13,29 becomes 61,29,13.\n",
        "97,13,75,29,47 becomes 97,75,47,29,13.\n",
        "After taking only the incorrectly-ordered updates and ordering them correctly, their middle page numbers are 47, 29, and 47. Adding these together produces 123.\n",
        "\n",
        "Find the updates which are not in the correct order. What do you get if you add up the middle page numbers after correctly ordering just those updates?"
      ],
      "metadata": {
        "id": "Pk6mAxQ6mbZ3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "mwrong = 0\n",
        "for i in wrong:\n",
        "    sortedi = sorted(i, key = functools.cmp_to_key(paging))\n",
        "    mwrong += int(sortedi[len(sortedi)//2])\n",
        "\n",
        "print(mwrong)"
      ],
      "metadata": {
        "id": "NMWrnNY-jNcT",
        "outputId": "2c2a6edb-ff6f-4e09-c155-fd20cb860a8d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6732\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 6**"
      ],
      "metadata": {
        "id": "avAfy0AFmjRp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "--- Day 6: Guard Gallivant ---\n",
        "The Historians use their fancy device again, this time to whisk you all away to the North Pole prototype suit manufacturing lab... in the year 1518! It turns out that having direct access to history is very convenient for a group of historians.\n",
        "\n",
        "You still have to be careful of time paradoxes, and so it will be important to avoid anyone from 1518 while The Historians search for the Chief. Unfortunately, a single guard is patrolling this part of the lab.\n",
        "\n",
        "Maybe you can work out where the guard will go ahead of time so that The Historians can search safely?\n",
        "\n",
        "You start by making a map (your puzzle input) of the situation. For example:\n",
        "\n",
        "....#.....\n",
        ".........#\n",
        "..........\n",
        "..#.......\n",
        ".......#..\n",
        "..........\n",
        ".#..^.....\n",
        "........#.\n",
        "#.........\n",
        "......#...\n",
        "The map shows the current position of the guard with ^ (to indicate the guard is currently facing up from the perspective of the map). Any obstructions - crates, desks, alchemical reactors, etc. - are shown as #.\n",
        "\n",
        "Lab guards in 1518 follow a very strict patrol protocol which involves repeatedly following these steps:\n",
        "\n",
        "If there is something directly in front of you, turn right 90 degrees.\n",
        "Otherwise, take a step forward.\n",
        "Following the above protocol, the guard moves up several times until she reaches an obstacle (in this case, a pile of failed suit prototypes):\n",
        "\n",
        "....#.....\n",
        "....^....#\n",
        "..........\n",
        "..#.......\n",
        ".......#..\n",
        "..........\n",
        ".#........\n",
        "........#.\n",
        "#.........\n",
        "......#...\n",
        "Because there is now an obstacle in front of the guard, she turns right before continuing straight in her new facing direction:\n",
        "\n",
        "....#.....\n",
        "........>#\n",
        "..........\n",
        "..#.......\n",
        ".......#..\n",
        "..........\n",
        ".#........\n",
        "........#.\n",
        "#.........\n",
        "......#...\n",
        "Reaching another obstacle (a spool of several very long polymers), she turns right again and continues downward:\n",
        "\n",
        "....#.....\n",
        ".........#\n",
        "..........\n",
        "..#.......\n",
        ".......#..\n",
        "..........\n",
        ".#......v.\n",
        "........#.\n",
        "#.........\n",
        "......#...\n",
        "This process continues for a while, but the guard eventually leaves the mapped area (after walking past a tank of universal solvent):\n",
        "\n",
        "....#.....\n",
        ".........#\n",
        "..........\n",
        "..#.......\n",
        ".......#..\n",
        "..........\n",
        ".#........\n",
        "........#.\n",
        "#.........\n",
        "......#v..\n",
        "By predicting the guard's route, you can determine which specific positions in the lab will be in the patrol path. Including the guard's starting position, the positions visited by the guard before leaving the area are marked with an X:\n",
        "\n",
        "....#.....\n",
        "....XXXXX#\n",
        "....X...X.\n",
        "..#.X...X.\n",
        "..XXXXX#X.\n",
        "..X.X.X.X.\n",
        ".#XXXXXXX.\n",
        ".XXXXXXX#.\n",
        "#XXXXXXX..\n",
        "......#X..\n",
        "In this example, the guard will visit 41 distinct positions on your map.\n",
        "\n",
        "Predict the path of the guard. How many distinct positions will the guard visit before leaving the mapped area?"
      ],
      "metadata": {
        "id": "_q2j-CTnmner"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load and process the grid from the file\n",
        "with open(\"data6.txt\", \"r\") as file:\n",
        "    contents = file.read()\n",
        "\n",
        "# Remove newlines and create the board\n",
        "row_length = 130\n",
        "contents = contents.replace('\\n', '')\n",
        "rows = [contents[i:i+row_length] for i in range(0, len(contents), row_length)]\n",
        "board = [list(row.ljust(row_length, '#')) for row in rows]\n",
        "\n",
        "# Find starting position dynamically\n",
        "for i, row in enumerate(board):\n",
        "    if \"^\" in row:\n",
        "        posX, posY = i, row.index(\"^\")\n",
        "        break\n",
        "\n",
        "# Initialize state\n",
        "player = \"^\"  # Start facing up\n",
        "deadEnd = False\n",
        "size = len(board)  # Size of the grid\n",
        "\n",
        "# Movement directions and rotation logic\n",
        "move_directions = {\n",
        "    \"^\": (-1, 0),\n",
        "    \">\": (0, 1),\n",
        "    \"v\": (1, 0),\n",
        "    \"<\": (0, -1)\n",
        "}\n",
        "\n",
        "def checkNext(player, posX, posY):\n",
        "    \"\"\"Rotate the player if facing a wall.\"\"\"\n",
        "    directions = {\n",
        "        \"^\": (-1, 0, \">\"),\n",
        "        \">\": (0, 1, \"v\"),\n",
        "        \"v\": (1, 0, \"<\"),\n",
        "        \"<\": (0, -1, \"^\")\n",
        "    }\n",
        "    dx, dy, new_player = directions[player]\n",
        "    if 0 <= posX + dx < size and 0 <= posY + dy < len(board[0]) and board[posX + dx][posY + dy] == \"#\":\n",
        "        return new_player\n",
        "    return \"^\"\n",
        "\n",
        "def is_valid_move(x, y):\n",
        "    \"\"\"Check if the move is within bounds and not a wall.\"\"\"\n",
        "    return 0 <= x < size and 0 <= y < len(board[0]) and board[x][y] != \"#\"\n",
        "\n",
        "# Core algorithm to count moves\n",
        "count = 0\n",
        "while not deadEnd:\n",
        "    count += 1\n",
        "\n",
        "    dx, dy = move_directions[player]\n",
        "    nextX, nextY = posX + dx, posY + dy\n",
        "\n",
        "    # Check if the next move is valid\n",
        "    if 0 <= nextX < size and 0 <= nextY < len(board[0]) and board[nextX][nextY] != \"#\":\n",
        "        posX, posY = nextX, nextY\n",
        "    else:\n",
        "        player = checkNext(player, posX, posY)\n",
        "\n",
        "    # Check for dead end by testing all four directions\n",
        "    deadEnd = not any(\n",
        "        is_valid_move(posX + dx, posY + dy)\n",
        "        for dx, dy in move_directions.values()\n",
        "    )\n",
        "\n",
        "# Final result\n",
        "print(\"Total moves:\", count)\n"
      ],
      "metadata": {
        "id": "Renu3RtOmk6P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 7**"
      ],
      "metadata": {
        "id": "6rEtug-8TPSd"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 8**"
      ],
      "metadata": {
        "id": "d7De2jN1TjUs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "--- Day 8: Resonant Collinearity ---\n",
        "You find yourselves on the roof of a top-secret Easter Bunny installation.\n",
        "\n",
        "While The Historians do their thing, you take a look at the familiar huge antenna. Much to your surprise, it seems to have been reconfigured to emit a signal that makes people 0.1% more likely to buy Easter Bunny brand Imitation Mediocre Chocolate as a Christmas gift! Unthinkable!\n",
        "\n",
        "Scanning across the city, you find that there are actually many such antennas. Each antenna is tuned to a specific frequency indicated by a single lowercase letter, uppercase letter, or digit. You create a map (your puzzle input) of these antennas. For example:\n",
        "\n",
        "............\n",
        "........0...\n",
        ".....0......\n",
        ".......0....\n",
        "....0.......\n",
        "......A.....\n",
        "............\n",
        "............\n",
        "........A...\n",
        ".........A..\n",
        "............\n",
        "............\n",
        "The signal only applies its nefarious effect at specific antinodes based on the resonant frequencies of the antennas. In particular, an antinode occurs at any point that is perfectly in line with two antennas of the same frequency - but only when one of the antennas is twice as far away as the other. This means that for any pair of antennas with the same frequency, there are two antinodes, one on either side of them.\n",
        "\n",
        "So, for these two antennas with frequency a, they create the two antinodes marked with #:\n",
        "\n",
        "..........\n",
        "...#......\n",
        "..........\n",
        "....a.....\n",
        "..........\n",
        ".....a....\n",
        "..........\n",
        "......#...\n",
        "..........\n",
        "..........\n",
        "Adding a third antenna with the same frequency creates several more antinodes. It would ideally add four antinodes, but two are off the right side of the map, so instead it adds only two:\n",
        "\n",
        "..........\n",
        "...#......\n",
        "#.........\n",
        "....a.....\n",
        "........a.\n",
        ".....a....\n",
        "..#.......\n",
        "......#...\n",
        "..........\n",
        "..........\n",
        "Antennas with different frequencies don't create antinodes; A and a count as different frequencies. However, antinodes can occur at locations that contain antennas. In this diagram, the lone antenna with frequency capital A creates no antinodes but has a lowercase-a-frequency antinode at its location:\n",
        "\n",
        "..........\n",
        "...#......\n",
        "#.........\n",
        "....a.....\n",
        "........a.\n",
        ".....a....\n",
        "..#.......\n",
        "......A...\n",
        "..........\n",
        "..........\n",
        "The first example has antennas with two different frequencies, so the antinodes they create look like this, plus an antinode overlapping the topmost A-frequency antenna:\n",
        "\n",
        "......#....#\n",
        "...#....0...\n",
        "....#0....#.\n",
        "..#....0....\n",
        "....0....#..\n",
        ".#....A.....\n",
        "...#........\n",
        "#......#....\n",
        "........A...\n",
        ".........A..\n",
        "..........#.\n",
        "..........#.\n",
        "Because the topmost A-frequency antenna overlaps with a 0-frequency antinode, there are 14 total unique locations that contain an antinode within the bounds of the map.\n",
        "\n",
        "Calculate the impact of the signal. How many unique locations within the bounds of the map contain an antinode?"
      ],
      "metadata": {
        "id": "Vzu_A5IZTnl-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "file = open(\"data8.txt\", 'r')\n",
        "freq = {}\n",
        "y = 0\n",
        "for i in file:\n",
        "    line = list(i.strip())\n",
        "    for x in range(len(line)):\n",
        "        if(line[x] != \".\"):\n",
        "            if line[x] in freq:\n",
        "                freq[line[x]].append([y, x])\n",
        "            else:\n",
        "                freq[line[x]] = [[y, x]]\n",
        "    y += 1\n",
        "\n",
        "ans1, ans2 = 0, 0\n",
        "nodeLoc = []\n",
        "for key, value in freq.items():\n",
        "    freqIns = len(value)\n",
        "    for i in range(freqIns):\n",
        "        for j in range(i+1, freqIns):\n",
        "            distY = value[i][0] - value[j][0]\n",
        "            distX = value[i][1] - value[j][1]\n",
        "            if(value[i][0]+distY>=0 and value[i][1]+distX>=0 and value[i][1]+distX<50):\n",
        "                if([value[i][0]+distY, value[i][1]+distX] not in nodeLoc):\n",
        "                    nodeLoc.append([value[i][0]+distY, value[i][1]+distX])\n",
        "                    ans1 += 1\n",
        "            if(value[j][0]-distY<y and value[j][1]-distX>=0 and value[j][1]-distX<50):\n",
        "                if([value[j][0]-distY, value[j][1]-distX] not in nodeLoc):\n",
        "                    nodeLoc.append([value[j][0]-distY, value[j][1]-distX])\n",
        "                    ans1 += 1\n",
        "\n",
        "\n",
        "nodeLoc = []\n",
        "for key, value in freq.items():\n",
        "    freqIns = len(value)\n",
        "    for i in range(freqIns):\n",
        "        for j in range(i+1, freqIns):\n",
        "            distY = value[i][0] - value[j][0]\n",
        "            distX = value[i][1] - value[j][1]\n",
        "            mul = 0\n",
        "            #same thing as part1 just that now it is more strict with the x coor, and there is a multiplier for dists\n",
        "            if(distX >= 0):\n",
        "                while(value[i][0]+distY*mul>=0 and value[i][1]+distX*mul<50):\n",
        "                    if([value[i][0]+distY*mul, value[i][1]+distX*mul] not in nodeLoc):\n",
        "                        nodeLoc.append([value[i][0]+distY*mul, value[i][1]+distX*mul])\n",
        "                        ans2 += 1\n",
        "                    mul+=1\n",
        "                mul = 0\n",
        "                while(value[j][0]-distY*mul<y and value[j][1]-distX*mul>=0):\n",
        "                    if([value[j][0]-distY*mul, value[j][1]-distX*mul] not in nodeLoc):\n",
        "                        nodeLoc.append([value[j][0]-distY*mul, value[j][1]-distX*mul])\n",
        "                        ans2 += 1\n",
        "                    mul+=1\n",
        "            else:\n",
        "                while(value[i][0]+distY*mul>=0 and value[i][1]+distX*mul>=0):\n",
        "                    if([value[i][0]+distY*mul, value[i][1]+distX*mul] not in nodeLoc):\n",
        "                        nodeLoc.append([value[i][0]+distY*mul, value[i][1]+distX*mul])\n",
        "                        ans2 += 1\n",
        "                    mul+=1\n",
        "                mul = 0\n",
        "                while(value[j][0]-distY*mul<y and value[j][1]-distX*mul<50):\n",
        "                    if([value[j][0]-distY*mul, value[j][1]-distX*mul] not in nodeLoc):\n",
        "                        nodeLoc.append([value[j][0]-distY*mul, value[j][1]-distX*mul])\n",
        "                        ans2 += 1\n",
        "                    mul+=1\n",
        "print(\"1:\", ans1, \"\\n2:\", ans2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bS5CDh6eTpof",
        "outputId": "c5a53033-9f8b-48b3-f950-fc6bcd9f4112"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1: 259 \n",
            "2: 927\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "--- Part Two ---\n",
        "Watching over your shoulder as you work, one of The Historians asks if you took the effects of resonant harmonics into your calculations.\n",
        "\n",
        "Whoops!\n",
        "\n",
        "After updating your model, it turns out that an antinode occurs at any grid position exactly in line with at least two antennas of the same frequency, regardless of distance. This means that some of the new antinodes will occur at the position of each antenna (unless that antenna is the only one of its frequency).\n",
        "\n",
        "So, these three T-frequency antennas now create many antinodes:\n",
        "\n",
        "T....#....\n",
        "...T......\n",
        ".T....#...\n",
        ".........#\n",
        "..#.......\n",
        "..........\n",
        "...#......\n",
        "..........\n",
        "....#.....\n",
        "..........\n",
        "In fact, the three T-frequency antennas are all exactly in line with two antennas, so they are all also antinodes! This brings the total number of antinodes in the above example to 9.\n",
        "\n",
        "The original example now has 34 antinodes, including the antinodes that appear on every antenna:\n",
        "\n",
        "##....#....#\n",
        ".#.#....0...\n",
        "..#.#0....#.\n",
        "..##...0....\n",
        "....0....#..\n",
        ".#...#A....#\n",
        "...#..#.....\n",
        "#....#.#....\n",
        "..#.....A...\n",
        "....#....A..\n",
        ".#........#.\n",
        "...#......##\n",
        "Calculate the impact of the signal using this updated model. How many unique locations within the bounds of the map contain an antinode?"
      ],
      "metadata": {
        "id": "3LYm3vC9Ut4Y"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 9**"
      ],
      "metadata": {
        "id": "UiAGqA1CU2fG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "--- Day 9: Disk Fragmenter ---\n",
        "Another push of the button leaves you in the familiar hallways of some friendly amphipods! Good thing you each somehow got your own personal mini submarine. The Historians jet away in search of the Chief, mostly by driving directly into walls.\n",
        "\n",
        "While The Historians quickly figure out how to pilot these things, you notice an amphipod in the corner struggling with his computer. He's trying to make more contiguous free space by compacting all of the files, but his program isn't working; you offer to help.\n",
        "\n",
        "He shows you the disk map (your puzzle input) he's already generated. For example:\n",
        "\n",
        "2333133121414131402\n",
        "The disk map uses a dense format to represent the layout of files and free space on the disk. The digits alternate between indicating the length of a file and the length of free space.\n",
        "\n",
        "So, a disk map like 12345 would represent a one-block file, two blocks of free space, a three-block file, four blocks of free space, and then a five-block file. A disk map like 90909 would represent three nine-block files in a row (with no free space between them).\n",
        "\n",
        "Each file on disk also has an ID number based on the order of the files as they appear before they are rearranged, starting with ID 0. So, the disk map 12345 has three files: a one-block file with ID 0, a three-block file with ID 1, and a five-block file with ID 2. Using one character for each block where digits are the file ID and . is free space, the disk map 12345 represents these individual blocks:\n",
        "\n",
        "0..111....22222\n",
        "The first example above, 2333133121414131402, represents these individual blocks:\n",
        "\n",
        "00...111...2...333.44.5555.6666.777.888899\n",
        "The amphipod would like to move file blocks one at a time from the end of the disk to the leftmost free space block (until there are no gaps remaining between file blocks). For the disk map 12345, the process looks like this:\n",
        "\n",
        "0..111....22222\n",
        "02.111....2222.\n",
        "022111....222..\n",
        "0221112...22...\n",
        "02211122..2....\n",
        "022111222......\n",
        "The first example requires a few more steps:\n",
        "\n",
        "00...111...2...333.44.5555.6666.777.888899\n",
        "009..111...2...333.44.5555.6666.777.88889.\n",
        "0099.111...2...333.44.5555.6666.777.8888..\n",
        "00998111...2...333.44.5555.6666.777.888...\n",
        "009981118..2...333.44.5555.6666.777.88....\n",
        "0099811188.2...333.44.5555.6666.777.8.....\n",
        "009981118882...333.44.5555.6666.777.......\n",
        "0099811188827..333.44.5555.6666.77........\n",
        "00998111888277.333.44.5555.6666.7.........\n",
        "009981118882777333.44.5555.6666...........\n",
        "009981118882777333644.5555.666............\n",
        "00998111888277733364465555.66.............\n",
        "0099811188827773336446555566..............\n",
        "The final step of this file-compacting process is to update the filesystem checksum. To calculate the checksum, add up the result of multiplying each of these blocks' position with the file ID number it contains. The leftmost block is in position 0. If a block contains free space, skip it instead.\n",
        "\n",
        "Continuing the first example, the first few blocks' position multiplied by its file ID number are 0 * 0 = 0, 1 * 0 = 0, 2 * 9 = 18, 3 * 9 = 27, 4 * 8 = 32, and so on. In this example, the checksum is the sum of these, 1928.\n",
        "\n",
        "Compact the amphipod's hard drive using the process he requested. What is the resulting filesystem checksum? (Be careful copy/pasting the input for this puzzle; it is a single, very long line.)"
      ],
      "metadata": {
        "id": "7Wl9B-11U8Ai"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "file = open(\"data9.txt\", 'r')\n",
        "for line in file:\n",
        "    diskMap = line\n",
        "    disk = \"\"\n",
        "    free = False\n",
        "    cnt, ans = 0, 0\n",
        "    for c in diskMap: #constructing the disk\n",
        "        if(free == False):\n",
        "            disk += chr(cnt) * int(c)\n",
        "            free = True\n",
        "            cnt += 1\n",
        "        elif(free == True):\n",
        "            disk += 'f' * int(c) #'f' used to replace '.'\n",
        "            free = False\n",
        "\n",
        "    while(disk[-1] == 'f'): #removing f from the right, till it reaches smth else\n",
        "        disk = disk[0: -1]\n",
        "    while('f' in disk):\n",
        "        freeIdx = disk.index('f')\n",
        "        disk = disk[0: freeIdx] + disk[-1] + disk[freeIdx+1: -1] #overriding with new str\n",
        "        while(disk[-1] == 'f'): #removing f from the right, till it reaches smth else\n",
        "            disk = disk[0: -1]\n",
        "\n",
        "    for i in range(len(disk)): #finding sum\n",
        "        ans += i * ord(disk[i])\n",
        "print(ans) #part 1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UYw_T3tpUFjs",
        "outputId": "95c3b7c9-e4a1-430c-f2e8-e16ab3dca793"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6211348208140\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "--- Part Two ---\n",
        "Upon completion, two things immediately become clear. First, the disk definitely has a lot more contiguous free space, just like the amphipod hoped. Second, the computer is running much more slowly! Maybe introducing all of that file system fragmentation was a bad idea?\n",
        "\n",
        "The eager amphipod already has a new plan: rather than move individual blocks, he'd like to try compacting the files on his disk by moving whole files instead.\n",
        "\n",
        "This time, attempt to move whole files to the leftmost span of free space blocks that could fit the file. Attempt to move each file exactly once in order of decreasing file ID number starting with the file with the highest file ID number. If there is no span of free space to the left of a file that is large enough to fit the file, the file does not move.\n",
        "\n",
        "The first example from above now proceeds differently:\n",
        "\n",
        "00...111...2...333.44.5555.6666.777.888899\n",
        "0099.111...2...333.44.5555.6666.777.8888..\n",
        "0099.1117772...333.44.5555.6666.....8888..\n",
        "0099.111777244.333....5555.6666.....8888..\n",
        "00992111777.44.333....5555.6666.....8888..\n",
        "The process of updating the filesystem checksum is the same; now, this example's checksum would be 2858.\n",
        "\n",
        "Start over, now compacting the amphipod's hard drive using this new method instead. What is the resulting filesystem checksum?"
      ],
      "metadata": {
        "id": "p1Rlr7UeU_b_"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "GvYLuDQUVAQ8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 10**"
      ],
      "metadata": {
        "id": "IyUinSBPU9K-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "ZCIif9pGVBHd"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "_WMP4pJUVBiU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "VRxzMqyWVB6-"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Eys1y5gFVCVF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 11**"
      ],
      "metadata": {
        "id": "kChtB8FOVDXr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "Qyw3R5KVVDOx"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "-puKS4WKVEa7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "cdM4P-JNVE0U"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "2sl7zy3uVFP4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "m6_dgdjnVFzd"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Hi8mTwRbVGOV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 12**"
      ],
      "metadata": {
        "id": "fbYeqCR7VG1i"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "iaHywkFrVHmX"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "6Gm59z_mVII4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "apNI6YThVId5"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "xo1H3UrQVJMZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 13**"
      ],
      "metadata": {
        "id": "LL7tPxsuVJyb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "34dwTeURVcKC"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Hx5HO0i5Vcni"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "3PXlUlChVc9a"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "DfRtoj2bVdZy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 14**"
      ],
      "metadata": {
        "id": "oYnBSj4qVd0n"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "YwAA3Pj-Vib_"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "UXFd-idIVi6X"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "60qDYtGJVjZp"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "J3Ii30GtVjz2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 15**"
      ],
      "metadata": {
        "id": "v5Drt33ZVkRY"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "Tky1eQ15Vm1C"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "6xc3WB9GVnTa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "VEiSLccwVnqj"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "6X4OreRbVoUR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 16**"
      ],
      "metadata": {
        "id": "EIEIZonkVqqt"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "F2VD-Iz1Vsvw"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "gbv0k6YZVtIE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "TqCHdiVmVtfS"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "JgisDoLiVuAE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 17**"
      ],
      "metadata": {
        "id": "_qpWCESbVudd"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "b7EAluYHVwdB"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ELQ681uxVw1r"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "Vmfph3NkVxP0"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "wZJgz6MiVxqL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 18**"
      ],
      "metadata": {
        "id": "qcDX3TbhVx_b"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "-8U-4fveV1r1"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "eNxXvJhaV2C6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "14ajqYlDV2aZ"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Pd8f6c7MV20I"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 19**"
      ],
      "metadata": {
        "id": "PfI6HzQRV3ea"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "k7IrXIFJV5XS"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "IMO3MpPRV5uF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "GXsnNc0-V6G9"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "q4oZ0fFUV6ru"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 20**"
      ],
      "metadata": {
        "id": "3vx75Wv3V7Me"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "f7oODjxjV8Xu"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "V9jFsY_pWFgt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "TO_bg25UWF3X"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "swk8KVdNWGP1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 21**"
      ],
      "metadata": {
        "id": "R6cq88DBWGkD"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "5E6BQbNBWIfu"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "xq9RPkuzWI4V"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "0sefRTlCWJec"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "f9VoaafXWJ4f"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 22**"
      ],
      "metadata": {
        "id": "_Rt4w5LAWKf4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "B1o-UcwvWM2x"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "-N48rp5mWNRX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "5oO9cCGiWNqs"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "7WGtkqJwWOJr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 23**"
      ],
      "metadata": {
        "id": "aTIgzX9YWOz6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "MTloo6WXWQ9_"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ro6SanRnWRXT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "-TqMMBwzWR1A"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "XBq9kAV1WSYJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 24**"
      ],
      "metadata": {
        "id": "ZDDqX903WTJi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "xYgwkV3CWVdf"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "iYthUOjtWV4M"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "LVBoXA_FWWQN"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Is22ZeXxWWq-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **DAY 25**"
      ],
      "metadata": {
        "id": "W6veTna6WXoo"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "4DmXsV7iWZhH"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Wib18XzjWZ3p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "eTjCe3cAWaNk"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "77OYoXgFWam0"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}