Advent of Code

Advent of Code 2024 – Day 06 – Guard Gallivant

Ramen Junkie December 6, 2024 1Comment

It’s happening already. The slow crushing creep of laziness. I have not done part 2, yet, and I will, maybe get to it. I have ideas for how to solve part 2, its just… Kind of tedious and I want a respite.

Part 1 was fun though. Basically just, a simple pathfinding robot to trace the path of a guard through a maze of obstacles. I even gave it the ability to draw the map, but the dataset is bigger than my monitor so the refresh and drawing it’s stupid ugly with the real data set. I also turned it off because it drags the entire process to a crawl. A seconds-long calculation takes minutes and counting when its drawing nonsense.

The sample dataset looks neat though when drawn.

Part 2 is to find every place you could drop an object to create a loop for the guard. I thought I had it, I had the right idea, but I only ended up finding all of the existing loops. And I am not sure some were not in the middle of “walls”.

I got to thinking about what I did wrong, which is basically, checking for squares (loops) instead of finding them. I got to thinking about new algorithms to check all directions instead of just one, but what I need to do is to check along each side for walls and see if the gap is longer than the previous sides.  But that’s not going to work exactly, so I think I can use the distances traveled to see if there are places to drop objects based on if sides are shorter than the previous sides.

That probably made more sense in my head.

It probably isn’t that hard, I just, don’t feel like doing it right now. Occasionally there is a stupid simple one thrown in that takes 5 minutes to do both parts, maybe I can come back to today on that day.

Or maybe just sometime tomorrow, tomorrow is surprisingly pretty open.

Anyway, here is the code, I trimmed out the useless part 2 function.

import time
import os

with open("Day06Input.txt") as file:
    data = file.read()

lines = data.split("\n")
lines.pop()

guard = [0,0,0]
grid = []
guard_active = True
total = 0
total2 = 0
distances = []
cur_steps = 0

for each in lines:
  if "^" in each:
    guard[0] = each.index("^")
    guard[1] = lines.index(each)
#  print(guard)
  grid.append(list(each))

def print_grid(thegrid):
  for each in thegrid:
    print("".join(each))

#print_grid(grid)

def move_guard(thegrid, guard_pos):
# 0 - North, 1 - East, 2 - South, 3 - West
# Defind in guard[2]
# guard[0] = x coord (across rows), guard [1] = y coord (up and down lines)
  step = 1
  if (thegrid[guard_pos[1]-1][guard_pos[0]] != "#") and guard_pos[2] == 0:
    thegrid[guard_pos[1]][guard_pos[0]] = "X"
    thegrid[guard_pos[1]-1][guard_pos[0]] = "^"
    guard_pos[1] = guard_pos[1]-1
  elif (thegrid[guard_pos[1]][guard_pos[0]+1] != "#") and guard_pos[2] == 1:
    thegrid[guard_pos[1]][guard_pos[0]] = "X"
    thegrid[guard_pos[1]][guard_pos[0]+1] = "^"
    guard_pos[0] = guard_pos[0]+1
  elif (thegrid[guard_pos[1]+1][guard_pos[0]] != "#") and guard_pos[2] == 2:
    thegrid[guard_pos[1]][guard_pos[0]] = "X"
    thegrid[guard_pos[1]+1][guard_pos[0]] = "^"
    guard_pos[1] = guard_pos[1]+1
  elif (thegrid[guard_pos[1]][guard_pos[0]-1] != "#") and guard_pos[2] == 3:
    thegrid[guard_pos[1]][guard_pos[0]] = "X"
    thegrid[guard_pos[1]][guard_pos[0]-1] = "^"
    guard_pos[0] = guard_pos[0]-1
  else:
    guard_pos[2] = (guard_pos[2]+1) % 4
    step = 0
#  print(guard_pos)

  return thegrid, guard_pos, step


while guard_active:
  this_step = 0
  grid, guard, this_step = move_guard(grid, guard)
  if this_step == 0:
    distances.append(cur_steps)
    cur_steps = 0
  else:
    cur_steps += this_step
# Optionally Print the Map
#  print_grid(grid)
#  time.sleep(.001)
#  os.system('clear')
#  print(guard)
#  print(len(grid)-1)
  if guard[1] >= len(grid)-1 or guard[1] <= 0 or guard[0] >= len(grid[0])-1 or guard[0] <= 0:
    grid[guard[1]][guard[0]] = "X"
    guard_active = False
    print("The guard has left the area!")

for each in grid:
  total+= each.count("X")

#Print the final grid for fun
#print_grid(grid)

print(distances)

print(total)
# 5318
print(total2)

Ramen Junkie

Josh Miller aka “Ramen Junkie”.  I write about my various hobbies here.  Mostly coding, photography, and music.  Sometimes I just write about life in general.  I also post sometimes about toy collecting and video games at Lameazoid.com.

www.bloggingintensifies.com

