def main():
tree = load_input('input.txt')[0].split()
tree = [int(q) for q in tree]
part1, part2 = treeverse(tree)
print('Part 1:', part1)
print('Part 2:', part2)
def test_cutdown_drinks(self):
data = utils.load_input('./input/users.json')
# check if every letter is lowercase
for drink in data[0]['drinks']:
for c in drink:
# cheeky ignore spaces
if c != ' ':
self.assertEqual(c.islower(), True)
def main():
# Get the number of players, and the (base) highest marble0
players, _, _, _, _, _, base_highest_marble, _ = load_input(
'input.txt')[0].split()
# convert to integers
players = int(players)
base_highest_marble = int(base_highest_marble)
print('Part 1', winning_score(players, base_highest_marble))
print('Part 2', winning_score(players, base_highest_marble * 100))
def main():
board = load_input('input.txt')
k = 3
while True:
all_elves_survived, outcome = simulation(board, k)
if k == 3:
print('Part 1:', outcome)
elif all_elves_survived:
# this is the first attack damage for which all elves survived
print('Part 2:', outcome)
break
k += 1
def main():
"""
Barebones, I would like to add proper inputs etc,
"""
# load input files
venues = utils.load_input('./input/venues.json')
users = utils.load_input('./input/users.json')
# input for further down
parsed_acceptable_venues, parsed_unacceptable_venues = _parse_venues(
venues, users)
# find un/acceptable venues
acceptable_venues = _find_acceptable_venues(parsed_acceptable_venues,
parsed_unacceptable_venues)
# output acceptable events
_output_acceptable_venues(acceptable_venues)
# output unacceptable events
_output_unacceptable_venues(parsed_unacceptable_venues)
def main():
# get the list of step orderings
key = int(load_input('input.txt')[0])
# get the 10 recipes after our puzzle input
recipes = get_recipes(key + 10)
print('Part 1:', ''.join(mapstr(recipes[key:key + 10])))
# we keep generating recipes until our key appears
recipes = get_recipes(25000000)
# find the first place the key occurs in our recipe list
print('Part 2:', ''.join(mapstr(recipes)).find(str(key)))
def main():
# get the list of step orderings
track = load_input('input.txt')
board = defaultdict(int)
carts = {}
k = 0
for (y, line) in enumerate(track):
for (x, c) in enumerate(line):
b = None
if c == '|':
b = 1
if c == '-':
b = 2
if c == '/':
b = 3
if c == '\\':
b = 4
if c == '+':
b = 5
if c == '^':
carts[(x, y)] = ['N', 0, k]
b = 1
k += 1
if c == 'v':
carts[(x, y)] = ['S', 0, k]
b = 1
k += 1
if c == '>':
carts[(x, y)] = ['E', 0, k]
b = 2
k += 1
if c == '<':
carts[(x, y)] = ['W', 0, k]
b = 2
k += 1
if b is not None:
board[(x, y)] = b
has_crashed = False
while True:
carts, deleted_keys = tick(board, carts)
# when the first crash occurs, we obtain our solution to part 1
if not has_crashed and len(deleted_keys) > 0:
has_crashed = True
print("Part 1:", deleted_keys[0])
# when only one cart remains, we have our solution to part 2
if len(carts) == 1:
print("Part 2:", list(carts.keys())[0])
break
def main():
puzzle_input = load_input('input.txt')
_, pts = simulate(puzzle_input, 0)
print('Part 1:', pts)
# look for the smallest boost where the immune system outright wins
boost = 0
while True:
winner, c = simulate(puzzle_input, boost)
if winner == 'immune':
print('Part 2:', c)
break
boost += 1
def main():
land = defaultdict(int)
for (y, line) in enumerate(load_input('input.txt')):
for (x, char) in enumerate(line):
if char == '.':
w = 0
elif char == '|':
w = 1
elif char == '#':
w = 2
land[(x, y)] = w
print('Part 1:', simulate(land, 10))
print('Part 2:', simulate(land, 1000000000))
def main():
# get the list of step orderings
serial_number = int(load_input('input.txt')[0])
sat = summed_area_table(serial_number)
# for part 2
max_pos = None
max_power = None
max_size = None
for size in range(3, 300):
x, y, power = max_power_level(size, sat)
if size == 3:
print(f"Part 1: {x}, {y}, Power: {power}")
if max_power is None or power > max_power:
max_power = power
max_pos = (x, y)
max_size = size
print(f"Part 2: {max_pos[0]}, {max_pos[1]}, Size: {max_size}")
def main():
# get the list of step orderings
points = load_input('input.txt')
positions = {}
position_set = set()
velocities = {}
# extract the four digits out of each input line
for (k, line) in enumerate(points):
x, y, xv, yv = get_numbers(line)
positions[k] = (x, y)
position_set.add((x, y))
velocities[k] = (xv, yv)
m = 0
while True:
ymin = min(t[1] for t in position_set)
ymax = max(t[1] for t in position_set)
ht = abs(ymax - ymin)
# the lights align perfectly when the height is 9
# its unclear if this always achieves the correct result
if ht == 9:
xmin = min(t[0] for t in position_set)
xmax = max(t[0] for t in position_set)
print_blocks(position_set, xmin, xmax, ymin, ymax)
break
# move the lights by their velocities
# updating the set of positions
position_set = set()
for idx in positions:
positions[idx] = (positions[idx][0] + velocities[idx][0],
positions[idx][1] + velocities[idx][1])
position_set.add(positions[idx])
m += 1
return m
def main():
door = map_doors((0, 0), load_input('input.txt')[0])
rooms = {}
# link up each of the rooms
for start, end in door:
if start not in rooms:
rooms[start] = Room(start)
if end not in rooms:
rooms[end] = Room(end)
rooms[start].add_neighbour(rooms[end])
rooms[end].add_neighbour(rooms[start])
# compute the shortest distance from (0,0) to every room
distances = {(0, 0): 0}
to_process = set([rooms[(0, 0)]])
while len(to_process) > 0:
room = to_process.pop()
for adjacent_room in room.neighbours:
if adjacent_room.pos not in distances:
distances[adjacent_room.pos] = distances[room.pos] + 1
to_process.add(adjacent_room)
else:
if distances[room.pos] + 1 < distances[adjacent_room.pos]:
distances[adjacent_room.pos] = distances[room.pos] + 1
to_process.add(adjacent_room)
c = 0
for pos in distances:
# count the number of points that are at least a distance 1000 away
if distances[pos] >= 1000:
c += 1
m = max(distances, key=distances.get)
print('Part 1:', distances[m])
print('Part 2:', c)
def main():
# get the list of step orderings
steps = load_input('input.txt')
# write down the graph
mapped_to = defaultdict(list)
keys = set()
for line in steps:
x = line.split()
# step a must be finished before step b
a = x[1]
b = x[7]
# add the keys
keys.add(a)
keys.add(b)
# a is mapped to b
mapped_to[b].append(a)
print('Part 1:', part1(keys.copy(), mapped_to.copy()))
print('Part 2:', part2(keys.copy(), mapped_to.copy()))
def main():
lines = load_input('https://pastebin.com/raw/ebDxSugK')
print(part_one(lines))
print(part_two(lines))
from utils import load_input, get_numbers, manhattan_distance
import numpy as np
def triangular(n):
return n*(n+1) // 2
v = {}
a = {}
p = {}
for (k,line) in enumerate(load_input('puzzle_inputs/Day20.txt')):
px,py,pz,vx,vy,vz,ax,ay,az = get_numbers(line)
v[k] = (vx,vy,vz)
a[k] = (ax,ay,az)
p[k] = (px,py,pz)
v = np.array(list(v.values()), dtype='int64')
a = np.array(list(a.values()), dtype='int64')
p = np.array(list(p.values()), dtype='int64')
# part 1
# a closed for for the position after t steps is
# p_i(t) = p_i(0) + t * v_i + triangular(t) * a_i
large_number = 500000000
d = p+large_number*v + triangular(large_number)*a
print('Part 1:', min(enumerate(d),key=lambda q:manhattan_distance(q[1],(0,0,0)))[0])
def test_cutdown_user_wont_eat(self):
data = utils.load_input('./input/users.json')
self.assertEqual(data[0]['wont_eat'][0], 'fish')
def test_raises_file_not_found(self):
with self.assertRaises(FileNotFoundError) as context:
utils.load_input('foo.json')
def test_cutdown_venues_food(self):
data = utils.load_input('./input/venues.json')
self.assertEqual(data[0]['food'][0], 'mexican')
points_in_constellation = set()
points_remaining = set(points)
# basically we pick a point that isn't in a constellation, and then keep working
# away from that point until we've found the entire constellation
while True:
# no more points remaining!
if len(points_remaining) == 0:
break
p = points_remaining.pop()
to_process = set([p])
points_in_constellation.add(p)
while len(to_process) > 0:
p = to_process.pop()
# get all the points that are within a distance of 3 of our current processing points
qs = {q for q in points_remaining if distances[p][q] <= 3}
points_remaining = points_remaining.difference(qs)
points_in_constellation = points_in_constellation.union(qs)
to_process = to_process.union(qs)
constellations += 1
return constellations
if __name__ == '__main__':
print('Part 1:', main(load_input('input.txt')))
return []
if idx + length < len(li):
return li[:idx] + li[idx:idx+length][::-1] + li[idx+length:]
else:
# have some overflow
overflow = length - (len(li) - idx)
sublist = (li[idx:] + li[:overflow])[::-1]
return sublist[len(li)-idx:] + li[overflow:idx] + sublist[:len(li)-idx]
if __name__ == '__main__':
numbers = list(range(256))
current_position = 0
skip_size = 0
lengths = get_numbers(load_input('puzzle_inputs/Day10.txt')[0])
for length in lengths:
numbers = wrap_reverse(numbers, current_position % len(numbers), length)
current_position += length + skip_size
skip_size += 1
print('Part 1:', numbers[0] * numbers[1])
# PART 2
lengths = [ord(c) for c in load_input('puzzle_inputs/Day10.txt')[0]]
lengths.extend([17, 31, 73, 47, 23])
current_position = 0
skip_size = 0
numbers = list(range(256))
def main():
lines = load_input('https://pastebin.com/raw/VdZiDjRn')
guards, ans = part_one(lines)
print(part_two(guards))
Where the serial port is. Should be in the form of /dev/cu.usbmodem1431
or similar
""")
args = parser.parse_args()
room_in = args.room
loc = args.location
serial_port = args.serial
## Serial and Logging Stufff
ser = serial.Serial(serial_port, 9600)
logging.basicConfig(filename='arudino_recorder.log',level=logging.DEBUG)
while True:
try:
load_input(parse_input(ser.readline()),room_in,loc)
except serial.serialutil.SerialException:
logging.warning("Arudino Failed to Report Data")
pass
except IndexError:
logging.warning("Bad Input Error")
pass
except sqlalchemy.exc.DataError:
logging.warning("SQL Alchemy Error")
pass
except KeyboardInterrupt:
print "You have quit the program. It will now exit. Goodbye"
sys.exit()
except:
print sys.exc_info()[0]
logging.info(sys.exc_info()[0])
from utils import load_input
from cartesian import left, right, up, down
def b(pos):
if pos[1] < 0 or pos[1] >= len(
puzzle_input) or pos[0] < 0 or pos[0] >= len(puzzle_input[pos[1]]):
return ' '
return puzzle_input[pos[1]][pos[0]]
puzzle_input = load_input('puzzle_inputs/Day19.txt')
pos = (puzzle_input[0].index('|'), 0)
direction = down
word = ''
steps = 1
while True:
# if we're on a letter, add it to our word
if b(pos).isalpha():
word += b(pos)
dpos = direction(pos)
# if we're ok to move in our current direction, then do so
if b(dpos) != ' ':
pos = direction(pos)
steps += 1
else:
# otherwise, change directions
def load_data(self, debug=False):
"""Loads train/valid/test data"""
self.train, self.word_embedding, self.max_sen_len, self.input_vocab_size, self.vocab, self.ivocab = utils.load_input(
self.config)
print '---> Config Vocab Size is ..', self.config.vocab_size
print '---> Config Hidden Layer Size is ..', self.config.hidden_size
print '---> Config Word Vector Size is ..', self.config.embed_size
print '---> Input Vocab Size is ..', self.input_vocab_size
def main():
lines = load_input('https://pastebin.com/raw/HSnu5ViM')
print(part_one(lines))
print(part_two(lines))
def part_two(string):
lets = 'qwertyuiopasdfghjklzxcvbnm'
small = 99999999
for l in lets:
curr = part_one(string.replace(l, '').replace(l.upper(), ''), combos())
if curr < small:
small = curr
return small
def combos():
combs = set()
lets = 'qwertyuiopasdfghjklzxcvbnm'
for l in lets:
combs.add(f'{l}{l.upper()}')
for l in lets.upper():
combs.add(f'{l}{l.lower()}')
return combs
string = load_input('https://pastebin.com/raw/TpG550mX', as_string=True)
combs = combos()
print(timeit.timeit('part_one(string, combs)', globals=globals(), number=1000))
# if __name__ == '__main__':
# main()
from utils import load_input, get_numbers, manhattan_distance
class Nanobot:
def __init__(self, _x, _y, _z, _r):
self.x = _x
self.y = _y
self.z = _z
self.r = _r
def __repr__(self):
return str((self.x, self.y, self.z, self.r))
puzzle_input = load_input('input.txt')
nanobots = []
for line in puzzle_input:
x, y, z, r = get_numbers(line)
nanobots.append(Nanobot(x, y, z, r))
nanobots.sort(key=lambda q: q.r, reverse=True)
# PART 1
r = nanobots[0]
nanobots_in_range = 0
for bot in nanobots:
if manhattan_distance((r.x, r.y, r.z), (bot.x, bot.y, bot.z)) <= r.r:
nanobots_in_range += 1
def main():
# process the input into a list of integers
differences = [int(q) for q in load_input('input.txt')]
print('Part 1:', part1(differences))
print('Part 2:', part2(differences))
def main():
initial_polymer = load_input('input.txt')[0]
print('Part 1:', part1(initial_polymer))
print('Part 2:', part2(initial_polymer))
from utils import load_input
from collections import defaultdict
from cartesian import left, right, up, down, turn_left, turn_right
grid = defaultdict(int)
puzzle_input = load_input('puzzle_inputs/Day22.txt')
for (y, line) in enumerate(puzzle_input):
for (x, char) in enumerate(line):
if char == '#':
grid[(x, y)] = 1
# initially start at the centre of our input, facing up
pos = (len(puzzle_input) // 2, len(puzzle_input) // 2)
direction = up
burst = 0
infections = 0
while burst < 10000:
x, y = pos
if grid[(x, y)] == 1:
direction = turn_right(direction)
else:
infections += 1
direction = turn_left(direction)
grid[(x, y)] = 1 - grid[(x, y)]
pos = direction(pos)
burst += 1
print('Part 1:', infections)
def main():
operations = [addr, addi, mulr, muli, banr, bani, borr, bori, setr, seti, gtir, gtri, gtrr, eqir, eqri, eqrr]
puzzle = load_input('input.txt')
before = None
instruction = None
part1_count = 0
possible_int = {}
for (k,line) in enumerate(puzzle):
if k % 4 == 0:
before = get_numbers(line)
if k % 4 == 1:
instruction = get_numbers(line)
if k % 4 == 2:
after = get_numbers(line)
opcode = instruction[0]
# get the operations that this instruction could correspond to
possible = check(before,after,instruction[1:], operations)
# count the number of samples that behave like three or more opcodes
if len(possible) >= 3:
part1_count += 1
# we keep intersecting the list of possible operations based on the result of each input
if opcode not in possible_int:
possible_int[opcode] = possible
else:
possible_int[opcode] = intersection(possible_int[opcode],possible)
# for part 1, count how many sample in our input behave like three or more opcodes
print('Part 1:', part1_count)
secured = []
# for part 2, we need to figure out which opcode corresponds to which operation
# at each stage, there is always (at least) one opcode that we can deduce
while len(secured) < 15:
for key in possible_int:
# if we've already figured this one out, skip it
if key in secured:
continue
# if there's only 1 possibility for what this opcode could be, then we're done!
if len(possible_int[key]) == 1:
secured.append(key)
new_possible_int = possible_int.copy()
# remove this operation as a possibility for all other opcodes
for k in possible_int:
if k == key:
continue
if possible_int[key][0] in new_possible_int[k]:
new_possible_int[k].remove(possible_int[key][0])
possible_int = new_possible_int
break
# apply the operations to our puzzle input
registers = [0,0,0,0]
for line in load_input('input2.txt'):
op, a, b, c = get_numbers(line)
registers = operations[possible_int[op][0]](registers,a,b,c)
print('Part 2:', registers[0])
