Solved 2024/03 P1+P2

2017/23/23.md

@@ -28,8 +28,6 @@ instruction invoked?*
 
 Your puzzle answer was `5929`.
 
-The first half of this puzzle is complete! It provides one gold star: \*
-
 ## \-\-- Part Two \-\-- {#part2}
 
 Now, it\'s time to fix the problem.
@@ -50,8 +48,14 @@ it wouldn\'t even need to run the program.
 After setting register `a` to `1`, if the program were to run to
 completion, *what value would be left in register `h`?*
 
-Answer:
+Your puzzle answer was `907`.
 
-Although it hasn\'t changed, you can still [get your puzzle
+Both parts of this puzzle are complete! They provide two gold stars:
+\*\*
+
+At this point, you should [return to your Advent calendar](/2017) and
+try another puzzle.
+
+If you still want to see it, you can [get your puzzle
 input](23/input).
 

2017/23/input.2

@@ -0,0 +1,22 @@
+set e 2
+set g d
+mul g e
+sub g b
+jnz g 2
+set f 0
+sub e -1
+set g e
+sub g b
+jnz g -8
+sub d -1
+set g d
+sub g b
+jnz g -13
+jnz f 2
+sub h -1
+set g b
+sub g c
+jnz g 2
+jnz 1 3
+sub b -17
+jnz 1 -23

2017/23/input.3

@@ -0,0 +1,31 @@
+a = 1
+b = 79 * 100 + 100000
+c = 79 * 100 + 100000 + 17000
+
+ 9. set f 1
+10. set d 2
+11. set e 2
+
+12. 
+
+
+if g != 0 jump to 12
+    g = d * e - b
+
+    if g != 0
+        f = 0
+        g = (e - 1) - b
+
+21. sub d -1
+22. set g d
+23. sub g b
+24. jnz g -13 jump to 11
+25. jnz f 2 jump to 27
+26. sub h -1
+27. set g b
+28. sub g c
+29. jnz g 2
+30. jnz 1 3
+31. sub b -17
+32. jnz 1 -23 jump to 9
+ 

2017/23/solution.py

@@ -3,10 +3,10 @@ import sys,re
 from pprint import pprint
 sys.path.insert(0, '../../')
 from fred import list2int
-
+from math import sqrt
 input_f = 'input'
 
-part = 1
+part = 3
 #########################################
 #                                       #
 #              Part 1                   #
@@ -34,7 +34,7 @@ if part == 1:
     instructions = []
 
     Sets = {
-        'a': 1,
+        'a': 0,
         'b': 0,
         'c': 0,
         'd': 0,
@@ -81,4 +81,72 @@ if part == 1:
 #                                       #
 #########################################
 if part == 2:
-    exit()
+    instructions = []
+
+    Sets = {
+        'a': 1,
+        'b': 107900,
+        'c': 124900,
+        'd': 3,
+        'e': 107900,
+        'f': 1,
+        'g': -107897,
+        'h': 0
+    }
+
+    count = 0
+
+    with open(input_f) as file:
+        for line in file:
+            instructions.append(list(parse_input(line.rstrip())))
+
+    intr = 0
+    while 0 <= intr < len(instructions):
+
+        i = instructions[intr]
+
+        x = i[1]
+        y = i[2]
+
+        if i[0] == 'set':
+            Sets[x] = sets_return(y,Sets)
+            
+        elif i[0] == 'sub':
+            Sets[x] -= sets_return(y,Sets)
+            
+        elif i[0] == 'mul':
+            Sets[x] *= sets_return(y,Sets)
+            count += 1
+
+        elif i[0] == 'jnz': 
+            if sets_return(x,Sets) != 0:
+                intr += sets_return(y,Sets)-1
+        intr += 1  
+        print(i)
+        print(Sets)
+        input()
+    print(count)
+
+
+if part == 3:
+    b = 107900
+    d = 2
+    e = 2
+    h = 0
+    for x in range(107900,124900,17):
+        for y in range(2,x):
+            if x%y == 0:
+                print(x,y,h)
+                h+=1
+    print(h)
+
+# def is_composite(n):
+#     if n < 2:
+#         return False
+#     for i in range(2, int(sqrt(n)) + 1):
+#         if n % i == 0:
+#             return True
+#     return False
+
+# h = sum(1 for b in range(107900, 124901, 17) if is_composite(b))
+# print(h)

2024/03/3.md

@@ -0,0 +1,81 @@
+## \-\-- Day 3: Mull It Over \-\--
+
+\"Our computers are having issues, so I have no idea if we have any
+Chief Historians [in
+stock]{title="There's a spot reserved for Chief Historians between the green toboggans and the red toboggans. They've never actually had any Chief Historians in stock, but it's best to be prepared."}!
+You\'re welcome to check the warehouse, though,\" says the mildly
+flustered shopkeeper at the [North Pole Toboggan Rental
+Shop](/2020/day/2). The Historians head out to take a look.
+
+The shopkeeper turns to you. \"Any chance you can see why our computers
+are having issues again?\"
+
+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!
+
+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`.
+
+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*.
+
+For example, consider the following section of corrupted memory:
+
+    xmul(2,4)%&mul[3,7]!@^do_not_mul(5,5)+mul(32,64]then(mul(11,8)mul(8,5))
+
+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`).
+
+Scan the corrupted memory for uncorrupted `mul` instructions. *What do
+you get if you add up all of the results of the multiplications?*
+
+Your puzzle answer was `174561379`.
+
+## \-\-- Part Two \-\-- {#part2}
+
+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.
+
+There are two new instructions you\'ll need to handle:
+
+-   The `do()` instruction *enables* future `mul` instructions.
+-   The `don't()` instruction *disables* future `mul` instructions.
+
+Only the *most recent* `do()` or `don't()` instruction applies. At the
+beginning of the program, `mul` instructions are *enabled*.
+
+For example:
+
+    xmul(2,4)&mul[3,7]!^don't()_mul(5,5)+mul(32,64](mul(11,8)undo()?mul(8,5))
+
+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.
+
+This time, the sum of the results is `48` (`2*4 + 8*5`).
+
+Handle the new instructions; *what do you get if you add up all of the
+results of just the enabled multiplications?*
+
+Your puzzle answer was `106921067`.
+
+Both parts of this puzzle are complete! They provide two gold stars:
+\*\*
+
+At this point, you should [return to your Advent calendar](/2024) and
+try another puzzle.
+
+If you still want to see it, you can [get your puzzle
+input](3/input).
+