Advent of Code 2024 – Day 05 – Print Queue

Ramen Junkie December 5, 2024 2Comments

Well, it’s an easy and hard-ish day.  I kind of hate the part 2s on these because they are almost always annoying.  It was a bit more interesting on the input because it was a two part input.  I’m still getting weird empty spaces at the end too, which I have just been trimming with a .pop(), but that’s a bit sloppy.  Today’s puzzle is verifying sorting of sets of numbers.

Part 1 was pretty simple, mostly because I forced myself not to “overthink it”.  I just, compared every pair set to the valid list.  Then if they were valid, added them into the total.  It feels like it’s going to miss some things, but it didn’t.  I got the correct answer in one try.

Part 2 was a pain.  It was, “take the wrong answers and fix them”.  What I did initially was just, swap the numbers if they were wrong.  This would put them one step closer to correct, afterwards, it fed them back through the check, this time flagged as bad, since the two sets need to be answered separately.  This code worked for the sample input for both parts. 

When I ran it through my actual data, this resulted in an answer of “5692”, which was incorrect.  Everything seemed correct in the code.  I even created a copy of the sorting loop with a “total3”, this time just running through bad pages.  It matched the answer of 5692.  So I started trying to guess a bit to see if I was even close I was within 100 for sure.  I went off to Reddit and pulled someone else’s code, ran my data set through it, and got the answer “5770”, which is the correct answer.

It also gave me a direction on where to look.  I tried a different sort where I just, slapped the first number at the end and sorted it back through.  It returned the same 5692.  Which would be a good sign, that both sorts were getting the same results, if the answer was correct.  On a bit of a lark, I decided to see just how off I was, 5770-5692 is 78.  In the data, on the last line, is a 78.  This was the key to solving the problem.  I uncommented some of my print statements and, sure enough, it wasn’t running the last line.

You know that .pop() I mentioned back at the start of this?  Well, it turns out that the sample data had an extra blank.  My actual data, did not, so it was just, dropping the last line of data.

Remember when I said it was a bad idea?

with open("Day05Input.txt") as file:
    data = file.read()


rules = data.split("\n\n")[0].split("\n")
pages = data.split("\n\n")[1].split("\n")
#pages.pop()
bad_pages = []

#Verify Inputs
#for each in pages:
#for each in rules:
#  print(each)

total = 0
total2 = 0
total3 = 0

for each in pages:
  these_pages = each.split(",")
  goodset = True
  running = True
#  print(these_pages)
  while running:
#    print(these_pages)
    running = False
    restart = False 
    for p1 in these_pages:
      for p2 in these_pages[these_pages.index(p1):]:
        if p1 != p2:
          pair = f"{p1}|{p2}"
          if pair in rules:
            #print("Good")
            pass
          else:
#            print(these_pages.index(p1))
            p1pos = these_pages.index(p1)
            p2pos = these_pages.index(p2)
            these_pages[p1pos] = p2
            these_pages[p2pos] = p1
#            print(these_pages.index(p1))
            #print("Bad")
            #print(pair)
            running = True
            goodset = False
 #           print("---")
 #           print(these_pages)
  if goodset:
    #print(f"Set {pages.index(each)} is good")
    total += int(these_pages[int((len(these_pages) - 1)/2)])
  else:
    bad_pages.append(these_pages)
    total2 += int(these_pages[int((len(these_pages) - 1)/2)])



for these_pages in bad_pages:
  goodset = True
  running = True
#  print(these_pages)
  while running:
#    print(these_pages)
    running = False
    restart = False 
    for p1 in these_pages:
      for p2 in these_pages[these_pages.index(p1):]:
        if p1 != p2:
          pair = f"{p1}|{p2}"
          if pair in rules:
            #print("Good")
            pass
          else:
            these_pages.append(these_pages.pop(p1))
#            print(these_pages.index(p1))
#            print(these_pages.index(p1))
            #print("Bad")
            #print(pair)
            running = True
            goodset = False
 #           print("---")
 #           print(these_pages)
  total3 += int(these_pages[int((len(these_pages) - 1)/2)])




print(total)
print(total2)
# Part 1 - 7365
#5692 Low
#5700 Low
#5800 Too High
#5750 - Wrong
#5730 - Wrong
print(total3)
## Its not working but the answer for future reference is 5770

Ramen Junkie

Josh Miller aka “Ramen Junkie”.  I write about my various hobbies here.  Mostly coding, photography, and music.  Sometimes I just write about life in general.  I also post sometimes about toy collecting and video games at Lameazoid.com.

www.bloggingintensifies.com

Advent of Code 2024 – Part 04 – Ceres Search

Ramen Junkie December 4, 2024 1Comment

Weee, the first real “pain in the ass” day and it’s only day 4!

