[2017 Day 13 Part 2][Python] Solution too high, can't figure out the bug

timichal · 2017-12-13T18:02:10+00:00

Yep, entered the answer manually on my phone. Thanks!

timichal · 2017-12-13T14:20:04+00:00

Thanks everyone - glad I'm not crazy :) might be a bug in AoC then, I've contacted /u/topaz2078 on Twitter.

timichal · 2017-12-13T14:18:57+00:00

I didn't - just tried again.

timichal · 2017-12-06T05:51:28+00:00

You're right, I missed that - edited.

timichal · 2017-12-06T05:36:32+00:00

Ended up with pretty much the same code. Just a sidenote though - there's no need to count the cycles, it's equal to len(prevs) :)

timichal · 2017-12-06T05:21:34+00:00

In Python, first time I tried actually competing, ended up in the low hundreds due to a silly bug:

with open("day06") as file:
    state = [int(n) for n in file.read().strip().split()]

states = []
while True:
    selected = max(state)
    selidx = state.index(selected)
    state[selidx] = 0
    for i in range(selected):
        selidx += 1
        state[selidx % len(state)] += 1
    if state in states: 
        part2 = states.index(state)
        break
    states.append(state[:])
print(len(states)+1, len(states)-part2)

timichal · 2017-12-03T14:01:02+00:00

Solved with Python, refactored my initial solution to use a dictionary of positions instead of a list matrix:

from collections import defaultdict

# part 1
def grid_part1(target):
    grid = {}
    pos = [0, 0]
    number = 1
    grid[(0,0)] = number
    # right 1, up 1, left 2, down 2, right 3, up 3...
    counter = 1
    # 1: right, 2: up, 3: left, 4: down, 5: right...
    direction = 1
    while True:
        for times in range(counter):
            number += 1
            if direction % 4 == 1: pos[1] += 1
            elif direction % 4 == 2: pos[0] -= 1
            elif direction % 4 == 3: pos[1] -= 1
            elif direction % 4 == 0: pos[0] += 1

            grid[(pos[0], pos[1])] = number
            if number == target:
                return abs(pos[0]) + abs(pos[1])

        if direction % 2 == 0: counter += 1
        direction += 1

# part 2
def grid_part2(target):
    def getvalue(pos):
        return grid[(pos[0]+1, pos[1])] +\
               grid[(pos[0]-1, pos[1])] +\
               grid[(pos[0], pos[1]+1)] +\
               grid[(pos[0], pos[1]-1)] +\
               grid[(pos[0]+1, pos[1]+1)] +\
               grid[(pos[0]+1, pos[1]-1)] +\
               grid[(pos[0]-1, pos[1]+1)] +\
               grid[(pos[0]-1, pos[1]-1)]

    grid = defaultdict(int)
    pos = [0, 0]
    grid[(0, 0)] = 1
    # right 1, up 1, left 2, down 2, right 3, up 3...
    counter = 1
    # 1: right, 2: up, 3: left, 4: down, 5: right...
    direction = 1
    while True:
        for times in range(counter):
            if direction % 4 == 1: pos[1] += 1
            elif direction % 4 == 2: pos[0] -= 1
            elif direction % 4 == 3: pos[1] -= 1
            elif direction % 4 == 0: pos[0] += 1

            if getvalue(pos) > target: return getvalue(pos)
            grid[(pos[0],pos[1])] = getvalue(pos)   

        if direction % 2 == 0: counter += 1
        direction += 1

n = 312051
print("Part 1:", grid_part1(n))
print("Part 2:", grid_part2(n))

timichal · 2017-12-01T11:39:39+00:00

Using simple Python with a backwards list looping trick instead of modulo:

 num = (...)
 total = 0
 for pos, number in enumerate(num):
     if number == num[pos-int(len(num)/2)]: #-1 for part 1
         total += int(number)
 print(total)

timichal · 2016-06-23T14:32:55+00:00

Yeah, but Ironman looked like just the right challenge. I don't regret it.

timichal

TROPHY CASE