2024/03/solution.py

@@ -0,0 +1,51 @@
+#!/bin/python3
+import sys,re
+from pprint import pprint
+sys.path.insert(0, '../../')
+from fred import list2int,get_re,nprint,lprint
+
+input_f = 'input'
+
+part = 2
+#########################################
+#                                       #
+#              Part 1                   #
+#                                       #
+#########################################
+result = 0
+if part == 1:
+    with open(input_f) as file:
+        for line in file:
+            for i in re.findall(r"(mul\((\d+),{1}(\d+)\))",line.rstrip()):
+                result += (int(i[1])*int(i[2]))
+
+    print(result)
+
+
+
+#########################################
+#                                       #
+#              Part 2                   #
+#                                       #
+#########################################
+result = 0
+do = True
+if part == 2:
+    with open(input_f) as file:
+        for line in file:
+            matches = re.findall(r"mul\(\d+,\d+\)|do\(\)|don't\(\)",line.rstrip())
+            for match in matches:
+                if match == 'do()':
+                    do = True
+                elif match == "don't()":
+                    do = False
+                else:
+                    if do:
+                        m = get_re(r"mul\((\d+),{1}(\d+)\)",match)
+                        result += (int(m.group(1))*int(m.group(2)))
+print(result)
+
+# Not really happy with my code. I would prefer to find all mul(x,y) between do() and don't(), 
+# instead of finding all the mul/do/don't and then turning calculation on/off. 
+
+#(do\(\).*?mul\((\d+),{1}(\d+)\))

2024/03/test.py

@@ -0,0 +1,16 @@
+from re import findall
+
+total1 = total2 = 0
+enabled = True
+data = open('input').read()
+
+for a, b, do, dont in findall(r"mul\((\d+),(\d+)\)|(do\(\))|(don't\(\))", data):
+    if do or dont:
+        enabled = bool(do)
+    else:
+        x = int(a) * int(b)
+        total1 += x
+        total2 += x * enabled
+
+print(total1, total2)
+

README.md

@@ -3,7 +3,8 @@
 ## 2024
 
            .--'~ ~ ~|        .-' *       \  /     '-.   1 **
-        .--'~  ,* ~ |        |  <o>   \_\_\|_/__/   |   2 **
+        .--'~  ,* ~ |        |  >o<   \_\_\|_/__/   |   2 **
+    .---': ~ '(~), ~|        | >@>O< o-_/.()__------|   3 **
 ## 2023
 
                       .      * ~~~~  /\ ' .            14