Ok, it wasn’t awful, I had the right idea, for the most part.  I wanted to do something better for Part 2, but it wasn’t working out, but I’ll get there.  For this puzzle, you get a blog of text with the letters of XMAS in them, randomly, scattered.  Sometimes it actually spells XMAS, it’s a “crossword” puzzle.  The ides is to find all of the occurrences of XMAS, crossword style, front, back, up down, and diagonally.  I used Numpy here to do some rotations on the letter matrix, which was fun.

First was a simple search for “XMAS” and “SAMX” on every line of the matrix.  Then I looked into how to rotate the matrix, 45 degrees.  Thankfully, there was a way.  I did it twice, one clockwise and one counter clockwise, which gave me all of the “diagonals” as single lines of texts.  I appended this to the normal lines and did the search again.  Then I realized, I needed to also search the verticals.  This meant, another, different, Numpy rotation.  I appended this to the big blob of lines as well, and ran the search again.

This gave the correct answer, easy.

I started out with a good but failed approach on Part 2.  Some of the code is still there, commented out, for posterity.

For Part two, the search is modified, you need to find all occurrences of “X-MAS”.  That is, places where the letters “MAS” make an “X” shape.  They can go forward or backwards, and must occur twice.  I started out by making a second copy of my diagonals lines.  I wanted to construct these back into “square” shapes.  I looked into doing some sort of fancy fill methods, but instead just, did a simple algorithm based on line lengths.  The idea was, to search for the As in one rotation block, then check if it’s a MAS or a SAM, then check the matching A on the opposite rotation block of text.  These coordinates should be opposites.  If point 2,4 is an “A”, then on the opposite rotation, that same A should be at point (1,2).

Except…  it’s not.  There is some funny doubling going on with one of the coordinates. I spent, more time than I care to admit trying to puzzle it out.  I finally gave up.

Instead I did the old fashioned “brute force” method.  I took the original block of text, checked each character to see if it’s an A, if it was an A, I built the two cross words, and checked if they were SAM or MAS.  This all occurs before modifying the block of text for part 1.

I got stuck a bit on it again, because I made a stupid typo and used “i” instead of “j” when making my check words.

Anyway, here is my code below for Day 4 in Python. 

with open("Day04Input.txt") as file:
    data = file.read()

import numpy as np

lines = data.split("\n")
lines.pop()
diaglines = []
total = 0
total2 = 0
grid = []
gridsize = len(lines[1])

for each in lines:
  grid.append(list(each))

a = np.array(grid)

rotated_a = np.rot90(a)

# Part 2 visa the shitty Brute Force Way
for i in range(len(lines)-1):
  for j in range(len(lines[i])-1):
    if i != 0 and j != 0:
#      print(lines[i][j])
      if lines[i][j] == 'A':
        check1 = lines[i+1][j+1]+lines[i][j]+lines[i-1][j-1]
        check2 = lines[i+1][j-1]+lines[i][j]+lines[i-1][j+1]
        if (check1 == "MAS" or check1 == "SAM") and (check2 == "MAS" or check2 == "SAM"):
          total2 += 1
#          print(check1)
#          print(check2)
#          print("Match")
        else:
          print(check1)
          print(check2)
          print(lines[i-1])
          print(lines[i])
          print(lines[i+1])
          print("------")


# Rotate the array 90 and add the lines to our overall lines
for row in rotated_a:
#  print(''.join(row))
  lines.append(''.join(row))

# Rotate the array diagonally
# https://stackoverflow.com/questions/6313308/get-all-the-diagonals-in-a-matrix-list-of-lists-in-python
diags = [a[::-1,:].diagonal(i) for i in range(-a.shape[0]+1,a.shape[1])]
diags.extend(a.diagonal(i) for i in range(a.shape[1]-1,-a.shape[0],-1))
#######################################################################################################


## Join the rotated numpy array and add it to our total lines to ge the diagonals
for n in diags:
  new_string = f"{''.join(str(i) for i in n.tolist())}" 
#  print(new_string)
#  padding = int((gridsize - len(new_string))/2)
#  diag_string = ('o'*padding) + new_string + ('o'*padding)
#  if len(diag_string) % 2 == 0:
#    diag_string = diag_string[:-1]
  lines.append(new_string)
#  diaglines.append(diag_string)

#print(diaglines)

# Count up for Part 1
for each in lines:
#  print(each)
  total+= each.count("XMAS")
  total+= each.count("SAMX")

#dlist1 = diaglines[:len(diaglines)//2]
#dlist2 = diaglines[len(diaglines)//2:]


# Print Totals
print(total)
print(total2)

#1771 = Too low
#2003 = Too Low
#Part 1 - 2427

#3085 Too High
#1312 Too Low
#1900 - Part 2

Ramen Junkie

Josh Miller aka “Ramen Junkie”.  I write about my various hobbies here.  Mostly coding, photography, and music.  Sometimes I just write about life in general.  I also post sometimes about toy collecting and video games at Lameazoid.com.

www.bloggingintensifies.com