Advent of Code 2020

import sys

class Node(object):
  def __init__(self, value):
    self.value = value
    self.prev_in_list, self.next_in_list, self.prev_in_val = None, None, None

  def __eq__(self, other):
    return self.value == other.value

  def __str__(self):
    return str(self.value)

  def __hash__(self):
    return self.value



def move(start_point):
  current_cup = start_point
  picked_cups = \
    [
      start_point.next_in_list,
      start_point.next_in_list.next_in_list,
      start_point.next_in_list.next_in_list.next_in_list
    ]

  next_to_picked = picked_cups[-1].next_in_list
  prev_cup = current_cup.prev_in_val
  while prev_cup in picked_cups:
    prev_cup = prev_cup.prev_in_val

  current_cup.next_in_list = next_to_picked
  next_to_picked.prev_in_list = current_cup

  next_to_prev = prev_cup.next_in_list

  prev_cup.next_in_list = picked_cups[0]
  picked_cups[0].prev_in_list = prev_cup

  next_to_prev.prev_in_list = picked_cups[-1]
  picked_cups[-1].next_in_list = next_to_prev


  return next_to_picked

def print_ring(start_point, list_len):
  root = start_point
  list_to_print = []
  for _ in range(list_len):
    list_to_print.append(root.value)
    root = root.next_in_list
  print(list_to_print)

cups = [x for x in map(int, [x for x in open(sys.argv[1], 'r').readline().strip()])]
if sys.argv[2] == '2':
  cups += list(range(len(cups) + 1, 1000001))

nodes = [Node(c) for c in cups]

nodes_with_val = {v.value: i for (i, v) in enumerate(nodes)}

for i in range(len(nodes)):
  prev_ind = (i - 1) % len(nodes)
  next_ind = (i + 1) % len(nodes)
  prev_val = ((nodes[i].value - 2) % len(nodes)) + 1
  nodes[i].prev_in_list = nodes[prev_ind]
  nodes[i].next_in_list = nodes[next_ind]
  nodes[i].prev_in_val = nodes[nodes_with_val[prev_val]]

start_point = nodes[0]

if sys.argv[2] == '1':
  print_ring(start_point, len(nodes))

for _ in range(10 if sys.argv[2] == '1' else 10000000):
  start_point = move(start_point)

if sys.argv[2] == '1':
  print_ring(start_point, len(nodes))

node_with_1 = nodes[nodes_with_val[1]]

print(node_with_1.next_in_list.value * node_with_1.next_in_list.next_in_list.value)

def get_dest(current_cup, pick_up, this_dict):
    guess = current_cup-1
    while guess > 0:
        if guess in pick_up:
            guess -= 1
        else:
            return guess
    current_max = max(this_dict.keys())
    removed_max = []
    while (current_max in pick_up):
        removed_max.append([current_max, this_dict[current_max]])
        this_dict.pop(current_max)
        current_max = max(this_dict.keys())
    for key, value in removed_max:
        this_dict[key] = value
    return current_max

def play(line, moves):
    dict_line = {cup:next_cup for cup, next_cup in zip(line, line[1:])}
    dict_line[line[-1]] = line[0]
    current_cup = line[0]
    for move in range(1, moves + 1):
        if move % 1000000 == 0:
            print("Current move", move)
        next_cup = current_cup
        pick_up = []
        for x in range(pick_up_range):
            cup_to_pick = next_cup
            next_cup = dict_line[cup_to_pick]
            pick_up.append(next_cup)
        last_pick_up_pointer = dict_line[pick_up[-1]]
        dict_line[current_cup] = last_pick_up_pointer
        destination =  get_dest(current_cup, pick_up, dict_line)
        destination_pointer = dict_line[destination]
        dict_line[destination] = pick_up[0]
        dict_line[pick_up[-1]] = destination_pointer
        current_cup = dict_line[current_cup]
    return dict_line


line = '459672813'

line = [int(char) for char in line]
pick_up_range = 3
moves = 100
dict_line_1 = play(line, moves)
line_1 = [1]
for x in range(len(dict_line_1.keys())):
    new_cup = dict_line_1[line_1[-1]]
    line_1.append(new_cup)
line_1=line_1[:-1]
one_index = line_1.index(1)
solution = [str(char) for char in line_1[one_index+1:]]
solution.extend([str(char) for char in line_1[:one_index]])
print("Part 1", "".join(solution))

max_cup = 1000000
line.extend(i for i in range(10, max_cup+1))
moves = 10000000
dict_line_2 = play(line, moves)
first = dict_line_2[1]
second = dict_line_2[first]
print("Part 2", first*second)

