def __init__(self, filename):
self.lines = readInput(filename)
self.wrong = ["(]", "(}", "(>", "[)", "[}", "[>",
"{)", "{]", "{>", "<)", "<]", "<}"]
self.good = ["()", "[]", "{}", "<>"]
self.counter = [0, 0, 0, 0]
self.scores = []
def __init__(self, filename):
lines = readInput(filename)
self.m = {}
self.xlim = len(lines[0])
self.ylim = len(lines)
for y in range(len(lines)):
for x in range(len(lines[0])):
self.m[x, y] = Octopus(int(lines[y][x]))
self.flashes = 0
def __init__(self, filename):
vents = readInput(filename)
self.segs = []
for v in vents:
v = v.split(" -> ")
self.segs.append(
Line(Coord(*map(int, v[0].split(","))),
Coord(*map(int, v[1].split(",")))))
lim = self.findMax()
self.field = np.zeros(shape=(lim + 1, lim + 1))
from utils import readInput
lines = readInput("input_19.txt", True)
dir = (0, 1)
for y, l in enumerate(lines):
x = l.find("|")
if x != -1:
start = (x, y)
break
phrase = ""
count = 0
while True:
start = (start[0] + dir[0], start[1] + dir[1])
count += 1
char = lines[start[1]][start[0]]
if 65 <= ord(char) <= 90:
phrase += char
elif char == "+":
if dir[0] == 0:
if start[0] + 1 < len(lines[start[1]]) - 1 and lines[start[1]][
start[0] + 1] != " ":
dir = (1, 0)
elif start[0] - 1 >= 0 and lines[start[1]][start[0] - 1] != " ":
dir = (-1, 0)
else:
break
else:
if start[1] + 1 < len(lines) - 1 and lines[start[1] +
1][start[0]] != " ":
from utils import readInput
from collections import Counter
lines = readInput("input_6.txt")
words = ["" for _ in range(len(lines[0]))]
for l in lines:
for i in range(len(l)):
words[i] += l[i]
msg = ""
for i in range(len(words)):
d = Counter(words[i])
#print (d)
msg += max(d, key=d.get)
print ("🎄Part 1: {}".format(msg))
def __init__(self, filename):
lines = readInput(filename)
self.cm = np.zeros(shape=(len(lines[0]), len(lines)))
for i, l in enumerate(lines):
m = [int(c) for c in l]
self.cm[:, i] = np.array(m)
from utils import readInput
def search(s, idx=0, length=0):
while idx < len(s):
if s[idx] == "(":
parc = s[idx:].find(")")
decompression = list(map(int, s[idx + 1:idx + parc].split("x")))
if "(" in s[idx + parc + 1:idx + parc + 1 + decompression[0]]:
l = search(s[idx + parc + 1:idx + parc + 1 + decompression[0]],
0, 0)
length += l * decompression[1]
else:
length += decompression[0] * decompression[1]
idx += parc + decompression[0] + 1
else:
idx += 1
length += 1
return length
lines = readInput("input_9.txt")
p = search(lines[0])
print("�🎄Part 2: {}".format(p))
from utils import readInput
import numpy as np
vents = readInput("input_5.txt")
vent_coords = []
for v in vents:
v = v.split(" -> ")
c1 = list(map(int, v[0].split(",")))
c2 = list(map(int, v[1].split(",")))
if (c1[0] < c2[0]):
vent_coords.append([c1, c2])
else:
vent_coords.append([c2, c1])
xmin = min(min([v[0][0] for v in vent_coords], [v[1][0] for v in vent_coords]))
xmax = max(max([v[0][0] for v in vent_coords], [v[1][0] for v in vent_coords]))
ymin = min(min([v[0][1] for v in vent_coords], [v[1][1] for v in vent_coords]))
ymax = max(max([v[0][1] for v in vent_coords], [v[1][1] for v in vent_coords]))
lim = max(xmax, ymax)
vent_map = np.zeros(shape=(lim + 1, lim + 1))
n = 0
for c1, c2 in vent_coords:
if c1[0] == c2[0]:
dx = 0
else:
dx = 1
from utils import readInput
#lines = readInput("input_4.txt")
lines = readInput("test.txt")
#print ("🎁🎄Part 2: {}".format())
from utils import readInput, printMap
import numpy as np
from matplotlib import pyplot as plt
filename = "input_13.txt"
points = []
foldings = []
lines = readInput(filename)
for l in lines:
if l.strip() == "":
continue
if "," in l:
points.append(list(map(int, l.split(","))))
elif "y" in l:
foldings.append(("y", int(l.split("=")[-1])))
elif "x" in l:
foldings.append(("x", int(l.split("=")[-1])))
xmax = max([x[0] for x in points])+1
ymax = max([x[1] for x in points])+1
cm = np.zeros(shape=(xmax, ymax))
for p in points:
cm[p[0], p[1]] = 1
#printMap(cm)
for i, f in enumerate(foldings):
if f[0] == "y":
new_cm = cm[:, :f[1]]
temp = np.flip(cm[:, f[1]+1:], 1)
if t == "oxy":
if counts >= thrs:
res = "1"
else:
res = "0"
elif t == "co2":
if counts >= thrs:
res = "0"
else:
res = "1"
rating += res
tmp_tmp_lines = [l for l in tmp_lines if l[col] == res]
tmp_lines = tmp_tmp_lines
col += 1
else:
if len(rating) != len(lines[0]):
rating += tmp_lines[0][len(rating):]
return rating
import time
tstart = time.time()
lines = readInput("input_3.txt")
oxygen = ratingCalc(lines, "oxy")
scrubber = ratingCalc(lines, "co2")
res = int(scrubber, 2) * int(oxygen, 2)
print("🎄🎅 Part 2: ", res)
print(time.time() - tstart)
if args[0] == 'x' and val == -1:
x = v[args[0]]
if x >= 1 and x <= 9:
v['w'] = x
inputs[digit - 1] = x
val = x
else:
return v, inputs
v[args[0]] = 1 if v[args[0]] == val else 0
else:
raise Exception(f'Unknown cmd {cmd}')
return v, inputs
prog = readInput('input_24.txt')
for i in product(range(9, 0, -1), repeat=7):
full_input = [i[0], i[1], i[2], i[3], -1, -1, i[4], -1, i[5], -1, i[6], -1, -1, -1]
res, inp = ALU(prog, full_input)
if res['z'] == 0 and -1 not in inp:
print ("🎄 Part 1: {}".format("".join([str(i) for i in inp])))
break
for i in product(range(1, 10), repeat=7):
full_input = [i[0], i[1], i[2], i[3], -1, -1, i[4], -1, i[5], -1, i[6], -1, -1, -1]
res, inp = ALU(prog, full_input)
if res['z'] == 0 and -1 not in inp:
print ("🎄🎅 Part 2: {}".format("".join([str(i) for i in inp])))
import re
def lookAba(s):
a = []
for i in range(len(s) - 2):
if s[i] == s[i + 2] and s[i] != s[i + 1]:
a.append(s[i:i + 3])
if a == []:
return None
else:
return a
r = re.compile(r"\w+")
lines = readInput("input_7.txt")
ipv7 = []
for l in lines:
matches = r.findall(l)
if matches:
hasAba = []
for im in range(0, len(matches), 2):
aba = lookAba(matches[im])
if aba is not None:
hasAba += aba
if len(hasAba) > 0:
hasBab = 0
for aba in hasAba:
bab = aba[1] + aba[0] + aba[1]
for im in range(1, len(matches), 2):
return []
paths = []
for vertex in graph[start]:
insert = False
if (vertex == cave and path.count(cave) < 2):
insert = True
if (vertex == vertex.lower() and vertex not in path):
insert = True
elif vertex != vertex.lower():
insert = True
if insert:
extended_paths = self.find_all_paths2(cave, vertex, end, path)
for p in extended_paths:
paths.append(p)
return paths
g = Graph()
edges = readInput("input_12.txt")
for edge in edges:
e = edge.split("-")
g.add_edge(e)
paths = g.find_all_paths("start", "end")
#print (p)
print ("🎄 Part 1: {}".format(len(paths)))
paths = g.find_special_paths("start", "end")
print ("🎄🎅 Part 2: {}".format(len(paths)))
from keras.layers.normalization import BatchNormalization
from keras.models import Model, Sequential
from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
from keras.preprocessing.image import ImageDataGenerator
from keras.applications.vgg16 import VGG16
from sklearn.model_selection import train_test_split
from utils import readInput, plotLoss, plotAccuracy, plotConfusionMatrix
import pickle
# (0=Angry, 1=Disgust, 2=Fear, 3=Happy, 4=Sad, 5=Surprise, 6=Neutral).
class_labels = [
'Angry', 'Disgust', 'Fear', 'Happy', 'Sad', 'Surprise', 'Neutral'
]
#### read input
x_total, y_total = readInput()
num_classes = np.shape(y_total)[1]
input_shape = (48, 48, 1)
#### normalize input feature to range -1..1
x_total = ((x_total / 255.0) - 0.5) * 2.0
#### IMPORTANT: VGG16 requires RGB input -> convert them
gray = np.reshape(x_total, (-1, 48, 48))
x_total = np.stack((gray, ) * 3, axis=-1)
### split train/valid/test data
x_train, x_test, y_train, y_test = train_test_split(x_total,
y_total,
test_size=0.2,
stratify=y_total,
class Particle:
def __init__(self, i, p, v, a):
self.n = i
self.p = np.array(p)
self.a = np.array(a)
self.v = np.array(v)
def move(self):
self.v += self.a
self.p += self.v
def distance(self):
return abs(self.p[0]) + abs(self.p[1]) + abs(self.p[2])
lines = readInput("input_20.txt")
particles = []
for i, l in enumerate(lines):
parts = l.split(">,")
p = list(map(int, parts[0][3:].split(",")))
v = list(map(int, parts[1][4:].split(",")))
a = list(map(int, parts[2][4:-1].split(",")))
particles.append(Particle(i, p, v, a))
min_dist = None
for t in range(1000):
for p in particles:
p.move()
min_dist = min([p.distance() for p in particles])
idx = [p.distance() for p in particles].index(min_dist)
return code, ID, checksum
def freq(s):
f = {}
for c in s:
f[c] = f.setdefault(c, 0) + 1
res = {
val[0]: val[1]
for val in sorted(f.items(), key=lambda x: (-x[1], x[0]))
}
checksum = "".join(res.keys())
return res, checksum[:5]
rooms = readInput("input_4.txt")
real_rooms = []
for r in rooms:
code, ID, checksum = decodeRoom(r)
if freq(code)[1] == checksum:
real_rooms.append(r)
for r in real_rooms:
code, ID, checksum = decodeRoom(r)
name = decypher(code, int(ID))
if "north" in name:
print("🎁🎄Part 2: {}-{}".format(name, ID))
break
from utils import readInput
def diff(a, b):
res = a
for char in a:
if char in b:
res = res.replace(char, '')
return res
lines = readInput("input_8.txt")
codes = []
numbers = []
for l in lines:
temp1, temp2 = l.split("|")
codes.append(["".join(sorted(t)) for t in temp1[:-1].split(" ")])
numbers.append(["".join(sorted(t)) for t in temp2[1:].split(" ")])
c = 0
for n in numbers:
for d in n:
if len(d) == 2 or len(d) == 4 or len(d) == 3 or len(d) == 7:
c += 1
print("🎄 Part 1: {}".format(c))
grand_tot = 0
digit_map = {}
for nc, code in enumerate(codes):
from utils import readInput
def sumInt(n):
return n * (n + 1) // 2
timers = readInput("input_7.txt")
pos = list(map(int, timers[0].split(",")))
deltas = [
sum([sumInt(abs(p - i)) for p in pos])
for i in range(min(pos),
max(pos) + 1)
]
print("🎄🎅 Part 2: {}".format(min(deltas)))
class Decoder:
def __init__(self):
self.decoded_msg = {}
self.main_loop = True
# def lv(self):
# n = ""
# while True:
# pack = self.scroll(5)
# n += pack[1:]
# if pack[0] == "0":
# break
# return n
#
#
def hexToBin(self, msg):
binary = ""
for c in msg:
binary += bin(int(c, 16))[2:].zfill(4)
return binary
def scroll(self, req, offset, binary):
return binary[offset:offset+req]
def decode(self, msg):
binary = self.hexToBin(msg)
self.payload(binary)
print (self.decoded_msg)
def litteral(self, b):
idx = 0
n = ""
while True:
pack = b[idx:idx+5]
n += pack[1:]
idx += 5
if pack[0] == "0":
break
print ("val:", int(n, 2))
return idx
# def skip(self, b, offset):
# diff = 0
# while True:
# if offset == len(b):
# self.main_loop = False
# break
# val = int(self.scroll(4, offset, b), 2)
# if val == 0:
# diff += 4
# offset += diff
# else:
# break
# return diff
def payload(self, b, oper=False):
print("total length:", len(b))
offset = 0
for ib in range(len(ib)):
while True:
if len(b) == 0:
print ("PIPPO")
break
print ("a"+b[offset:]+"a")
if offset % 4 != 0:
diff = 4 - offset%4
if "1" not in b[offset:offset+diff]:
offset += diff
print (offset, len(b))
print (b[offset:offset+4])
while b[offset:] != "":
if "1" not in b[offset:offset+4]:
offset += 4
else:
break
print (offset, len(b))
print (b[offset:])
if offset == len(b):
break
header = self.scroll(6, offset, b)
version = int(header[:3], 2)
id = int(header[3:6], 2)
print (version, id)
offset += 6
if id == 4:
self.decoded_msg.setdefault("LV", []).append((version, id))
offset += self.litteral(b[offset:])
#if not oper:
# offset += 4 - offset % 4
# offset += self.skip(b, offset)
# print (offset)
#if offset == len(b):
# break
else:
typ = self.scroll(1, offset, b)
offset += 1
if typ == "0":
self.decoded_msg.setdefault("OP0", []).append((version, id))
print (self.decoded_msg)
length = int(self.scroll(15, offset, b), 2)
offset += 15
self.payload(b[offset:offset+length], True)
offset += length
print ("DOPO", b[offset:])
#
#offset += 4 - offset % 4
#offset += self.skip(b, offset)
#print (offset)
#if offset == len(b):
# break
elif typ == "1":
self.decoded_msg.setdefault("OP1", []).append((version, id))
npacks = int(self.scroll(11, offset, b), 2)
offset += 11
self.payload(b[offset:offset*11*npacks], True)
offset += 11*npacks
if len(b) == 0:
break
lines = readInput("test.txt")
d = Decoder()
for l in lines[0:2]:
d.decode(l)
from utils import readInput, printPath
import numpy as np
from heapdict import heapdict
scale = 5
lines = readInput("input_15.txt")
xmax = len(lines[0])
ymax = len(lines)
a = np.zeros(shape=(xmax, ymax))
for y in range(ymax):
for x in range(xmax):
a[(x, y)] = int(lines[y][x])
cavern = np.zeros(shape=(xmax * scale, ymax * scale))
s = 0
for x in range(0, scale):
for y in range(0, scale):
cavern[xmax * x:xmax * (1 + x), ymax * y:ymax * (1 + y)] = a + x + y
s += 1
cavern[cavern > 9] = cavern[cavern > 9] % 9
xmax *= scale
ymax *= scale
start = (0, 0)
end = (xmax - 1, ymax - 1)
neighs = [(0, -1), (0, 1), (-1, 0), (1, 0)]
shortest = np.ones(shape=(xmax, ymax)) * -1
shortest[0, 0] = 0
from imports import *
import utils
from desAndRes import designAndResponse
from priors import getPriors
from groupPredictors import groupPredictors
from miAndClr import mi, mixedCLR
from bayesianRegression import BBSR
utils.loadJob('default')
utils.loadJob(sys.argv[1])
pars = utils.getParams()
random.seed(pars['jobSeed'])
# Read in data
data = utils.readInput(
pars['inputDir'], pars['expMatFile'],
pars['tfNamesFile'], pars['metaDataFile'],
pars['priorsFile'], pars['goldStandardFile'])
# Generate design and response matricies
desResp = designAndResponse(
data['metaData'], data['expMat'],
pars['delTMin'], pars['delTMax'], pars['tau'])
# Generate priors
priors = getPriors(
data['expMat'], data['tfNames'],
data['priorsMat'], data['gsMat'],
pars['evalOnSubset'], pars['jobSeed'],
pars['percTp'], pars['permTp'],
pars['percFp'], pars['permFp'], pars['prSelMode'])
