def tokenize_context(context, center_word, dictionary): match_obj = SCWS_CONTEXT.match(context.lower()) left_context = match_obj.group(1).strip() assert match_obj.group(2).strip() == center_word right_context = match_obj.group(3).strip() tokenization_type = 'wsi' return parse_line(left_context, dictionary, tokenization_type), parse_line(right_context, dictionary, tokenization_type)
def read_in_image_subset(self): """ Parses and reads in the csv files in the image directory. Looking for only those images that fit the user's requirements/choices. :return: Returns a list that contains information about certain images in the directory. """ if len(self.choices) == 0: raise ValueError("self.choices array is EMPTY.") all_files = os.listdir(con.IMAGES_DIRECTORY) output_list = [] for filename in all_files: extension = filename[-3:] if extension == "png": # skip the image files continue new_path = os.path.join(con.IMAGES_DIRECTORY, filename) mylist = [] # opens a .csv file and reads in its contents. with open(new_path, "r") as f: mylist = f.readlines() # The following line strips out newline characters and makes sure the line isn't empty. mylist = [i.strip() for i in mylist if len(i.strip()) > 0] # print(mylist) mylist = utils.parse_line(mylist) mylist.insert(0, filename) output_list.append(mylist) # ---------------------------- output_list = self.apply_choices(output_list) # ---------------------------- return output_list
def create_example(line): data = utils.parse_line(line.strip()) input_image = create_input_image(args.input_dir, data['scan_id'], data['slice_id'], utils.INPUT_SHAPE) # normalize the image input_image = input_image / 0.0625 if args.structure and args.structure not in data['structures']: return None mask = utils.create_joint_mask((512, 512), data['structures'], utils.LUNG_CLASSES) height, width = utils.INPUT_SHAPE classes = np.array([0] + [ int(any(x in data['structures'] for x in v)) for k, v in utils.LUNG_CLASSES ], dtype=np.int32) print("Writing: ", data['structures'].keys(), "Classes:", classes, "Image max:", np.max(input_image), "Mask max: ", np.max(mask)) example = tf.train.Example(features=tf.train.Features( feature={ 'height': _int64_feature(height), 'width': _int64_feature(width), 'image': _bytes_feature(input_image.tostring()), 'mask': _bytes_feature(mask.tostring()), 'scan_id': _bytes_feature(data['scan_id'].encode()), 'slice_id': _bytes_feature(data['slice_id'].encode()), 'classes': _bytes_feature(classes.tostring()) })) return example
def pre_process(leaf_size=40, processed_data=r'./proc_data.tree', lookup=r'./id_star.lkp'): """ Function to pre process the stars data into a kd tree and save the data Args: leaf_size: The number of points at which the algorithm switches over to brute-force. Has to be positive processed_data: The location where the processed data is to be stored as a pickle file lookup: The location where the data id to object lookup is stored Returns: No return """ utils.skip_line(1) stars = [] idx = 0 id_star_dct = {} for line in sys.stdin: star_name, x, y, z = utils.parse_line(line) stars.append([x, y, z]) id_star_dct[idx] = star(x, y, z, star_name) idx += 1 # construct a kd-tree tree = spatial.KDTree(stars, leafsize=leaf_size) utils.save_as_pickle(data=tree, pickle_file=processed_data) utils.save_as_pickle(data=id_star_dct, pickle_file=lookup)
def _parse_file(self, storage_key, file_path, read_from_start=False, read_to_time=None): """ Read recent part of the log file, update statistics storages and adjust seek. If only file parameter is supplied, read file from self.seek to the end. If the file is not found or cannot be read, log an error and return. @param str storage_key: a key to define statistics storage @param string file_path: path to file for parsing @param bool read_from_start: if true, read from the beginning of file, otherwise from `self.seek` @param datetime read_to_time: if set, records are parsed until their time is greater or equal of parameter value Otherwise the file is read till the end. """ with open(file_path, 'r') as f: if read_from_start: logger.debug('Reading file %s from the beginning to %s' % (file_path, read_to_time)) else: logger.debug('Reading file %s from position %d to %s' % (file_path, self.seek[file_path], read_to_time or 'the end')) if not read_from_start: f.seek(self.seek[file_path]) logger.debug('Setting seek for file %s to %d based on a value from the storage' % (f.name, self.seek[file_path])) log_parser = apachelog.parser(getattr(settings, 'ELF_FORMAT', '')) while True: current_seek = f.tell() line = f.readline() if not line: #Reached end of file, record seek and stop self.seek[file_path] = current_seek logger.debug('Reached end of file %s, set seek in storage to %d' % (f.name, current_seek)) break record = utils.parse_line(line, log_parser, getattr(settings, 'LATENCY_IN_MILLISECONDS', False)) if not record: self._count_record(storage_key, 'error') continue record_time = record.get_time() if record_time is None: logger.error('Could not process time string: ' + record.time) logger.error('Line: ' + record.line) self._count_record(storage_key, 'error') continue if read_to_time and record_time >= read_to_time: #Reached a record with timestamp higher than end of current analysis period #Stop here and leave it for the next invocation. self.seek[file_path] = current_seek logger.debug('Reached end of period, set seek for %s in storage to %d' % (f.name, current_seek)) break status = self._process_record(storage_key, record) self._count_record(storage_key, status)
def find_k_nearest(k, point_star): """ Function to loop through each line in the stdin and keep track of the k closest points Args: k: the number of closest neighbors to find point_star: the star for which to find the k closest neighbors Returns: max_heap: a heap containing the k closest distances to the point_star star_dist: a key value pari of {dist-d1: [list of stars at dist-d1 to point_star]} """ max_heap = [] star_dist = defaultdict(list) # skip header and sun row utils.skip_line(2) for line in sys.stdin: star_name, x, y, z = utils.parse_line(line=line) dist = utils.euclidean_dist(x=(x, y, z), y=point_star) new_star = star(x=x, y=y, z=z, star_name=star_name) if len(max_heap) < k: heappush(max_heap, -1 * dist) star_dist[dist].append(new_star) elif dist <= -1 * max_heap[0]: heappushpop(max_heap, -1 * dist) star_dist[dist].append(new_star) return max_heap, star_dist
def _read_record(f, log_parser): """ Parse a single record from a log file @param FileIO f: file to seek @param parser log_parser: instance of a parser @return LogRecord parsed record """ line = f.readline() if not line: return utils.END_OF_FILE return utils.parse_line(line, log_parser)
def main(): # Graceful interruption handler. def quit(signum, frame): """ Handler to catch interrupting signals. :param signum: Number of a caught signal. :param frame: Interpreter stack frame (not used, added to comply with standard). :return: None :side-effects: Sets global exit event. """ sys.stderr.write("\nInterrupted by %s, exiting.\n" % sig_names[signum]) sys.stderr.flush() exit.set() exit = threading.Event() for s in sig_names.values(): signal.signal(getattr(signal, s), quit) # Configuration manipulation. utils.update_config_from_cli_arguments(config, cliargs) collectors = utils.load(config, 'collectors', _collectors) display = utils.load(config, 'representer', representers, args=[collectors])[0] check_interval = config.getint('DEFAULT', 'check_interval') fname = config.get('DEFAULT', 'log_file') sys.exit(1) if utils.file_has_problems(fname) else just_continue # The processing itself. with open(fname, 'r') as f: f.seek(0, 2) # Ignore historic data. display.show_stats() while True and not exit.is_set(): start = datetime.datetime.now() data = list( filter( None, [utils.parse_line(x) for x in utils.get_fresh_events(f)])) for collector in collectors: for line in data: collector.process_line(line) duration = (datetime.datetime.now() - start).total_seconds() to_wait = check_interval - duration if to_wait > 0: exit.wait(to_wait) else: sys.stderr.write("WARNING: too many events! Can not process" " them in %d second(s)!\n" % check_interval) sys.stderr.flush() display.tick()
def do_add_user(self, line): ''' This command adds a single user to the list of users USAGE: ad_user PersonE {(17, 42), [Running, Reading, Trekking]} ''' try: name, x, y, interests, attributes = parse_line(line.strip()) except Exception as e: print 'Unable to add user: ERROR: %s' % e return location = Location(x, y) user = User(name, location, interests, **attributes) cell = location.cell() if cell in self.users: self.users[cell].append(user) else: self.users[cell] = [user] self.users_by_name[name] = user print 'User added'
def create_lung_example(line): data = utils.parse_line(line.strip()) input_image = create_input_image(args.input_dir, data['scan_id'], data['slice_id'], (256, 256), 3) # normalize the image input_image = input_image / 0.0625 if args.structure and args.structure not in data['structures']: return None with open(os.path.join(args.input_dir, data['scan_id'], 'coordinates.txt'), 'r') as f: r0, c0, r1, c1 = [int(x) for x in f.read().split(",")] radiomics = { k: v for k, v in data['structures'].items() if k == 'radiomics_gtv' } mask = utils.create_mask((512, 512), radiomics) mask = mask[r0:r1, c0:c1] height, width = 256, 256 classes = np.array([0] + ['radiomics_gtv' in data['structures']], dtype=np.int32) print("Writing: ", data['structures'].keys(), "Classes:", classes, "Image max:", np.max(input_image), "Mask max: ", np.max(mask)) example = tf.train.Example(features=tf.train.Features( feature={ 'height': _int64_feature(height), 'width': _int64_feature(width), 'image': _bytes_feature(input_image.tostring()), 'mask': _bytes_feature(mask.tostring()), 'scan_id': _bytes_feature(data['scan_id'].encode()), 'slice_id': _bytes_feature(data['slice_id'].encode()), 'classes': _bytes_feature(classes.tostring()) })) return example
def read_in_all_images(self): """ Reads in all the faces in the directory. :return: Returns a list that contains information about each image in the directory. """ all_files = os.listdir(con.IMAGES_DIRECTORY) output_list = [] for filename in all_files: extension = filename[-3:] if extension == "png": continue new_path = os.path.join(con.IMAGES_DIRECTORY, filename) # print(new_path) with open(new_path, "r") as f: mylist = f.readlines() mylist = [i.strip() for i in mylist if len(i.strip()) > 0] parsed_list = utils.parse_line(mylist) parsed_list.insert(0, filename) output_list.append(parsed_list) return output_list
#!/usr/bin/env python import sys import utils if __name__ == "__main__": host = sys.argv[1] port = int(sys.argv[2]) collection = sys.argv[3] chunk_size = 10000 added = 0 for lines in utils.grouper(sys.stdin, chunk_size): lines = [x for x in lines if x != None] objects = [utils.parse_line(line) for line in lines] utils.index_objects(objects, host, port, collection) added += chunk_size print >>sys.stderr, added
def next_act(self): l = f[self.process_num].readline() act = utils.parse_line(l) utils.norm_act(act, 1, t_maxlen) return act
def test_ari(wsi_dir, testset_name, dictionary, estimate_sense_distribution_fct): wsi_ctx_file = os.path.join(wsi_dir, 'dataset.txt') wsi_gt_file = os.path.join(wsi_dir, 'key.txt') # logging.info(' Loading ground truth') ground_truth = {} with open(wsi_gt_file) as f: for l in f: splitted = l.split() word_with_pos = splitted[0] if word_with_pos not in ground_truth: ground_truth[word_with_pos] = {} word_with_pos_with_ctx_id = splitted[1].split('.') assert word_with_pos == '.'.join( [word_with_pos_with_ctx_id[0], word_with_pos_with_ctx_id[1]]) ctx_id = int(word_with_pos_with_ctx_id[2]) word_with_pos_with_sense_id = splitted[2].split('.') assert word_with_pos.split('.')[0] == word_with_pos_with_sense_id[ 0] # There is no PoS in WWSI if '&&' in word_with_pos_with_sense_id[ 2]: # TODO: handle it better; this occurs in SemEval 2010 continue sense_id = int(word_with_pos_with_sense_id[2]) ground_truth[word_with_pos][ctx_id] = sense_id if __debug__: sense_numbers = [] # logging.info('Total ctx number: {}. Unique word with POS number: {}'.format(sum([len(ctx_dict) for ctx_dict in ground_truth.itervalues()]), len(ground_truth))) for w in ground_truth.itervalues(): sense_numbers.append(len(set(w.itervalues()))) # logging.info('Sense numbers. Min: {}, max: {}, median: {} and mean: {}.'.format(min(sense_numbers), max(sense_numbers), np.median(sense_numbers), np.mean(sense_numbers))) # logging.info('Predicting') ctx_number = 0 ctx_expected_number = 0 current_word_with_pos = None aris = [] # unknown_word_id = dictionary[UNKNOWN_WORD] # reverse_dictionary = dict(zip(dictionary.values(), dictionary.keys())) disambiguation_examples = {} disambiguation_examples_words = ( ) # ('mouse', 'goal', 'heart', 'wave', 'root', 'coup', 'java', 'ruby', 'time', 'train', 'mass', 'bus', 'foot', 'mini', 'lion', 'mirror', 'burn', 'monopoly', 'apache') # if testset_name == 'WWSI': # wwsi_raw = read_raw_wwsi(wsi_dir) with open(wsi_ctx_file, 'r') as f: for l in f: splitted = l.split() if len(splitted) == 2 and '\t' not in l: assert ctx_number == ctx_expected_number if current_word_with_pos: aris.append( adjusted_rand_score(predicted_senses, expected_senses)) predicted_senses = [] expected_senses = [] current_word_with_pos = splitted[0] current_word = current_word_with_pos.split('.')[0] if current_word not in dictionary: current_word_with_pos = None continue ctx_expected_number = int(splitted[1]) ctx_number = 0 elif current_word_with_pos: ctx_number += 1 sense_dict = ground_truth[current_word_with_pos] if ctx_number not in sense_dict: continue # due to skipping '&&' in SemEval2010 tab_splitted = l.split('\t') assert len(tab_splitted) == 2 ctx = (parse_line(tab_splitted[0], dictionary, 'wsi'), parse_line(tab_splitted[1], dictionary, 'wsi')) if ctx != ([], []): # this is possible in case of SemEval 2013 expected_senses.append(sense_dict[ctx_number]) sense_distribution = estimate_sense_distribution_fct( w=dictionary[current_word], c=ctx) # logging.info('word: {}, ctx size: {}, first word: {}, unknown number: {}, expected sense: {}, predicted sense: {}'.format(current_word, len(ctx[0]) + len(ctx[1]), reverse_dictionary[list(chain.from_iterable(ctx))[0]], len([t for t in chain.from_iterable(ctx) if t == unknown_word_id]), expected_senses[-1], predicted_senses[-1])) predicted_senses.append(np.argmax(sense_distribution) + 1) if testset_name == 'WWSI' and current_word in disambiguation_examples_words: if current_word not in disambiguation_examples: disambiguation_examples[current_word] = [] disambiguation_examples[current_word].append( (wwsi_raw[current_word][ctx_number - 1], expected_senses[-1], sense_distribution)) logging.info(' Averaged ARI for {:12}: {:.3}'.format( testset_name, np.mean(aris))) # logging.info('Disambiguation_examples:') for w in disambiguation_examples: logging.info(' Word {}:'.format(w)) for sense_id in xrange(len(disambiguation_examples[w][0][2])): logging.info(' Sense {}:'.format(sense_id)) top_examples = sorted(disambiguation_examples[w], key=lambda ex: ex[2][sense_id], reverse=True)[:4] for ex in top_examples: logging.info(' {:.3} {} {}'.format( ex[2][sense_id], ex[1], ex[0]))
# combinations('ABCD', 2) AB AC AD BC BD CD # combinations_with_replacement('ABCD', 2) AA AB AC AD BB BC BD CC CD DD tot = 0 res = [] board = {} table = new_table(None, width=2, height=4) # Uncomment for multi-group style inputs. :c # data = ''.join([line for line in fileinput.input()]) # groups = [g.split('\n') for g in data.split('\n\n')] for y, line in enumerate(fileinput.input()): line = line.strip() nums = parse_nums(line) data = parse_line(r'', line) nums = [int(x) for x in line.split(',')] for x, c in enumerate(line): board[Point(x, y)] = c if y == 0: print(data) print nums seen = defaultdict(list) for i, n in enumerate(nums): seen[n].append(i)
def create_indexes(): db = connect_db() cursor = db.cursor() data = get_all_data_from_db(cursor) norm_redis = connect_word_to_norm_word() id_item_redis = connect_id_to_item() word_ids_redis = connect_word_to_bag_ids() word_ids_redis_quick = connect_word_to_bag_ids_quick() idBag_length_redis = connect_bag_id_to_length() idBag_bag = connect_bag_id_to_bag() for rec in data: item_id = rec[0] name = rec[1] print str(item_id) + " " + name id_item_redis.set(item_id, name) for i in range(1, 4): #print rec[i] cur_bag_of_words = filter_bag_of_words(normalize_bag_of_words_with_index(parse_line(rec[i]), norm_redis), STOP_LIST) idBag_length_redis.set((item_id - 1)*3 + i - 1, len(cur_bag_of_words)) idBag_bag.set((item_id - 1)*3 + i - 1, rec[i]) for word in cur_bag_of_words: word_ids_redis.sadd(word, (item_id - 1)*3 + i - 1) word_ids_redis_quick.zadd(word, 1, (item_id - 1)*3 + i - 1) disconnect_db(db)
def test_second(self): fish_dates = utils.parse_line("test_input.txt", ",", int) self.assertEqual(day06.count_fish(fish_dates, 256), 26984457539)
raise Exception('modular inverse does not exist') else: return x % m def chinese_remainder_theorem(discs): M = mul(d[0] for d in discs) x = 0 for i, (size, initial) in enumerate(discs, start=1): # Disc #2 has 17 positions; at time=0, it is at position 15. # => x \equiv (17 - 15 - 2) (mod 17) M_i = (M / size) x += (size - initial - i) * M_i * modinv(M_i, size) return x DISCS = [] DISC_RE = re.compile( r'Disc #\d+ has (\d+) positions; at time=0, it is at position (\d+).') for line in fileinput.input(): disc = parse_line(DISC_RE, line.strip()) DISCS.append(disc) # print "Timing to press button:", button_timing(DISCS) # print "Timing with added disc:", button_timing(DISCS + [[11, 0]]) print "Timing to press button:", chinese_remainder_theorem(DISCS) print "Timing with added disc:", chinese_remainder_theorem(DISCS + [[11, 0]])
import utils def calc_fuel(start_position: int, end_position: int, const: bool = False) -> int: const_burn = abs(start_position - end_position) return const_burn if not const else ((const_burn**2 + const_burn) // 2) def find_min_fuel(start_positions: list[int], const: bool = False) -> int: return min( sum( calc_fuel(start_position, end_position, const) for start_position in start_positions) for end_position in range(max(start_positions))) if __name__ == "__main__": in_fpath = input("Enter file containing starting positions: ") in_data = utils.parse_line(in_fpath, ",", int) print(f"Minimum fuel required (constant burn): {find_min_fuel(in_data)}") print( f"Minimum fuel required (non-constant burn): {find_min_fuel(in_data, True)}" )
import fileinput from utils import parse_line part_1 = 0 part_2 = 0 for line in fileinput.input(): start, end, letter, pwd = parse_line(r'(\d+)-(\d+) (\w+): (\w+)', line) if start <= pwd.count(letter) <= end: part_1 += 1 if (pwd[start - 1] == letter) ^ (pwd[end - 1] == letter): part_2 += 1 print "Part 1:", part_1 print "Part 2:", part_2
def test_first(self): start_positions = utils.parse_line("test_input.txt", ",", int) self.assertEqual(day07.find_min_fuel(start_positions), 37)
def test_second(self): start_positions = utils.parse_line("test_input.txt", ",", int) self.assertEqual(day07.find_min_fuel(start_positions, True), 168)
def create_seed_example(line): data = utils.parse_line(line.strip()) input_image = create_input_image(args.input_dir, data['scan_id'], data['slice_id'], (512, 512), 1) # normalize the image input_image = input_image / 0.0625 if args.structure and args.structure not in data['structures']: return None radiomics = { k: v for k, v in data['structures'].items() if k == 'radiomics_gtv' } examples = [] for seed in data['seeds']: mask = utils.create_mask((512, 512), radiomics) height, width = 224, 224 r0 = max(0, seed[1] - height // 2) c0 = max(0, seed[0] - width // 2) r1 = seed[1] + height // 2 c1 = seed[0] + width // 2 mask = mask[r0:r1, c0:c1] image = input_image[r0:r1, c0:c1, :] pad_h = (height - image.shape[0]) / 2 pad_w = (width - image.shape[1]) / 2 print("Point", seed, "Image", image.shape, "Mask", mask.shape, "Pad", pad_h, pad_w) if pad_h or pad_w: mask = np.pad(mask, ((int(np.ceil(pad_h)), int(np.floor(pad_h))), (int(np.ceil(pad_w)), int(np.floor(pad_w)))), mode='constant') image = np.pad(image, ((int(np.ceil(pad_h)), int(np.floor(pad_h))), (int(np.ceil(pad_w)), int(np.floor(pad_w))), (0, 0)), mode='constant') assert (image.shape[0] == height and image.shape[1] == width) assert (mask.shape[0] == height and mask.shape[1] == width) classes = np.array([0] + ['radiomics_gtv' in data['structures']], dtype=np.int32) print("Writing: ", data['structures'].keys(), "Classes:", classes, "Image max:", np.max(image), "Mask max: ", np.max(mask)) example = tf.train.Example(features=tf.train.Features( feature={ 'height': _int64_feature(height), 'width': _int64_feature(width), 'image': _bytes_feature(image.tostring()), 'mask': _bytes_feature(mask.tostring()), 'scan_id': _bytes_feature(data['scan_id'].encode()), 'slice_id': _bytes_feature(data['slice_id'].encode()), 'classes': _bytes_feature(classes.tostring()) })) examples.append(example) return examples
import fileinput from collections import defaultdict from utils import parse_line PROG = {} # Parse puzzle input for i, line in enumerate(fileinput.input()): if i == 0: STATE = parse_line(r'Begin in state (\w+).', line)[0] elif i == 1: STEPS = int( parse_line(r'Perform a diagnostic checksum after (\d+) steps.', line)[0]) if i <= 2: continue if i % 10 == 3: start = parse_line(r'In state (\w+):', line)[0] elif i % 10 == 5: write_0 = parse_line(r' - Write the value (\d+).', line)[0] elif i % 10 == 6: move_0 = parse_line(r' - Move one slot to the (\w+).', line)[0] move_0 = 1 if move_0 == 'right' else -1 elif i % 10 == 7: next_0 = parse_line(r' - Continue with state (\w+).', line)[0] elif i % 10 == 9: write_1 = parse_line(r' - Write the value (\d+).', line)[0] elif i % 10 == 0:
# import sys # import time import fileinput from utils import parse_line WIDTH = 50 HEIGHT = 6 SCREEN = [[False for _ in range(WIDTH)] for _ in range(HEIGHT)] # Make space for animated output # print '\n' * HEIGHT for line in fileinput.input(): if line.startswith('rect'): a, b = parse_line(r'rect (\d+)x(\d+)', line) for y in range(b): for x in range(a): SCREEN[y][x] = True else: rc, n, offset = parse_line(r'rotate (\w+) .=(\d+) by (\d+)', line) if rc == 'row': temp = SCREEN[n][:] for i, x in enumerate(temp): SCREEN[n][(offset + i) % WIDTH] = x else: temp = [row[n] for row in SCREEN]
fish_count = defaultdict(int) for dates in init_dates: fish_count[dates] += 1 # Determine number of fish created after num_days for _ in range(num_days): new_fish_count = defaultdict(int) for days_left, fish_count in fish_count.items(): if days_left == 0: # Reset timer and add same number of new fish new_fish_count[6] += fish_count new_fish_count[8] += fish_count else: # Minus 1 day for fish not due new_fish_count[days_left - 1] += fish_count # Update tracker fish_count = new_fish_count return sum(fish_count.values()) if __name__ == "__main__": input_data = input("Enter path containing fish due dates: ") fish_dates = utils.parse_line(input_data, ",", int) print(f"Number of laternfish after 80 days: {count_fish(fish_dates, 80)}") print( f"Number of laternfish after 256 days: {count_fish(fish_dates, 256)}")
from utils import parse_line def decrypt(c, n): if c == '-': return ' ' return chr((((ord(c) - ord('a')) + n) % 26) + ord('a')) total_sector_id = 0 north_pole_sector_id = None for line in fileinput.input(): name, sector, checksum = parse_line(r'(\S+)-(\d+)\[(\w{5})\]', line) sector = int(sector) real_name = ''.join(decrypt(c, sector) for c in name) if 'northpole' in real_name: north_pole_sector_id = sector occurences = Counter([x for x in name if x.isalpha()]) commons = sorted(occurences.most_common(), key=lambda (x, y): (-y, x)) if ''.join(zip(*commons)[0][:5]) == checksum: total_sector_id += sector print "Sum of sector IDs of real rooms: %i" % total_sector_id print "North Pole storage room sector: %i" % north_pole_sector_id
import re import fileinput from collections import Counter from utils import parse_line formulas = {} from_ore = set() for i, line in enumerate(fileinput.input()): inp, out = line.split(' => ') re_form = r'(\d+) (.+)' inputs = [parse_line(re_form, i) for i in inp.split(', ')] out = parse_line(re_form, out) formulas[out[1]] = (out[0], inputs) if inputs[0][1] == 'ORE': from_ore.add(out[1]) def create_fuel(n): excesses = Counter() def needed(n, type): ret = Counter() if type in from_ore: ret[type] += n return ret
def test_first(self): fish_dates = utils.parse_line("test_input.txt", ",", int) self.assertEqual(day06.count_fish(fish_dates, 18), 26) self.assertEqual(day06.count_fish(fish_dates, 80), 5934)
import fileinput from collections import defaultdict from utils import parse_line GOAL = 'shiny gold' graph = defaultdict(set) for i, line in enumerate(fileinput.input()): line = line.strip() color, rest = parse_line(r'(\w+ \w+) bags contain (.+)+', line) rest = rest.replace('.', '').split(',') for r in rest: if r != 'no other bags': parts = r.split() new_color = ' '.join(parts[1:3]) graph[color].add((new_color, int(parts[0]))) def dfs_1(node): if node == GOAL: return True return any(dfs_1(n) for n, _ in graph[node]) def dfs_2(node, count=1): tot = 1 for nxt, amt in graph[node]:
import fileinput from collections import Counter, defaultdict from utils import parse_line SQUARES = Counter() CLAIMS = defaultdict(list) for i, line in enumerate(fileinput.input()): _id, x, y, w, h = parse_line(r'#(\d+) @ (\d+),(\d+): (\d+)x(\d+)', line) for i in range(x, x + w): for j in range(y, y + h): SQUARES[(i, j)] += 1 CLAIMS[_id].append((i, j)) print "Square inches of fabric within multiple claims:", sum(n > 1 for c, n in SQUARES.items()) for _id in CLAIMS: for pos in CLAIMS[_id]: if SQUARES[pos] != 1: break else: print "ID of only non-overlapping claim:", _id
print ''.join( grid.get(Point(x, y), '.') for x in range(min_x - 1, max_x + 2)) print grid = {} min_y = 1e10 max_y = -1e10 min_x = 1e10 max_x = -1e10 for i, line in enumerate(fileinput.input()): a, x, b, y, z = parse_line(r'(.)=(\d+), (.)=(\d+)..(\d+)', line) for i in range(y, z + 1): if a == 'x': grid[Point(x, i)] = '#' min_y = min(min_y, i) max_y = max(max_y, i) min_x = min(min_x, x) max_x = max(max_x, x) else: grid[Point(i, x)] = '#' min_y = min(min_y, x) max_y = max(max_y, x) min_x = min(min_x, i) max_x = max(max_x, i)
def read_log_file(log_file): # initialize data structures logger.info('Initializing data structures') hosts_count = {} # data struct for feature1, dict containing top hosts resources_count = {} # data struct for feature 2, dict containing top resources hours_queue = [] # data struct for feature 3, maintains 1 hour worth of log entries hours_count = {} # data struct for feature 3, dict containing busiest 10 hours blocked_list = [] # data struct for feature 4, list containing all blocked login attempts blocked_attempts = BlockedAttempts() # iterate through log file and update data structures with open(str(log_file)) as file: for line in file: # parse line line = str(line) data = parse_line(line) logger.info('Updating data structures') # update data structures # feature 1 hosts_count = update_feature1(data, hosts_count) # feature 2 resources_count = update_feature2(data, resources_count) # feature 3 hours_queue, hours_count = update_feature3(data, hours_queue, hours_count) # feature 4 blocked_attempts, blocked_list = update_feature4(line, data, blocked_attempts, blocked_list) logger.info('Begin writing to output files') # write to output files # feature 1: save top 10 hosts to hosts.txt logger.info('Begin writing to hosts.txt') with open(str(hosts_file), 'w') as file: host_number = 0 for host, value in sorted(hosts_count.items(), key=lambda kv: kv[1], reverse=True): if host_number < 10: file.write(host + ',' + str(value) + '\n') else: break host_number += 1 logger.info('Completed writing to hosts.txt') logger.info('Begin writing to resources.txt') # feature 2: save top 10 resources to resources.txt, sort by value in descending order, then by key ascending value with open(str(resources_file), 'w') as file: resource_number = 0 for resource, value in sorted(resources_count.items(), key=lambda(k, v): (-v, k)): if resource_number < 10: file.write(resource + '\n') else: break resource_number += 1 logger.info('Completed writing to resources.txt') logger.info('Begin writing to hours.txt') # feature 3: save top 10 hours to hours.txt with open(str(hours_file), 'w') as file: hour_number = 0 for hour, value in sorted(hours_count.items(), key=lambda kv: kv[1], reverse=True): if hour_number < 10: file.write(hour + ',' + str(value) + '\n') else: break hour_number += 1 logger.info('Completed writing to hours.txt') logger.info('Begin writing to blocked.txt') # feature 4: save all blocked login attempts to blocked.txt with open(str(blocked_file), 'w') as file: for row in blocked_list: file.write(row) logger.info('Begin writing to blocked.txt')
def allowed_ips(blacklist, max_ip=MAX_IP): """Generator over all allowed IPs given a blacklist.""" i = 0 for start, end in sorted(blacklist): if i < start: for n in range(i, start): yield n if i <= end: i = end + 1 if i <= max_ip: for n in range(i, max_ip + 1): yield n if __name__ == '__main__': blacklist = [] for line in fileinput.input(): start, end = parse_line(r'(\d+)-(\d+)', line) blacklist.append((start, end)) whitelist = list(allowed_ips(blacklist)) print "Lowest-valued whitelisted IP:", whitelist[0] print "Number of allowed addresses:", len(whitelist)