adventofcode2020julia-notebook.ipynb

{
 "metadata": {
  "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.8.5-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "julia-1.5",
   "display_name": "Julia 1.5.2",
   "language": "julia"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# Day 1:\n",
    "## --- Report Repair ---"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Part 1:\n",
      "1632\t388\t633216\n",
      "388\t1632\t633216\n",
      "Part2:\n",
      "1607\t196\t217\t68348924\n",
      "1607\t217\t196\t68348924\n",
      "196\t1607\t217\t68348924\n",
      "196\t217\t1607\t68348924\n",
      "217\t1607\t196\t68348924\n",
      "217\t196\t1607\t68348924\n"
     ]
    }
   ],
   "source": [
    "using DelimitedFiles\n",
    "f = open(\"d01p1-input.txt\")\n",
    "data = readdlm(f, '\\t', Int, '\\n')\n",
    "close(f)\n",
    "println(\"Part 1:\")\n",
    "for x in data\n",
    "\tfor y in data\n",
    "\t\tif (x + y) == 2020\n",
    "            println(x, \"\\t\", y, \"\\t\",(x*y))\n",
    "        end\n",
    "    end\n",
    "end\n",
    "println(\"Part2:\")\n",
    "for x in data\n",
    "\tfor y in data\n",
    "        for z in data\n",
    "        \tif (x + y + z) == 2020\n",
    "                println(x, \"\\t\", y, \"\\t\", z,\"\\t\",(x*y*z))\n",
    "            end\n",
    "        end\n",
    "    end\n",
    "end\n"
   ]
  },
  {
   "source": [
    "# Day 2:\n",
    "## --- Password Philosophy ---\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Part 1: Valid passwords: 422\n",
      "Part 2: Valid passwords: 451\n"
     ]
    }
   ],
   "source": [
    "using DelimitedFiles\n",
    "\n",
    "f = open(\"d02-input.txt\")\n",
    "data = readdlm(f, '\\t', String, '\\n')\n",
    "close(f)\n",
    "\n",
    "# data = [x.strip().split() for x in data]\n",
    "valid = 0\n",
    "for row in 1:length(data)\n",
    "\t# min value = split(split(data[row])[1],\"-\")[1]\n",
    "\t# max value = split(split(data[row])[1],\"-\")[2]\n",
    "\t# character = split(split(data[row])[2],\":\")[1]\n",
    "\t# password to test = split(data[row])[3]\n",
    "\t# number occurances of letter = length(collect(eachmatch(Regex(split(split(data[row])[2],\":\")[1]), split(data[row])[3])))\n",
    "\tmaximum = parse(Int, split(split(data[row])[1],\"-\")[2])\n",
    "\tminimum = parse(Int, split(split(data[row])[1],\"-\")[1])\n",
    "    char_count = length(collect(eachmatch(Regex(split(split(data[row])[2],\":\")[1]), split(data[row])[3])))\n",
    "\tglobal valid += (char_count >= minimum) * (char_count <= maximum)\n",
    "end\n",
    "println(\"Part 1: Valid passwords: \", valid)\n",
    "\n",
    "valid = 0\n",
    "for row in 1:length(data)\n",
    "\t# char_pos_1 = split(split(data[row])[1],\"-\")[1]\n",
    "\t# char_pos_2 = split(split(data[row])[1],\"-\")[2]\n",
    "\t# character = split(split(data[row])[2],\":\")[1]\n",
    "\t# password to test = split(data[row])[3]\n",
    "\t# number occurances of letter = length(collect(eachmatch(Regex(split(split(data[row])[2],\":\")[1]), split(data[row])[3])))\n",
    "    test_char = split(split(data[row])[2],\":\")[1][1]\n",
    "    password = split(data[row])[3]\n",
    "\tchar_pos_2 = parse(Int, split(split(data[row])[1],\"-\")[2])\n",
    "    char_pos_1 = parse(Int, split(split(data[row])[1],\"-\")[1])\n",
    "    if (password[char_pos_1] == test_char && password[char_pos_2] != test_char) || (password[char_pos_1] != test_char && password[char_pos_2] == test_char)\n",
    "        global valid = valid + 1\n",
    "    end\n",
    "end\n",
    "println(\"Part 2: Valid passwords: \", valid)\n"
   ]
  },
  {
   "source": [
    "# Day 3:\n",
    "## --- Toboggan Trajectory ---"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Part 1: Trees encountered= 209\n",
      "Part 2: Trees product= 1574890240\n"
     ]
    }
   ],
   "source": [
    "using DelimitedFiles\n",
    "# Read data file\n",
    "f = open(\"d03-input.txt\")\n",
    "data = readdlm(f, '\\t', String, '\\n')\n",
    "close(f)\n",
    "#Part 1\n",
    "global trees = 0\n",
    "global col = 1\n",
    "global line_length = length(data[1])\n",
    "for row in 1:length(data)\n",
    "    if data[row][col] == '#'\n",
    "        global trees += 1\n",
    "    end\n",
    "    global col = (col + 2) % (line_length)+1 # julia doesnt allow zero index - this calulates across 2 mod line_length then adds one to make total across 3\n",
    "end\n",
    "println(\"Part 1: Trees encountered= $trees\")\n",
    "# Part 2\n",
    "trees =0 \n",
    "col = 1\n",
    "routes = [(1,1),(3,1),(5,1),(7,1),(1,2)]\n",
    "answer = 0\n",
    "for route in 1:length(routes)\n",
    "    # reset variables fro the route\n",
    "    global col = 1\n",
    "    global trees = 0\n",
    "    for row in 1:routes[route][2]:length(data)\n",
    "        if data[row][col] == '#'\n",
    "            global trees = trees + 1\n",
    "        end\n",
    "        global col = (col + routes[route][1]-1) % (line_length)+1\n",
    "    end\n",
    "    if answer != 0\n",
    "        global answer = answer * trees\n",
    "    else\n",
    "        global answer = trees\n",
    "    end\n",
    "end\n",
    "println(\"Part 2: Trees product= $answer\")\n"
   ]
  },
  {
   "source": [
    "# Day 4: \n",
    "## --- Passport Processing ---"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Part 1: Valid passports = 250\nPart 2: Valid passports = 161\n"
     ]
    }
   ],
   "source": [
    "f = open(\"d04-input.txt\", \"r\")\n",
    "data = read(f, String)\n",
    "close(f)\n",
    "# clean data\n",
    "# need to strip the double '\\n\\n' indicates new passport data - strip from the dataset\n",
    "data = split(data, \"\\n\\n\")\n",
    "# replace remaining eol (\\n) chars in string with spaces\n",
    "for i in 1:length(data)\n",
    "    global data[i] = replace(data[i], \"\\n\" => \" \")\n",
    "end\n",
    "\n",
    "validpart1 = 0\n",
    "validpart2 = 0\n",
    "for (index, passport) in enumerate(data)\n",
    "    # the following test check for valid passports in part 1, and is first test for part 2\n",
    "    if occursin(\"byr\", passport) & occursin(\"iyr\", passport) & occursin(\"eyr\", passport) & occursin(\"hgt\", passport) & occursin(\"hcl\", passport) & occursin(\"ecl\", passport) & occursin(\"pid\", passport)\n",
    "        global validpart1 = validpart1 + 1\n",
    "\n",
    "        # start of checks for part 2\n",
    "        # determine birth year byr\n",
    "        byr = parse(Int, split(split(split(passport, \"byr\")[2], \":\")[2], \" \")[1])\n",
    "        # determine issue year iyr\n",
    "        iyr = parse(Int, split(split(split(passport, \"iyr\")[2], \":\")[2], \" \")[1])\n",
    "        # determine expiration year eyr \n",
    "        eyr = parse(Int, split(split(split(passport, \"eyr\")[2], \":\")[2], \" \")[1])\n",
    "        # determine height hgt & units\n",
    "        hgt_length = length(split(split(split(passport, \"hgt\")[2], \":\")[2], \" \")[1])\n",
    "        # check units included\n",
    "        hgt_unit = split(split(split(passport, \"hgt\")[2], \":\")[2], \" \")[1][hgt_length-1:hgt_length]\n",
    "        if !occursin(r\"cm|in\", hgt_unit) continue end\n",
    "        hgt = parse(Int, split(split(split(passport, \"hgt\")[2], \":\")[2], \" \")[1][1:hgt_length-2])\n",
    "        # determine hair colour hcl\n",
    "        hcl = split(split(split(passport, \"hcl\")[2], \":\")[2], \" \")[1]\n",
    "        # determine eye colour ecl\n",
    "        ecl = split(split(split(passport, \"ecl\")[2], \":\")[2], \" \")[1]\n",
    "        # determine passport id pid\n",
    "        pid = split(split(split(passport, \"pid\")[2], \":\")[2], \" \")[1]\n",
    "        # ignore cid\n",
    "\n",
    "        # check if parameters in range\n",
    "        # byr (Birth Year) - four digits; at least 1920 and at most 2002.\n",
    "        # iyr (Issue Year) - four digits; at least 2010 and at most 2020.\n",
    "        # eyr (Expiration Year) - four digits; at least 2020 and at most 2030.\n",
    "        # hgt (Height) - a number followed by either cm or in:\n",
    "        # If cm, the number must be at least 150 and at most 193.\n",
    "        # If in, the number must be at least 59 and at most 76.\n",
    "        # hcl (Hair Color) - a # followed by exactly six characters 0-9 or a-f.\n",
    "        # ecl (Eye Color) - exactly one of: amb blu brn gry grn hzl oth.\n",
    "        # pid (Passport ID) - a nine-digit number, including leading zeroes.\n",
    "        # cid (Country ID) - ignored, missing or not.\n",
    "        if ((byr >= 1920) & (byr <= 2002)) & \n",
    "            ((iyr >= 2010 & iyr <= 2020)) & \n",
    "            ((eyr >= 2020) & (eyr <= 2030)) & \n",
    "            occursin(r\"^#[0-9A-Fa-f]{6}$\", hcl) & \n",
    "            occursin(r\"amb|blu|brn|gry|grn|hzl|oth\", ecl) & \n",
    "            occursin(r\"\\d{9}\", pid) & \n",
    "            (((hgt_unit == \"cm\") & (hgt >= 150) & (hgt <= 193)) | ((hgt_unit == \"in\") & (hgt >=59) & (hgt <= 76)))\n",
    "            global validpart2 = validpart2 + 1\n",
    "        end # if ((byr >= ....))\n",
    "\n",
    "    end #if occursin\n",
    "end #for passport in data\n",
    "\n",
    "println(\"Part 1: Valid passports = $validpart1\")\n",
    "println(\"Part 2: Valid passports = $validpart2\")\n",
    "\n"
   ]
  },
  {
   "source": [
    "# Day 5\n",
    "## --- Binary Boarding ---"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Part 1: Highest seat ID is: 922\n",
      "Part 2: seat id is: 747\n"
     ]
    }
   ],
   "source": [
    "using DelimitedFiles\n",
    "f = open(\"d05-input.txt\")\n",
    "data = readdlm(f, '\\t', String, '\\n')\n",
    "close(f)\n",
    "\n",
    "# Part 1 - find highest seat id\n",
    "\n",
    "global maxseatid=0\n",
    "for line in data\n",
    "    # split the ticketdata into row and seat info\n",
    "    global row_code = line[1:7]\n",
    "    global seat_code= line[8:end]\n",
    "    global seatid = 0\n",
    "    global seatrow = 0:127\n",
    "    global seatnum = 0:7\n",
    "\n",
    "    for s in row_code\n",
    "        if s == 'F'\n",
    "            global seatrow = seatrow[1:Integer(length(seatrow)/2)]\n",
    "        else\n",
    "            global seatrow = seatrow[Integer(length(seatrow)/2)+1:end]\n",
    "        end\n",
    "    end\n",
    "\n",
    "    for s in seat_code\n",
    "        if s == 'L'\n",
    "            global seatnum = seatnum[1:Integer(length(seatnum)/2)]\n",
    "        else\n",
    "            global seatnum = seatnum[Integer(length(seatnum)/2)+1:end]\n",
    "        end\n",
    "        global seatid = seatrow[1] * 8 + seatnum[1]\n",
    "        global maxseatid = (seatid * (seatid > maxseatid)) + (maxseatid * (seatid <= maxseatid))\n",
    "    end\n",
    "end\n",
    "println(\"Part 1: Highest seat ID is: $maxseatid\")\n",
    "\n",
    "# Part 2\n",
    "maxseatid=0\n",
    "seatid=[]\n",
    "\n",
    "for line in data\n",
    "    global row_code = line[1:7]\n",
    "    global seat_code= line[8:end]\n",
    "    global seatrow = 0:127\n",
    "\tglobal seatnum = 0:7\n",
    "\t\n",
    "    for s in row_code\n",
    "        if s == 'F'\n",
    "            seatrow = seatrow[1:Integer(length(seatrow)/2)]\n",
    "        else\n",
    "            seatrow = seatrow[Integer(length(seatrow)/2)+1:end]\n",
    "\t\tend\n",
    "\tend\n",
    "    for s in seat_code\n",
    "        if s == 'L'\n",
    "            seatnum = seatnum[1:Integer(length(seatnum)/2)]\n",
    "        else\n",
    "            seatnum = seatnum[Integer(length(seatnum)/2)+1:end]\n",
    "\t\tend\n",
    "\tend\n",
    "    push!(seatid, (seatrow[1] * 8 + seatnum[1]))\n",
    "end\n",
    "\n",
    "sort!(seatid)\n",
    "\n",
    "for s in 1:length(seatid)-1\n",
    "    if Integer(seatid[s+1] - seatid[s]) == 1\n",
    "        continue\n",
    "    else\n",
    "        println(\"Part 2: seat id is: $(Integer((seatid[s+1]+seatid[s]) / 2))\")\n",
    "\tend\n",
    "end\n",
    "\n"
   ]
  },
  {
   "source": [
    "# Day 6:\n",
    "## --- Custom Customs ---"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Part 1: the number of questions to which anyone answered \"yes\" = : 6297\nPart 2: the number of questions to which everyone answered \"yes\" = : 3158\n"
     ]
    }
   ],
   "source": [
    "readInput() = split.(split(read(\"d06-input.txt\", String), \"\\n\\n\"))\n",
    "data = readInput()\n",
    "\n",
    "# solve by creating a set of responses.\n",
    "# Part 1 : answers for anyone is the union of sets of answers\n",
    "# Part 2 : answers for everyone in the intersection of the sets of answers\n",
    "\n",
    "global part1 = 0\n",
    "global part2 = 0\n",
    "for line in data\n",
    "    if line == [] continue end\n",
    "    txt1 = \"\"\n",
    "    txt2 = line[1]\n",
    "\tfor x in 1:length(line)\n",
    "        txt1 = ∪(txt1,line[x]) # ∪ symbol for union\n",
    "        txt2 = ∩(txt2, line[x]) # ∩ symbol for intersection\n",
    "\tend\n",
    "    global part1 += length(txt1)\n",
    "    global part2 += length(txt2)\n",
    "end\n",
    "println(\"Part 1: the number of questions to which anyone answered \\\"yes\\\" = : $part1\")\n",
    "println(\"Part 2: the number of questions to which everyone answered \\\"yes\\\" = : $part2\")\n"
   ]
  },
  {
   "source": [
    "# Day 7: \n",
    "## --- Handy Haversacks ---\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Part 1: How many bag colors can eventually contain at least one shiny gold bag? Answer: 278\n"
     ]
    }
   ],
   "source": [
    "readInput() = split(read(\"d07-input.txt\", String), \"\\n\")\n",
    "data = readInput()\n",
    "\n",
    "# data = [\"light red bags contain 1 bright white bag, 2 muted yellow bags.\", \"dark orange bags contain 3 bright white bags, 4 muted yellow bags.\", \"bright white bags contain 1 shiny gold bag.\" , \"muted yellow bags contain 2 shiny gold bags, 9 faded blue bags.\" , \"shiny gold bags contain 1 dark olive bag, 2 vibrant plum bags.\" , \"dark olive bags contain 3 faded blue bags, 4 dotted black bags.\", \"vibrant plum bags contain 5 faded blue bags, 6 dotted black bags.\" , \"faded blue bags contain no other bags.\", \"dotted black bags contain no other bags.\"]\n",
    "myBags = []\n",
    "data_clean = [split(data[i], \" contain \") for i in 1:length(data)]\n",
    "\n",
    "# find the bags that can contain \"shiny gold bags\"\n",
    "myBags = [data_clean[s][1][1:length(data_clean[s][1])-5] for s in 1:length(data_clean) if occursin(\"shiny gold\", data_clean[s][2])]\n",
    "\n",
    "# find bags that can contain bags that can contain \"shiny gold bags\"\n",
    "for bag_col in myBags\n",
    "\tunion!(myBags, [data_clean[s][1][1:length(data_clean[s][1])-5] for s in 1:length(data_clean) if occursin(bag_col, data_clean[s][2])])\n",
    "\t# using union removes the need to remove duplicate entries\n",
    "end\n",
    "\n",
    "println(\"Part 1: How many bag colors can eventually contain at least one shiny gold bag? Answer: $(length(myBags))\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/usr/bin/env julia\n",
    "\n",
    "parsebags(filename) =\n",
    "    let bagmap = Dict{String,Array{Pair{String,Int}}}()\n",
    "        for line ∈ eachline(filename)\n",
    "            root = match(r\"(.*?) bags contain\", line).captures[1]\n",
    "            start = SubString(line, last(findlast(\"contain \", line)))\n",
    "            children = match.(r\"(\\d+) (.*?) bags?[,.]?$\", split(start, \",\"))\n",
    "            foreach(children) do child\n",
    "                get!(bagmap, root, [])\n",
    "                if !isnothing(child)\n",
    "                    count, name = child.captures\n",
    "                    push!(bagmap[root], string(name) => parse(Int, count)) \n",
    "                end\n",
    "            end\n",
    "        end\n",
    "        bagmap\n",
    "    end\n",
    "\n",
    "dfs(graph, root, visited = []) =\n",
    "    let total = 0\n",
    "        root ∈ visited || push!(visited, root)\n",
    "        foreach(graph[root]) do (child, count)\n",
    "            _, nc = dfs(graph, child, visited)\n",
    "            total += count * (nc + 1)\n",
    "        end\n",
    "        visited, total\n",
    "    end\n",
    "dfs(graph) = root -> dfs(graph, root)\n",
    "\n",
    "alldfs(graph) = map(dfs(graph), [keys(graph)...])\n",
    "\n",
    "if abspath(PROGRAM_FILE) == @__FILE__\n",
    "    filename = joinpath(@__DIR__, \"d07-input.txt\")\n",
    "    # part 1\n",
    "    println(\"Part 1: How many bag colors can eventually contain at least one shiny gold bag? Answer: \", count(path -> \"shiny gold\" ∈ path[2:end],\n",
    "                first.(alldfs(parsebags(filename)))))\n",
    "    # part 2\n",
    "    println(\"Part 2: How many individual bags are required inside your single shiny gold bag? Answer: \", last(dfs(parsebags(filename), \"shiny gold\")))\n",
    "end"
   ]
  },
  {
   "source": [
    "# Day 8\n",
    "## --- Handheld Halting ---"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Immediately before any instruction is executed a second time, what value is in the accumulator?\n",
      "2058\n",
      "844\n"
     ]
    }
   ],
   "source": [
    "# read data file\n",
    "readInput() = split(read(\"d08-input.txt\", String), \"\\n\")\n",
    "data = readInput()\n",
    "# test data\n",
    "# data = [\"nop +0\", \"acc +1\", \"jmp +4\", \"acc +3\", \"jmp -3\", \"acc -99\", \"acc +1\", \"jmp -4\", \"acc +6\"]\n",
    "\n",
    "# Part 1\n",
    "\n",
    "# initialise variables\n",
    "global codeLine = 1\n",
    "global accumulator = 0\n",
    "global executedCodeLines = []\n",
    "global repeatedLines = false\n",
    "\n",
    "# loop until a line is repeated\n",
    "while !(repeatedLines)\n",
    "    # split input data into components\n",
    "    command = data[codeLine][1:3]\n",
    "    value = parse(Int64, data[codeLine][5:end])\n",
    "    # if the line of code has been executed then change the repeatedLines variable\n",
    "    if codeLine in executedCodeLines\n",
    "        global repeatedLines = true\n",
    "        break\n",
    "    else push!(executedCodeLines, codeLine)\n",
    "    end\n",
    "    # execute the commands\n",
    "    if command == \"acc\"\n",
    "        global accumulator += value\n",
    "        global codeLine += 1\n",
    "    end\n",
    "    if command == \"nop\"\n",
    "        codeLine += 1\n",
    "    end\n",
    "    if command == \"jmp\"\n",
    "        codeLine += value\n",
    "    end\n",
    "end\n",
    "# print result\n",
    "println(\"Immediately before any instruction is executed a second time, what value is in the accumulator?\")\n",
    "println(accumulator)\n",
    "\n",
    "# Part 2\n",
    "\n",
    "# identify all the lines with jmp or nop\n",
    "testLines = []\n",
    "for (idx, i) in enumerate(data)\n",
    "    if (i[1:3] == \"jmp\") | (i[1:3] == \"nop\")\n",
    "        push!(testLines, idx-1) # ?? should this -1 be here - trying to convert betwwen python 0 index and julia 1 index.\n",
    "\tend\n",
    "end\n",
    "\n",
    "# loop through the list changing each in turn to the other\n",
    "\n",
    "for idx in testLines\n",
    "    if data[idx][1:3] == \"jmp\"\n",
    "\t\tdata[idx] = replace(data[idx], \"jmp\" => \"nop\")\n",
    "    else\n",
    "        data[idx] = replace(data[idx], \"nop\" => \"jmp\")\n",
    "\tend\n",
    "\n",
    "# initialise variables\n",
    "    global codeLine = 1\n",
    "    global accumulator = 0\n",
    "    global executedCodeLines = []\n",
    "    global lastJmpLine = []\n",
    "    global repeatedLines = false\n",
    "\n",
    "    # while-loop until a line is repeated\n",
    "    while !(repeatedLines)\n",
    "        # split input data into components\n",
    "        command = data[codeLine][1:3]\n",
    "        value = parse(Int64, data[codeLine][5:end])\n",
    "        # if the line of code has been executed then change the repeatedLines variable\n",
    "        if codeLine in executedCodeLines\n",
    "            global repeatedLines = true\n",
    "            # reset the change code line then end the loop\n",
    "            if data[idx][1:3] == \"jmp\"\n",
    "                data[idx] = replace(data[idx], \"jmp\" => \"nop\")\n",
    "            else\n",
    "                data[idx] = replace(data[idx], \"nop\" => \"jmp\")\n",
    "            end\n",
    "            break\n",
    "        else push!(executedCodeLines, codeLine)\n",
    "\t\tend\n",
    "        # execute the commands\n",
    "        if command == \"acc\"\n",
    "            global accumulator += value\n",
    "            global codeLine += 1\n",
    "\t\tend\n",
    "        if command == \"nop\"\n",
    "            codeLine += 1\n",
    "\t\tend\n",
    "        if command == \"jmp\"\n",
    "            codeLine += value\n",
    "\t\tend\n",
    "        if codeLine > length(data)\n",
    "            break\n",
    "\t\tend\n",
    "    end # while\n",
    "    if (repeatedLines == false) & (codeLine == length(data))\n",
    "        break\n",
    "\tend\n",
    "end # for idx\n",
    "\n",
    "println(accumulator)\n"
   ]
  },
  {
   "source": [
    "# Day 9:\n",
    "## --- Encoding Error ---"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "The first step of attacking the weakness in the XMAS data is to find the first number in the list (after the preamble) which is not the sum of two of the 25 numbers before it. What is the first number that does not have this property? 10884537\n",
      "What is the encryption weakness in your XMAS-encrypted list of numbers? 1261309\n"
     ]
    }
   ],
   "source": [
    "# read data file\n",
    "readInput() = split(read(\"d09-input.txt\", String), \"\\n\")\n",
    "stringData = readInput()\n",
    "# convert strings to Integer\n",
    "data = []\n",
    "for i in stringData\n",
    "    push!(data, parse(Int,i))\n",
    "end\n",
    "\n",
    "# test data\n",
    "# data = [35, 20, 15, 25, 47, 40, 62, 55, 65, 95, 102, 117, 150, 182, 127, 219, 299, 277, 309, 576]\n",
    "preamble = 25 #25 for main problem, 5 for testing\n",
    "\n",
    "#Part 1\n",
    "\n",
    "for (idx,i) in enumerate(data[preamble+1:end])\n",
    "    global solution = false\n",
    "    # println(\"idx\",idx,\" i\",i)\n",
    "    for j in data[idx:idx+preamble-1]\n",
    "        for k in data[idx:idx+preamble-1]\n",
    "            if (j + k == i) &&  (j != k)\n",
    "                # println(\"i\",i,\"j\",j,\"k\",k)\n",
    "                global solution = true\n",
    "                break\n",
    "            end\n",
    "        end\n",
    "        if solution == true\n",
    "            break\n",
    "        end\n",
    "    end\n",
    "    if solution == false\n",
    "        println(\"The first step of attacking the weakness in the XMAS data is to find the first number in the list (after the preamble) which is not the sum of two of the 25 numbers before it. What is the first number that does not have this property? \",i)\n",
    "        return global targetNumber = i\n",
    "        break\n",
    "    end\n",
    "end\n",
    "\n",
    "# Part 2\n",
    "\n",
    "# i is the value, indexin(i, data) is the position of i in the list\n",
    "# need to loop through the data list to the position of i to find \n",
    "# a combination of two or more numbers that sum to i\n",
    "#global targetNumber = i\n",
    "global targetIdx = indexin(targetNumber, data)[1]\n",
    "for i in 1:targetIdx-1\n",
    "    sum = 0\n",
    "    vals = []\n",
    "    for j in data[i:targetIdx]\n",
    "        if i == j\n",
    "            continue\n",
    "        end\n",
    "        sum += j\n",
    "        push!(vals, j)\n",
    "        if sum == targetNumber\n",
    "            # println(targetNumber, \" \", sum, \" \", vals)\n",
    "            println(\"What is the encryption weakness in your XMAS-encrypted list of numbers? \", minimum(vals) + maximum(vals))\n",
    "            break\n",
    "        end\n",
    "        if sum > targetNumber\n",
    "            break\n",
    "        end\n",
    "    end\n",
    "end\n",
    "\n",
    "\n",
    "\n"
   ]
  }
 ]
}