He hecho submit de la solucion yendo a saco como #880, porque checkeando solo de los vecinos me daba mal. Al final resulta que era un bug tonto :D, así que dejo aquí la versión checkeando solo vecinos como #879.

from collections import defaultdict
import copy
def process_tiles(line):
    ref_tile = [0.0, 0.0]
    i=0
    while (i < len(line)):
        if line[i] == "e":
            ref_tile[0] += 1.0
            i += 1
        elif line[i] == "s":
            ref_tile[1] += -0.5
            if line[i+1] == "e":
                ref_tile[0] += 0.5
                i += 2
            elif line[i+1] == "w":
                ref_tile[0] += -0.5
                i += 2
        elif line[i] == "w":
            ref_tile[0] += -1.0
            i += 1
        elif line[i] == "n":
            ref_tile[1] += 0.5
            if line[i+1] == "w":
                ref_tile[0] += -0.5
                i += 2
            elif line[i+1] == "e":
                ref_tile[0] += 0.5
                i += 2
    return ref_tile

def count_black(tiles_color):
    return len([value for value in tiles_color.values() if value == "B"])

def get_delta_list():
        return [
        [1.0 , 0.0],
        [-1.0 , 0.0],
        [0.5, 0.5],
        [0.5, -0.5],
        [-0.5, 0.5],
        [-0.5, -0.5]
    ]

def get_neigh_coord_list(tiles_color, tile_coord):
    ref_tile = list(tile_coord)
    neighbouring_list = get_delta_list()
    return [[ref_tile[0]+neighbour[0], ref_tile[1]+neighbour[1]] for neighbour in neighbouring_list]

def check_tile(dict_to_edit, ref_dict, tile_coord):
    if tile_coord in checked_tiles:
        return dict_to_edit, []
    neigh_coord_list = get_neigh_coord_list(ref_dict, tile_coord)
    neigh_color_list = [ref_dict[tuple(coords)] for coords in neigh_coord_list]
    b_len = len([neigh for neigh in neigh_color_list if neigh=="B"])
    if ref_dict[tile_coord] == "B":
        if not b_len in [1,2]:
            dict_to_edit[tile_coord] = "W"
    else:
        if b_len == 2:
            dict_to_edit[tile_coord] = "B"
    checked_tiles.add(tile_coord)
    return dict_to_edit, [neigh_coord for neigh_coord in neigh_coord_list if not tuple(neigh_coord) in checked_tiles]

# e, se, sw, w, nw, and ne
lines_list = open("input.txt").read().splitlines()
tiles_color = defaultdict(lambda: "W")
flip = {
    "W" : "B",
    "B" : "W"
}
for line in lines_list:
    flip_tile = tuple(coord for coord in process_tiles(line))
    tiles_color[flip_tile] = flip[tiles_color[flip_tile]]
print("Part 1", count_black(tiles_color))

def check_neighbours(this_tile_dict, aux_dict, neighbour_list):
    new_neigh_list = []
    for neigh_coord in neighbour_list:
        this_tile_dict, neigh_coord_list = check_tile(this_tile_dict, aux_dict, tuple(neigh_coord))
        new_neigh_list.extend(neigh_coord_list)
    return this_tile_dict, new_neigh_list

days = 100

for day in range(days):
    checked_tiles = set()
    this_tile_dict = copy.deepcopy(tiles_color)
    neighbour_list = []
    aux_dict = copy.deepcopy(tiles_color)
    for tile_coord, color in tiles_color.items():
        this_tile_dict, neigh_coord_list = check_tile(this_tile_dict, aux_dict, tile_coord)
        neighbour_list.extend([coord for coord in neigh_coord_list if not tuple(coord) in checked_tiles])
    all_white = False
    while(not all_white):
        this_tile_dict, neighbour_list = check_neighbours(this_tile_dict, aux_dict, neighbour_list)
        all_white = True
        for neigh in neighbour_list:
            if tiles_color[tuple(neigh)] == "B":
                all_white = False

tiles_color = copy.deepcopy(this_tile_dict)
print("Day", day+1, count_black(tiles_color))
print("Part 2", count_black(tiles_color))

import sys
from itertools import dropwhile, count

p1, p2 = map(int, [x.strip() for x in open(sys.argv[1], 'r').readlines()])
l = next(dropwhile(lambda x: pow(7, x, 20201227) != p1, count()))
print(pow(p2, l, 20201227))