import datetime import argparse import cProfile, pstats, StringIO from file_importer import FileImporter from metric_calculator import MetricCalculator parser = argparse.ArgumentParser(description='Read a Tab-separated Graph Datafile and start Calculation of Metrics and Statistics as configured in config.py') parser.add_argument('filename', metavar='filename', type=str, help='the name of the data file containing tab separated node ids') parser.add_argument('--profiling',dest='profiling',action='store_true', help='enable runtime profiling into profiling.txt file') args = parser.parse_args() if args.profiling: pr = cProfile.Profile() s = StringIO.StringIO() timestamp = str(datetime.datetime.now().strftime('%Y%m%d_%H%M%S')) outfile = open('profiling_output_'+timestamp+'.txt', 'w') pr.enable() fi = FileImporter(args.filename) graph = fi.read() mc = MetricCalculator(graph) mc.start() if args.profiling: ps = pstats.Stats(pr, stream=s).sort_stats('cumulative') ps.print_stats() outfile.write(s.getvalue())
from file_importer import FileImporter def spin(ary, ind): ind = len(ary) - ind return ary[ind:] + ary[:ind] def exchange(ary, pos1, pos2): tmp = ary[pos1] ary[pos1] = ary[pos2] ary[pos2] = tmp return ary def partner(ary, char1, char2): pos1, pos2 = ary.index(char1), ary.index(char2) return exchange(ary, pos1, pos2) progs = [chr(i) for i in range(97, 113)] inp = FileImporter.get_input("/../input/16.txt").split(",") for i in inp: x = i.split("/") if len(x) == 1: progs = spin(progs, int(x[0][1:])) elif x[0][0] == "x": progs = exchange(progs, int(x[0][1:]), int(x[1])) elif x[0][0] == "p": progs = partner(progs, x[0][1], x[1]) print("".join(progs))
return False def get_hash(salt, ind, cache): hashed = "" if ind not in cache: to_hash = salt + str(ind) hashed = md5(to_hash.encode('utf-8')).hexdigest() cache[ind] = hashed else: hashed = cache[ind] return hashed # Get input inp = FileImporter.get_input("/../input/14a.txt").strip() index = 0 keys = 0 hash_cache = {} # Couldn't wait to use this one. while True: hashed = get_hash(inp, index, hash_cache) first_repeated = get_first_repeated(hashed, 3) if first_repeated: for i in range(index + 1, index + 1001): hashed = get_hash(inp, i, hash_cache) if has_repeated_sequence(hashed, first_repeated, 5):
from file_importer import FileImporter from enum import Enum inp = [list(map(int, i.split(": "))) for i in FileImporter.get_input("/../input/13.txt").split('\n')] class Scanner: def __init__(self, rang): self.rang = rang def get_pos(self, ps): indRang = self.rang - 1 return abs(indRang - ((ps + indRang) % (indRang*2))) delay = 0 scanners = [None for x in range(inp[-1][0] + 1)] for i in inp: scanners[i[0]] = Scanner(i[1]) severity = 0 found = False for i in range(len(scanners)): if scanners[i] is None: continue pos = scanners[i].get_pos(i) if pos == 0: severity += i * scanners[i].rang print(severity)
for sequence in sequences: abas.append(get_aba(sequence)) return filter(None, abas) def supports_ssl(abas, babs): for i in abas: for j in babs: if is_bab_of(i, j): return True return False # Get input inp = [ i.strip() for i in FileImporter.get_input("/../input/7a.txt").split("\n") ] count_support_SSL = 0 for ip in inp: without_hypernets = filter(None, re.split("\[\w*\]", ip)) abas = [] for sequence in without_hypernets: abas += get_abas(sequence) if len(abas) == 0: continue hypernets = re.findall("\[\w*\]", ip) babs = []
from file_importer import FileImporter def add_tup(t1, t2): return (t1[0] + t2[0], t1[1] + t2[1]) def negate_touple(t1): return (-t1[0], -t1[1]) # Row, Column Deltas UP, DOWN, RIGHT, LEFT = (-1, 0), (1, 0), (0, 1), (0, -1) inp = [i for i in FileImporter.get_input("/../input/19.txt").split('\n')] current = (0, inp[0].index('|')) direction = DOWN letters = [] steps = 1 while True: nxt = add_tup(current, direction) char = inp[nxt[0]][nxt[1]] if char == '+': for i in (set([UP, DOWN, RIGHT, LEFT]) - set([direction, negate_touple(direction)])): turned_coord = add_tup(nxt, i) if inp[turned_coord[0]][turned_coord[1]] in '|-': direction = i break
from file_importer import FileImporter from queue import Queue # Dictionary of program ID to list of connecting program IDs inp = {int(i.split(" <-> ")[0]): list(map(int, i.split(" <-> ")[1].split(', '))) for i in FileImporter.get_input("/../input/12.txt").split('\n')} q = Queue() contained = set([0]) # Start with 0 q.put(inp[0]) while not q.empty(): for program in q.get(): if not program in contained: contained.add(program) q.put(inp[program]) print(len(contained))
from file_importer import FileImporter from queue import Queue import sys # Get input fav_number = int(FileImporter.get_input("/../input/13a.txt")) def check_position(x, y): global fav_number if x < 0 or y < 0: return False binary_rep = bin((x * x + 3 * x + 2 * x * y + y + y * y) + fav_number) return True if binary_rep.count("1") % 2 == 0 else False start = (1, 1, 0) end = (31, 39) visited = [] q = Queue() q.put(start) while not q.empty(): position = q.get() visited.append((position[0], position[1])) for i in range(-1, 2): for j in range(-1, 2): x, y, dist = position[0] + i, position[1] + j, position[2] + 1 if abs(i) != abs(j):
from file_importer import FileImporter def reverse_length(_list, currentPos, length): reverse = list( reversed([ _list[i % len(_list)] for i in range(currentPos, currentPos + length) ])) for i in reverse: _list[currentPos % len(_list)] = i currentPos += 1 return _list lengths = list(map(int, FileImporter.get_input("/../input/10.txt").split(','))) nums = list(range(256)) currentPos = skipSize = 0 for length in lengths: nums = reverse_length(nums, currentPos, length) currentPos += length + skipSize currentPos %= 256 skipSize += 1 print(nums[0] * nums[1])
from file_importer import FileImporter inp = [j for j in [i.split(' -> ') for i in FileImporter.get_input("/../input/7.txt").split("\n")] if len(j) > 1] left, right = set(), set() for i in inp: left.add(i[0].split()[0].strip()) for j in i[1].split(', '): right.add(j.strip()) print(list((left - right))[0])
from file_importer import FileImporter inp = [ i.split(" ") for i in FileImporter.get_input("/../input/4.txt").split("\n") ] print( len([ l for l in inp if len(set(["".join(sorted(i)) for i in l])) == len(["".join(sorted(i)) for i in l]) ]))
import re def get_dragon_curve(a): b = reversed(a) b = ''.join('1' if x == '0' else '0' for x in b) return a + "0" + b def get_checksum(inp): final = "" pairs = re.findall("..", inp) for pair in pairs: if pair[0] == pair[1]: final += "1" else: final += "0" if len(final) % 2 == 0: return get_checksum(final) return final # Get input for_checksum = FileImporter.get_input("/../input/16a.txt").strip() disk_length = 272 # Get proper input to compute checksum while len(for_checksum) < disk_length: for_checksum = get_dragon_curve(for_checksum) for_checksum = for_checksum[:disk_length] print(get_checksum(for_checksum))
global cursor # 0 is always rule 1 and 1 is always rule 2 rule = self.rule1 if tape[cursor] == 0 else self.rule2 # step 1 - write new val tape[cursor] = rule.new_val # step 2 - move cursor cursor += rule.new_dir # step 3 - update state state = rule.new_state inp = FileImporter.get_input("/../input/25.txt").split('\n') tape = defaultdict(lambda: 0) state = 'A' cursor = 0 states = { 'A': State(tape, Rule(1, 1, 'B'), Rule(0, -1, 'F')), 'B': State(tape, Rule(0, 1, 'C'), Rule(0, 1, 'D')), 'C': State(tape, Rule(1, -1, 'D'), Rule(1, 1, 'E')), 'D': State(tape, Rule(0, -1, 'E'), Rule(0, -1, 'D')), 'E': State(tape, Rule(0, 1, 'A'), Rule(1, 1, 'C')), 'F': State(tape, Rule(1, -1, 'A'), Rule(1, 1, 'A')) } for i in range(12794428): c_state = states[state]
from file_importer import FileImporter from collections import OrderedDict # Get input inp = int(FileImporter.get_input("/../input/19a.txt").strip()) # List of elf ID's elves = [i for i in range(1, inp + 1)] while len(elves) != 1: size = len(elves) # delete all evens del elves[1::2] # if list size was odd and we haven't accounted for final item, append it to front and restart :) if size % 2 != 0: elves.insert(0, elves.pop()) print(elves[0])
from file_importer import FileImporter from collections import defaultdict inp = FileImporter.get_input("/../input/11.txt").split(',') dic = defaultdict(lambda: 0) max = 0 for i in inp: dic[i] += 1 xabs = abs((dic["ne"] + dic["se"]) - (dic["nw"] + dic["sw"])) yabs = abs((dic["n"] + dic["nw"]) - (dic["s"] + dic["se"])) zabs = abs((dic["s"] + dic["sw"]) - (dic["n"] + dic["ne"])) dist = int((xabs + zabs + yabs) / 2) if dist > max: max = dist print(max)
from file_importer import FileImporter steps = int(FileImporter.get_input("/../input/17.txt")) currentPos = 0 buffer = [0] newVal = 1 for i in range(2017): currentPos = ((currentPos + steps) % len(buffer)) + 1 buffer.insert(currentPos, newVal) newVal += 1 print(buffer[currentPos + 1])
from file_importer import FileImporter import math from collections import defaultdict def add_tuple(t1, t2): return (t1[0] + t2[0], t1[1] + t2[1]) def get_key(x, y): return str(x) + ',' + str(y) inp = [list(i) for i in FileImporter.get_input("/../input/22.txt").split("\n")] grid_dic = defaultdict(lambda: '.') for i in range(len(inp)): for j in range(len(inp)): grid_dic[get_key(i, j)] = inp[i][j] # Map of direction number to the vector you'll travel directions = { 0: (0, 1), # Right 1: (-1, 0), # Up 2: (0, -1), # Left 3: (1, 0), # Down } # Initial position is middle of grid, direction is up. Grid is a square c_pos = (math.floor(len(inp) / 2), math.floor(len(inp) / 2))
from file_importer import FileImporter class Gen: def __init__(self, prevVal: int, factor, divis, mod): self.prevVal = prevVal self.factor = factor self.divis = divis self.mod = mod def next(self): self.prevVal = (self.prevVal * self.factor) % self.divis if not self.prevVal % self.mod == 0: return self.next() return self.prevVal inp = FileImporter.get_input("/../input/15.txt").split("\n") FACTOR_A, FACTOR_B, DIVISOR = 16807, 48271, 2147483647 gen_a = Gen(int(inp[0].split(" ")[-1]), FACTOR_A, DIVISOR, 4) gen_b = Gen(int(inp[1].split(" ")[-1]), FACTOR_B, DIVISOR, 8) print(sum(gen_a.next() & 0xffff == gen_b.next() & 0xffff for i in range(5000000)))
from file_importer import FileImporter # Get input inp = [ list(map(int, y.split("-"))) for y in [ x.strip() for x in FileImporter.get_input("/../input/20a.txt").split("\n") ] ] inp = sorted(inp, key=lambda x: x[0]) max0, max1 = inp[0][0], inp[0][1] allowed = 0 for i in inp: if i[0] > max0: max0 = i[0] if max0 > max1 + 1: allowed += 1 if i[1] > max1: max1 = i[1] print(allowed)
from file_importer import FileImporter inp = [ list(map(int, i.split("\t"))) for i in FileImporter.get_input("/../input/2.txt").split('\n') ] sum = 0 for row in inp: for num in row: divs = list(row) divs.remove(num) for otherNum in divs: if (num % otherNum == 0): sum += num // otherNum print(sum)
from file_importer import FileImporter # Get Input inp = [i.strip().split(" ") for i in FileImporter.get_input("/../input/3a.txt").split("\n")] possible = 0 for line in inp: line = sorted([int(i.strip()) for i in list(filter(None, line))]) if line[0] + line[1] > line[2]: possible += 1 print(possible)
from file_importer import FileImporter def get_name(file): return file.split("-", 1)[1] FILESYSTEM, SIZE, USED, AVAIL, USEP = 0, 1, 2, 3, 4 inp = [x.strip().split() for x in FileImporter.get_input("/../input/22a.txt").split("\n")][:] pairs = 0 for a in range(len(inp)): node_a = inp[a] for b in range(a+1, len(inp)): node_b = inp[b] if int(node_a[USED][:-1]) != 0 and int(node_a[USED][:-1]) < int(node_b[AVAIL][:-1]): pairs += 1 break if int(node_b[USED][:-1]) != 0 and int(node_b[USED][:-1]) < int(node_a[AVAIL][:-1]): pairs += 1 print(pairs)
from file_importer import FileImporter inp = FileImporter.get_input("/../input/1.txt") steps = len(inp) // 2 print( sum([ int(inp[i]) for i in range(len(inp)) if inp[i] == inp[(i + steps) % len(inp)] ]))
from file_importer import FileImporter inp = list(map(int, FileImporter.get_input("/../input/6.txt").split())) def max_bank_ind(banks): max = 0 for i in range(len(banks)): if banks[i] > banks[max]: max = i return max def realloc(banks, bankInd): blocks, banks[bankInd] = banks[bankInd], 0 while blocks > 0: bankInd += 1 banks[bankInd % len(banks)] += 1 blocks -= 1 states, count = [], 0 while inp not in states: states.append(inp[:]) maxInd = max_bank_ind(inp) realloc(inp, maxInd) count += 1 print(count)
from file_importer import FileImporter # Get input inp = [ i.split(" ") for i in FileImporter.get_input("/../input/12a.txt").split("\n") ] registers = {"a": 0, "b": 0, "c": 0, "d": 0} i = 0 while i < len(inp): instr = inp[i] if instr[0] == "cpy": if instr[1].isdigit(): registers[instr[2]] = int(instr[1]) else: registers[instr[2]] = registers[instr[1]] elif instr[0] == "inc": registers[instr[1]] += 1 elif instr[0] == "dec": registers[instr[1]] -= 1 if instr[0] == "jnz": val = 0 if instr[1].isdigit(): val = int(instr[1]) else: val = registers[instr[1]] if val != 0: i += int(instr[2]) continue
from file_importer import FileImporter from operator import xor from functools import reduce def reverse_length(_list, currentPos, length): reverse = list(reversed([_list[i % len(_list)] for i in range(currentPos, currentPos + length)])) for i in reverse: _list[currentPos % len(_list)] = i currentPos += 1 return _list lengths = [ord(i) for i in FileImporter.get_input("/../input/10.txt")] + [17, 31, 73, 47, 23] # Get ascii for each char, add nums = list(range(256)) # the problem-defined sequence currentPos = skipSize = 0 # Run 64 rounds for i in range(64): for length in lengths: nums = reverse_length(nums, currentPos, length) currentPos += length + skipSize; currentPos %= 256 skipSize += 1 # Calculate dense hash - 16 blocks denseHash = [] for i in range(16): hashVal = reduce(xor, [i for i in nums[i * 16:i * 16 + 16]]) denseHash.append(hashVal) # Function to add leading 0 if necessary ensurelen = lambda x: '0' + x if len(x) == 1 else x