Advent of Code 2020

pub fn part2(lines: &[String]) -> i64 {
    let (_, bus_lines) = parse(lines);
    let (timestamp, _) = bus_lines
        .iter()
        .fold((0, 1), |(timestamp, step), (offset, frequency)| {
            let mut timestamp = timestamp;
            while (timestamp + offset) % frequency != 0 {
                timestamp += step;
            }
            // The steps should be the L.C.M., but they are all primes
           (timestamp, step * frequency)
        });
    timestamp
}

import re

mem = re.compile(r'mem\[([0-9]+)\] = ([0-9]+)')
mask_re = re.compile(r'mask = ([01-X]+)')

def floating_bit(addrs, bit):
    addrs_ = []
    for addr in addrs:
        addrs_.append( addr ^ (1<<bit) )
    return addrs + addrs_

def return_addr(mask, addr):
    addr = [addr | int(mask.replace('X','0'), base=2)]
    for idx in [pos for pos, char in enumerate(mask[::-1]) if char == 'X']:
        addr = floating_bit(addr, idx)
    return addr

data = open('input.txt').readlines()

reg = {}

for inst in data:
    if inst.count('mem'):
        addr = int(re.match(mem, inst)[1])
        val = int(re.match(mem, inst)[2])
        for a in return_addr(mask, addr):
            reg[a] = val
    else:
        mask = re.match(mask_re, inst)[1]

print( sum([reg[k] for k in reg.keys()]) )

import re

def longbinary(number):    

    return '0'* (36-len(bin(number)[2:])) + bin(number)[2:]

def applymask(binary,mask):
    result=''
    for char in range(len(binary)):
        if mask[char]=='X':
            result+=binary[char]
        else:
            result+=mask[char]
    return result

def binary2base10(binary):
    return int(binary,2)

input=[x.replace('\n','') for x in open('C:/Users/z003kpaw/Desktop/input1.txt').readlines()]

memory={}
for row in input:
    if row[0:4]=='mask':
        currentmask=row[7:]
    else:
        key=int(re.findall(re.compile(r'[0-9]+'),row)[0])
        value= int(re.findall(re.compile(r'[0-9]+'),row)[1])
        memory[key] = binary2base10(applymask(longbinary(value),currentmask))
print(sum(memory.values()))

import re
from itertools import product

def longbinary(number):    #Takes int
    return '0'* (36-len(bin(number)[2:])) + bin(number)[2:]

def applymask(binary,mask): #Takes strings
    result=''
    for char in range(len(binary)):
        if mask[char]=='0':
            result+=binary[char]
        else:
            result+=mask[char]
    return result

def binary2base10(binary): #Takes string
    return int(binary,2)

def cartesian(s):

result=[]
keyletters = '01'
replace='X'

seq = list(s)
indices = [ i for i, c in enumerate(seq) if c in replace ]

for t in product(keyletters, repeat=len(indices)):
    for i, c in zip(indices, t):
        seq[i] = c
    result.append(''.join(seq))
    
return result

input=[x.replace('\n','') for x in open('C:/Users/z003kpaw/Desktop/input1.txt').readlines()]

memory={}
for row in input:
    if row[0:4]=='mask':
        currentmask=row[7:]
    else:
        value= int(re.findall(re.compile(r'[0-9]+'),row)[1])
        orig= int(re.findall(re.compile(r'[0-9]+'),row)[0])
        fatheraddress=applymask(longbinary(orig),currentmask)
        combinations=cartesian(fatheraddress)
        for comb in combinations:
            key=binary2base10(comb)
            memory[key] = value
            

print(sum(memory.values()))

edit: vale, no, no funciona
no se me ocurre nada, la verdad

import sys

def main(until):
  nums = list(map(int, input().split(',')))

  turns = {}

  for i, num in enumerate(nums):
    turns.setdefault(num, []).append(i + 1)

  last_num, num_count = nums[-1], len(nums)

  while num_count < until:
    new_num = \
      num_count - turns[last_num][-2] if len(turns[last_num]) > 1 else 0
    num_count += 1
    turns.setdefault(new_num, []).append(num_count)
    if len(turns[new_num]) > 2:
      turns[new_num] = turns[new_num][-2:]
    last_num = new_num

  print(last_num)


if __name__ == '__main__':
  main(int(sys.argv[1]))

number_list =[int(number) for number in open("input.txt").read().splitlines()[0].split(",")]
dict_of_indices = { number:[i] for i, number in enumerate(number_list)}

def add_number_to_dict(number_list, number, i):
    if not number in dict_of_indices.keys():
        dict_of_indices[number]=[]
    dict_of_indices[number].append(i)
    if len(dict_of_indices[number]) > 2:
        dict_of_indices[number].pop(0)

def compute_ith_value(stop_criteria):
    i = len(number_list)
    prev_value = number_list[i-1]
    while (i < stop_criteria):
        prev_indices = dict_of_indices[prev_value]
        prev_value = prev_indices[1] - prev_indices[0] if len(prev_indices) > 1 else 0
        add_number_to_dict(number_list, prev_value, i)
        i += 1
    return prev_value

stop_criteria = 2020
print("Part 1", compute_ith_value(stop_criteria))
dict_of_indices = {number:[i] for i, number in enumerate(number_list)}
stop_criteria = 30000000
print("Part 2", compute_ith_value(stop_criteria))