Advent of Code 2020

#Part 1

import re
import numpy as np
number_regex = re.compile(r'[0-9]+')
letter_regex= re.compile(r'[A-Z]+')
a=re.findall(letter_regex,open('./Advent/Day12.txt', 'r').read().strip())
b=[int(x) for x in re.findall(number_regex,open('./Advent/Day12.txt', 'r').read().strip())]

movdict = { 'N': np.array([0,1]) , 'E': np.array([1,0]), 'S': np.array([0,-1]), 'W': np.array([-1,0]) }
movlist = [x for x in movdict.keys()] * 3

pos=np.array([0,0])
facing='E'
for i in range(len(a)):
    if a[i] in movdict.keys():
        pos+= movdict[a[i]] * b[i]
    elif a[i] == 'F':
        pos+= movdict[facing] * b[i]
    elif a[i] == 'R':
        facing=movlist[movlist.index(facing) + int(b[i]/90)]
    elif a[i] == 'L':
        facing=movlist[movlist.index(facing) - int(b[i]/90)] 
        

print(sum(abs(pos)))

#Part 2

pos=np.array([0,0])
way=np.array([10,1])

for i in range(len(a)):
    if a[i] in movdict.keys():
        way+= movdict[a[i]] * b[i]       

    elif a[i] == 'F':
        pos+= way * b[i]
    elif a[i] == 'R':
        if b[i] == 90:
            way=np.array([way[1],-way[0]])
        elif b[i] == 180:
            way=np.array([-way[0],-way[1]])            

        elif b[i] == 270:
            way=np.array([-way[1],way[0]])             

    elif a[i] == 'L':
        if b[i] == 90:
            way=np.array([-way[1],way[0]])
        elif b[i] == 180:
            way=np.array([-way[0],-way[1]])            

        elif b[i] == 270:
            way=np.array([way[1],-way[0]])  

print(sum(abs(pos)))

type NavCode = (Char, Int)
type Pair = (Int, Int)
type State = (Pair, Pair)
type RotateF = Pair -> Pair -> NavCode -> State
type ForwardF = Pair -> Pair -> Int -> State

north = 'N'
east = 'E'
south = 'S'
west = 'W'
left = 'L'
right = 'R'
forward = 'F'


read_data :: FilePath -> IO [NavCode]
read_data fname = do
  contents <- readFile fname
  let parse [] = error "invalid input"
      parse (letter:number) = (letter, read number :: Int)
  return $ map parse $ lines contents


move :: State -> NavCode -> RotateF -> ForwardF -> State
move (p@(x, y), d@(dx, dy)) nc@(order, n) rotate_f forward_f
  | order == north = ((x, y + n), d)
  | order == east = ((x + n, y), d)
  | order == south = ((x, y - n), d)
  | order == west = ((x - n, y), d)
  | order == forward = forward_f p d n
  | otherwise = rotate_f p d nc


rotate :: Pair -> NavCode -> Pair
rotate (x, y) nc@(_, n)
  | n == 180 = (-x, -y)
  | nc == (right, 90) || nc == (left, 270) = (y, -x)
  | nc == (left, 90) || nc == (right, 270) = (-y, x)
  | otherwise = error $ "unknown navigation code: " ++ show nc


forward_p1 (x, y) d@(dx, dy) n = ((x + dx * n, y + dy * n), d)
forward_p2 wp@(x, y) (sx, sy) n = (wp, (sx + x * n, sy + y * n))

rotate_p1 pos direction code = (pos, rotate direction code)
rotate_p2 wp ship code = (rotate wp code, ship)


run :: State -> RotateF -> ForwardF -> [NavCode] -> State
run s _ _ [] = s
run s rf ff (x:xs) = run (move s x rf ff) rf ff xs


p1 fname = do
  codes <- read_data fname
  let (pos, _) = run ((0, 0), (1, 0)) rotate_p1 forward_p1 codes
  return $ (abs $ fst pos) + (abs $ snd pos)


p2 fname = do
  codes <- read_data fname
  let (_, ship) = run ((10, 1), (0, 0)) rotate_p2 forward_p2 codes
  return $ (abs $ fst ship) + (abs $ snd ship)

import re
import math


def rotate(x, y, degrees):
    return round(x * math.cos(math.radians(degrees)) - y * math.sin(math.radians(degrees)), 10), \
           round(x * math.sin(math.radians(degrees)) + y * math.cos(math.radians(degrees)), 10)


if __name__ == '__main__':

actions = {
    'N': lambda px, py, dx, dy, v: ((px, py + v), (dx, dy)),
    'S': lambda px, py, dx, dy, v: ((px, py - v), (dx, dy)),
    'E': lambda px, py, dx, dy, v: ((px + v, py), (dx, dy)),
    'W': lambda px, py, dx, dy, v: ((px - v, py), (dx, dy)),
    'R': lambda px, py, dx, dy, v: ((px, py), rotate(dx, dy, v)),
    'L': lambda px, py, dx, dy, v: ((px, py), rotate(dx, dy, v)),
    'F': lambda px, py, dx, dy, v: ((px + dx * v, py + dy * v), (dx, dy))
}

position = (0, 0)
direction = (1, 0)
parser = re.compile('([NSEWRLF])([0-9]+)')
with open('input', 'r') as f:
    for line in f.readlines():
        action, value = (v for v in parser.search(line).groups())
        position, direction = actions[action](*position, *direction, -int(value) if action == 'R' else int(value))
print(sum(abs(val) for val in position))

import re
import math


def rotate(x, y, degrees):
    return round(x * math.cos(math.radians(degrees)) - y * math.sin(math.radians(degrees)), 10), \
           round(x * math.sin(math.radians(degrees)) + y * math.cos(math.radians(degrees)), 10)


if __name__ == '__main__':

actions = {
    'N': lambda px, py, dx, dy, v: ((px, py), (dx, dy + v)),
    'S': lambda px, py, dx, dy, v: ((px, py), (dx, dy - v)),
    'E': lambda px, py, dx, dy, v: ((px, py), (dx + v, dy)),
    'W': lambda px, py, dx, dy, v: ((px, py), (dx - v, dy)),
    'R': lambda px, py, dx, dy, v: ((px, py), rotate(dx, dy, v)),
    'L': lambda px, py, dx, dy, v: ((px, py), rotate(dx, dy, v)),
    'F': lambda px, py, dx, dy, v: ((px + dx * v, py + dy * v), (dx, dy))
}

position = (0, 0)
direction = (10, 1)
parser = re.compile('([NSEWRLF])([0-9]+)')
with open('input', 'r') as f:
    for line in f.readlines():
        action, value = (v for v in parser.search(line).groups())
        position, direction = actions[action](*position, *direction, -int(value) if action == 'R' else int(value))
print(sum(abs(val) for val in position))

Yo lo he resuelto resolviendo el sistema de congruencias
x = t - i mod t
usando el chinese remainder theorem.

Que los modulos fueran primos me permitia calcular la inversa con k^p - 2, lo cual me daba a entender que no era mala solucion ir por ahi.
La cosa es que no se si porque iba sobado o le ponia poca atencion que no me acababa de funcionar, asi que lo he programado en matlab porque me resultaba mas facil hacerlo ahi porque lo de number theory lo llevo mejor, ahora lo hare en python a ver si veo el error.

from functools import reduce
min_t = int(input())
bus_schedule = input().split(',')
timestamps = [int(x) for x in bus_schedule if x != 'x']
indices = [i for i, x in enumerate(bus_schedule) if x != 'x']

# Part 1
for i in range(min_t, min_t + max(timestamps) + 1):
	l = [k for k in timestamps if i % k == 0]
	if l: print(l[0] * (i - min_t)); break

# Part 2
remainders = [t - i for t, i in zip(timestamps, indices)]
N = reduce(int.__mul__, timestamps)
y = [N // t for t in timestamps]
z = [pow(r, t - 2, t) for r, t in zip(y, timestamps)]
print(sum([ri * yi * zi for ri, yi, zi in zip(remainders, y, z)]) % N)

import re
import numpy as np
all=[int(x) for x in re.findall(re.compile(r'[0-9]+'),open('./Advent/Day13.txt', 'r').read().strip())]
for number in range ( all[0], all[0]+min(all)):
    for bus in all[1:]:
        if number % bus == 0:
            print( (number-all[0]) * bus)

def solutionpair(time, input1, input2, delta2): 
    while time>-1:
        if (time+delta2) % input2 == 0:
            return time
            break
        time+=input1

input=[l.strip() for l in open('./Advent/Day13.txt').readlines()][1]
input=np.array( [int(x) for x in input.replace('x','0').split(',')] )
deltas=np.arange(0,len(input))[input>0]
input=input[input>0]

first=0
input1=input[0]
for i in range(1,len(input)): 
    first=solutionpair(first,input1,input[i],deltas[i])
    input1=input1*np.float64(input[i])
print(first)