def cadusers(): users = { 'nome': '', 'sobrenome': '', 'login': '', 'senha': '', 'conf_senha': '', } print("#" * 30) print("Cadastro de Usuários.") print("Precione 'q' para sair.") print("#" * 30) while True: users['nome'] = get_input("Digite o nome do usuário: ") if users['nome'] == 'q': break users.clean() users['sobrenome'] = get_input("Digite o sobrenome do usuário: ") if users['sobrenome'] == 'q': break users.clean() users['login'] = get_input("Digite o login do usuário: ") if users['login'] == 'q': break users.clean() users['senha'] = getpass("Digite a senha do usuário: ") if users['login'] == 'q': break users.clean() users['conf_senha'] = getpass("Confirme a senha do usuário: ") if users['login'] == 'q': break users.clean() save = get_input("Deseja salvar as informações do usuário? 's'/'n': ") if save == 's': colunas = users.keys() values = users.values() insert_info = ("INSERT INTO Users (%s) VALUES ('%s')" % (",".join(colunas), "','".join(values))) connsql(insert_info) print("Dados salvos com sucesso!") else: break new_user = get_input("Deseja cadastrar outro usuário? 's'/'n': ") if new_user == 's': continue else: break
def test_code(): assert code('""') == '' assert code('"abc"') == 'abc' assert code('"aaa\"aaa"') == 'aaa"aaa' assert code('"\x27"') == "'" for line in get_input(day=8, year=2015).splitlines(): assert eval(line) == code(line)
def test_escape(): assert escape('""') == r'"\"\""' assert escape('"abc"') == r'"\"abc\""' assert escape(r'"aaa\"aaa"') == r'"\"aaa\\\"aaa\""' assert escape(r'"\x27"') == r'"\"\\x27\""' for line in get_input(day=8, year=2015).splitlines(): assert line == code(escape(line))
def main(): # get input file name from command line argument file_name = sys.argv[1] start_time = time.time() # parse the input and return a list of cards list_of_cards = get_input.get_input(file_name) # find the number of SET's no_of_sets, list_of_sets = find_sets.find_set(list_of_cards) # find the disjoint SET's no_of_disjoint_sets, list_of_disjoint_sets = find_disjoint_sets.find_disjoint( list_of_sets) print("Execution time : %s" % (time.time() - start_time)) # print the results print(no_of_sets) print(no_of_disjoint_sets) print() for y in list_of_disjoint_sets: for z in range(3): print(y[z]) print() print("Execution time : %s" % (time.time() - start_time))
def main(strExp="", vbose=False): from output import verbose_output, touch, folder_maker from get_input import get_input, format_input # Set the input string expression (strExp) if strExp == "": strExp = get_input() else: strExp = format_input(strExp) #process parsed elements into the folder object result_folder = parse(strExp[1:-1], fold()) if vbose: try: verbose_output(result_folder, "") except: print "VERBOSE_OUTPUT ERROR" try: folder_maker(result_folder, "./") except: print "FOLDER_MAKER ERROR" return result_folder
def main(): day = int(os.path.basename(__file__).replace('day', '').replace('.py', '')) data = get_input.get_input(day) hvac_map = Map(data) poi = {} for i, c in enumerate(hvac_map): if c.isdigit(): poi[int(c)] = i n_poi = len(poi) dists = np.zeros((n_poi, n_poi), dtype=np.int32) for a, b in combinations(range(n_poi), 2): pos_a = poi[a] pos_b = poi[b] steps = hvac_map.get_steps(pos_a, pos_b) dists[a, b] = dists[b, a] = steps # Part 1: Random end position total_dist_min = 1e10 for order in permutations(range(1, n_poi)): order = [0] + list(order) total_dist = 0 for i in range(1, len(order)): total_dist += dists[order[i - 1], order[i]] if total_dist < total_dist_min: total_dist_min = total_dist print( 'Minimum steps to visit all important places starting at 0: {}'.format( total_dist_min)) # Part 2: Back to position 0 total_dist_min = 1e10 for order in permutations(range(1, n_poi)): order = [0] + list(order) + [0] total_dist = 0 for i in range(1, len(order)): total_dist += dists[order[i - 1], order[i]] if total_dist < total_dist_min: total_dist_min = total_dist print( 'Minimum steps to visit all important places starting at 0 and back to 0: {}' .format(total_dist_min))
def hello_world(): speak = "Wow, you look really sad! Try smiling more!" play_audio(speak) speak = "What is your number 1 goal for today?" play_audio(speak) userInput = get_input() analyzed = analyze_text(userInput) print("Analyzed: " + analyzed) quote = get_quotes(analyzed) play_audio(quote)
def select_model(): net_options = list('to ' + net_name + ' press ' + str(i) for i, net_name in enumerate(MY_NETS)) message = 'Please select the requested net:\n' net_name = get_input(message, net_options, MY_NETS) if net_name == DEBLUR: deblur = Deblur() blur = Blur() return deblur, blur, net_name else: denoise = Denoise() noise = Noise() return denoise, noise, net_name
def main(): day = int(os.path.basename(__file__).replace('day', '').replace('.py', '')) data = get_input.get_input(day) # Altered data, changed multiplying loops to single command for speedup data = """cpy a b dec b cpy a d cpy 0 a cpy b c nop #inc a nop #dec c nop #jnz c -2 nop #dec d mtp a c d #jnz d -5 dec b cpy b c cpy c d dec d inc c jnz d -2 tgl c cpy -16 c jnz 1 c cpy 78 c jnz 70 d nop #inc a nop #inc d nop #jnz d -2 nop #inc c mtp a c d #jnz c -5""" lines = data.split('\n') lines_parts = [] for line in lines: lines_parts.append(line.split(' ')) reg = {'a': 7, 'b': 0, 'c': 0, 'd': 0} reg = assem(reg, deepcopy(lines_parts)) print('Value in register a for input 7: {}'.format(reg['a'])) reg = {'a': 12, 'b': 0, 'c': 0, 'd': 0} reg = assem(reg, deepcopy(lines_parts)) print('Value in register a for input 12: {}'.format(reg['a']))
def main(): output_dir,iPod_drive,music_dir,song_db_loc = get_input() print "output directory: {0}".format(output_dir) print "iPod: {0}".format(iPod_drive) print "music directory: {0}".format(music_dir) tag_list,attrib_key_dict,attrib_dict = load_database(iPod_drive,music_dir,song_db_loc) print print "Now that setup has been taken care of, welcome! This application was designed to assist you in copying songs from your iPod to your computer. While this application allows for filtering by different attributes, the central feature is the ability to rename your files based on their metadata. Enjoy!" print "For help, simply type the word \"help\"." while True: choice_num,choice_str = prompt(actions,2,message="Please select an action",hidden_options={"help":False}) perform_action(choice_str,iPod_drive,output_dir,tag_list)
def main(): # 模式选择 mode, file_old_, file_new_, image_new_folder, \ b_path_type_img_folder, b_keep_structure, \ b_keep_original_img, b_download_web_image, b_convert_to_relative_path = get_input() file_old_path_ls, file_new_path_ls, image_new_folder_ls = [], [], [] if mode == "Folder": file_old_folder, file_new_folder = file_old_, file_new_ file_old_path_ls = search_file_flat(file_old_folder, suffix_ls=[".md"], flag_ls=None, case_sensitive=False) for file_old_path in file_old_path_ls: if b_keep_structure: # file_old_folder/b/c/xxx.md ==> file_new_folder/b/c/xxx.md file_new_path = file_new_folder + file_old_path.split(file_old_folder)[1] else: # file_old_folder/b/c/xxx.md ==> file_new_folder/xxx.md file_new_path = os.path.join(file_new_folder, os.path.split(file_old_path)[1]) image_new_folder_trans = deal_with_image_folder_path(image_new_folder, b_path_type_img_folder, file_new_path) file_new_path_ls.append(file_new_path) image_new_folder_ls.append(image_new_folder_trans) elif mode == "File": file_old_path, file_new_path = file_old_, file_new_ image_new_folder_trans = deal_with_image_folder_path(image_new_folder, b_path_type_img_folder, file_new_path) file_old_path_ls.append(file_old_path) file_new_path_ls.append(file_new_path) image_new_folder_ls.append(image_new_folder_trans) # print(file_old_path_ls) # print(file_new_path_ls) # print(image_new_folder_ls) for i in range(len(file_new_path_ls)): steward(file_old_path_ls[i], file_new_path_ls[i], image_new_folder_ls[i], b_convert_to_relative_path, b_download_web_image, b_keep_original_img) print("\nCongratulations, accomplished!\nThe output path is %s\n\n(/≧▽≦)/\n" % file_new_)
return start def part1(boardingpasses): max_id = 0 for boardingpass in boardingpasses: row = binary_search([char == "F" for char in boardingpass[:7]], 0, 127) col = binary_search([char == "L" for char in boardingpass[7:]], 0, 7) max_id = max(row * 8 + col, max_id) return max_id def part2(boardingpasses): seats = {(row, col) for row in range(128) for col in range(8)} for boardingpass in boardingpasses: row = binary_search([char == "F" for char in boardingpass[:7]], 0, 127) col = binary_search([char == "L" for char in boardingpass[7:]], 0, 7) seats.remove((row, col)) seat = [s for s in seats if 10 < s[0] and s[0] < 100] assert len(seat) == 1 seat = seat.pop() return seat[0] * 8 + seat[1] if __name__ == "__main__": LINES = line_parser(get_input(day=5, year=2020), parse=list) assert binary_search([c == "F" for c in "FBFBBFF"], 0, 127) == 44 assert binary_search([c == 'L' for c in "RLR"], 0, 7) == 5 print(f"Part 1: {part1(LINES)}") print(f"Part 2: {part2(LINES)}")
for bot in runner.run(output='bot'): for b, bot in bot.items(): if 61 in bot and 17 in bot: return b text = """ value 5 goes to bot 2 bot 2 gives low to bot 1 and high to bot 0 value 3 goes to bot 1 bot 1 gives low to output 1 and high to bot 0 bot 0 gives low to output 2 and high to output 0 value 2 goes to bot 2 """ def test_runner(): runner = Runner(text.strip()) for bots in runner.run('bot'): print(bots) assert runner.output == {0:{5,}, 1:{2,}, 2:{3,}} def part2(runner): runner = deepcopy(runner) for output in runner.run(output='output'): if len(output[0]) > 0 and len(output[1]) > 0 and len(output[2]) > 0: return output[0].pop() * output[1].pop() * output[2].pop() if __name__ == '__main__': runner = Runner(get_input(day=10, year=2016)) print("Part 1: {}".format(part1(runner))) print("Part 2: {}".format(part2(runner)))
'''Program for calling the function for smart input''' import get_input default_length = 30 input_type="" length = 0 action = "lenient" ch = raw_input("What type of Input do you Want (1 - Name 2-Number) : ") if ch == "1": input_type = "name" elif ch =="2": input_type = "number" d=raw_input("\n\nEnter the Max Length : ") try: length = int(d) except: length = default_length if input_type == "number": action = raw_input("\n\nEnter the Mode for length (strict or lenient) :") action = action.lower() print "" print get_input.get_input(input_type,length,action)
dest = cups.value - 1 skip = { first.value, first.next.value, first.next.next.value, } while not (0 < dest <= num_nodes) or dest in skip: dest -= 1 if dest <= 0: dest = num_nodes index = values[dest] last.next = index.next index.next = first cups = cups.next print() index = values[1] return index.next.value * index.next.next.value def parse(text): return tuple(int(c) for c in text) if __name__ == "__main__": assert part1(parse('389125467'), rounds=10) == 92658374 assert part1(parse('389125467'), rounds=100) == 67384529 assert part2(parse('389125467')) == 149245887792 LINES = parse(get_input(day=23, year=2020).strip()) print(f"Part 1: {part1(LINES)}") print(f"Part 2: {part2(LINES)}")
birthdate:<mm/dd/yyyy> """ bday_book = {} data = read_file(file_name) assert data, "There is no data!" data_chunks = chunk_data(data, 3) for chunk in data_chunks: username = parse(r"username:(?P<username>[\w.-]+)", 'username', chunk[0]) nationality = parse("nationality:(?P<nationality>[a-zA-Z]+ ?[a-zA-Z]*)", "nationality", chunk[1], ) birthdate = parse("birthdate:(?P<birthdate>[0-9]{1,2}/[0-9]{1,2}/[0-9]{4})", "birthdate", chunk[2], ) if username and nationality and birthdate: bday_book[username] = User(username, nationality, birthdate) return bday_book if __name__ == "__main__": FILE = 'user_data.txt' # Enter filename here. BDAY_BOOK = build_bday_book(FILE) USERNAME = get_input().lower() while not USERNAME.isspace() and USERNAME: if USERNAME in BDAY_BOOK: BDAY_BOOK[USERNAME].print_birthdate() else: print "Sorry, user not found." USERNAME = get_input().lower()
def part2(directions): position = (0, 0) heading = (0, 1) visited = set() turn = { 'R': lambda m: (-m[1], m[0]), 'L': lambda m: (m[1], -m[0]), } for t, d in directions: heading = turn[t](heading) for _ in range(d): if position in visited: break visited.add(position) position = tuple(p + h for p, h in zip(position, heading)) return sum(abs(p) for p in position) def parse(line): turn = line[0] steps = int(line[1:]) return (turn, steps) if __name__ == '__main__': directions = line_parser(get_input(day=1, year=2016), parse=parse, seperator=", ") print("Part 1: {}".format(part1(directions))) print("Part 2: {}".format(part2(directions)))
def part1(groups): result = 0 for group in groups: result += len(set(answer for person in group for answer in person)) return result def part2(groups): result = 0 for group in groups: result += sum(1 for q in set( answer for person in group for answer in person) if all(q in person for person in group)) return result def parse(text): result = [[]] for line in text.splitlines(): if line == "": result.append([]) else: result[-1].append(list(line)) return result if __name__ == "__main__": LINES = parse(get_input(day=6, year=2020)) print(f"Part 1: {part1(LINES)}") print(f"Part 2: {part2(LINES)}")
grid[pos] = '#' elif grid[pos] == 'F': grid[pos] = '.' head = reverse(head) elif grid[pos] == '#': head = turn_right(head) grid[pos] = 'F' pos = move(pos, head) return count def test_part2(): test = "..#\n#..\n...".splitlines() assert 26 == part2(parse(test), iters=100) assert 2511944 == part2(parse(test), iters=10000000) def parse(lines): grid = defaultdict(lambda: '.') height, width = len(lines), len(lines[0]) for r, row in enumerate(lines, -(height // 2)): for c, char in enumerate(row, -(width // 2)): grid[(r, c)] = char return grid if __name__ == '__main__': grid = parse(get_input(day=22, year=2017).splitlines()) print('Part 1: {}'.format(part1(grid))) print('Part 2: {}'.format(part2(grid)))
def main(lambda2): X = get_input("input_pos_neg.txt") m = 0 m_pos = 0 m_neg = 0 m_distinct_X = len(X) for (pos,neg,s) in X: m_pos += pos m_neg += neg m += pos + neg print 'm,m_pos,m_neg=',m,m_pos,m_neg theta_max_pos = 1.0*m_neg/m theta_max_neg = 1.0*m_pos/m tmp = Xtheta_mapper(X) # Z = X' * theta_max Z = Xtheta_reducer(tmp,theta_max_pos,theta_max_neg) lambda_max = max([abs(w)for w in Z.itervalues()])/m print 'lambda_max = ',lambda_max,'lambda2 = ',lambda2 ''' sum_b= [e[0]for e in X] for i in range(m-1): sum_b[i+1] += sum_b[i] ''' if lambda2>=lambda_max: print "lambda2 >= lambda_max" return print "get len_of_X_column" tmp = projection_scale_mapper(X) #PX len_of_X_column = projection_scale_reducer(tmp) j0 = 0 sign_j0 = 0 mi = m for (k,v) in Z.items(): #print abs(v),m*lambda_max if abs(abs(v)-m*lambda_max)<1e-10: # theta*Xj == m*lambda_max if len_of_X_column[k]<mi: # find j0 with the sparsest column mi = len_of_X_column[k] j0 = k if v > 0: sign_j0 = 1 elif v < 0: sign_j0 = -1 else: sign_j0 = 0 print 'j0 = ',j0 X_raw_star = tmp[j0] # j0th column of X, list of instance_id L_X_star = mi #print 'length of X_raw_star', len(X_raw_star) P_X_star = [(instance_id,sign_j0*(1.0-1.0*L_X_star/m),pos+neg) for (pos,neg,instance_id) in X_raw_star] #PX*, list of (instance_id, a, b) sign_P_X_star_b = -1.0*sign_j0*L_X_star/m hash_P_X_star = [0] * m_distinct_X hash_P_X_star_a = [0] * m_distinct_X sum_a_star_p_n = 0 sum_a_star_square_p_n = 0 for (idx,a,p_n) in P_X_star: sum_a_star_p_n += a*p_n sum_a_star_square_p_n+=a*a*p_n hash_P_X_star_a[idx] = a for (pos,neg,index) in X_raw_star: hash_P_X_star[index]=1 print 'sum_a_star_p_n ', sum_a_star_p_n, ' sum_a_star_square_p_n ',sum_a_star_square_p_n print 'sign_P_X_star_b ', sign_P_X_star_b P_X_star_norm2 = norm2(P_X_star,sign_P_X_star_b,m) print 'P_X_star_norm2 ',P_X_star_norm2 print 'length of P_X_star = ',len(P_X_star) #X_raw_star = [feature_key,feature_key,...] #len_of_X_column = {column_id:len} r = g(theta_max_pos,theta_max_neg,m_pos,m_neg,lambda2/lambda_max) - g(theta_max_pos,theta_max_neg,m_pos,m_neg,1) r += (1-lambda2/lambda_max)*(m_pos*math.log(theta_max_pos/(1.0 - theta_max_pos))*theta_max_pos + m_neg*math.log(theta_max_neg/(1.0 - theta_max_neg))*theta_max_neg)/m r = math.sqrt(r*m/2.0) print 'r ',r #print j0,sign_j0 print "final step" tmp = final_mapper(X,len_of_X_column,hash_P_X_star,hash_P_X_star_a) rejection_features = final_reducer(tmp,m,P_X_star,sign_P_X_star_b,lambda2,lambda_max,sign_j0,r,Z,P_X_star_norm2,L_X_star,sum_a_star_p_n,sum_a_star_square_p_n) print 'rejection length = ',len(rejection_features) Y = [] length_feature_before = 0 length_feature_after = 0 for (pos,neg,s) in X: nt = [] for t in s: if not t in rejection_features: nt.append(t) Y.append([pos,neg,nt]) length_feature_after+=len(nt) length_feature_before +=len(s) print 'average length of feature before',length_feature_before*1.0/len(X),'after',length_feature_after*1.0/len(X), save_X(Y,'input_after_filter.txt')
brute_gen = lambda n: ((k // 2) + 1 for k in reversed(range(n-1))) assert brute(i, brute_gen(i)) == josephus(i, joseph_gen(i)) def brute(n_elves, k_gen, debug=False): elves = list(range(1, n_elves+1)) e = 0 for kill in k_gen: if len(elves) == 1: break log.debug('{}: {}'.format(kill, elves)) elves.pop(kill) elves.append(elves.pop(0)) assert len(elves) != 0 return elves[0] def test_brute(): assert 3 == brute(5, cycle([1])) assert 2 == brute(5, ((k // 2) + 1 for k in reversed(range(5-1)))) assert 3 == brute(6, ((k // 2) + 1 for k in reversed(range(6-1)))) assert 5 == brute(7, ((k // 2) + 1 for k in reversed(range(7-1)))) def part2(n): kills = ((k // 2) + 1 for k in range(n-1)) return josephus(n, kills) if __name__ == '__main__': log.setLevel(logging.INFO) lines = int(get_input(day=19, year=2016).strip()) print("Part 1: {}".format(part1(lines))) print("Part 2: {}".format(part2(lines)))
i = 0 while i < len(text): m = re.match(r'^\((\d+)x(\d+)\)', text[i:]) if m is None: group += text[i] i += 1 else: if group is not '': groups.append((1, group)) group = '' i += m.end(0) chars, repeat = (int(g) for g in m.groups()) if recurse: groups.append((repeat, parse(text[i:i + chars], recurse=True))) else: groups.append((repeat, text[i:i + chars])) i += chars if group is not '': groups.append((1, group)) return groups def test_decompress_len(): assert part2("(3x3)XYZ") == 9 if __name__ == '__main__': lines = get_input(day=9, year=2016).strip() print("Part 1: {}".format(part1(lines))) print("Part 2: {}".format(part2(lines)))
#!/usr/bin/env python3 from get_input import get_input, line_parser from collections import Counter def part1(lines): phrase_counter = [Counter() for _ in range(len(lines[0]))] for line in lines: for i, c in enumerate(line): phrase_counter[i][c] += 1 return ''.join(max(p.items(), key=lambda q: q[1])[0] for p in phrase_counter) def part2(lines): phrase_counter = [Counter() for _ in range(len(lines[0]))] for line in lines: for i, c in enumerate(line): phrase_counter[i][c] += 1 return ''.join(min(p.items(), key=lambda q: q[1])[0] for p in phrase_counter) if __name__ == '__main__': lines = line_parser(get_input(day=6, year=2016), parse=lambda l: tuple(l), seperator='\n') print("Part 1: {}".format(part1(lines))) print("Part 2: {}".format(part2(lines)))
return state.path for step in state.directions(): if 0 <= step.x < 4 and 0 <= step.y < 4: queue.append(step) def test_part1(): assert 'DDRRRD' == part1('ihgpwlah') assert 'DDUDRLRRUDRD' == part1('kglvqrro') assert 'DRURDRUDDLLDLUURRDULRLDUUDDDRR' == part1('ulqzkmiv') def part2(prefix): queue = [MazeState(prefix)] longest = None while queue: state = queue.pop(0) if state.x == 3 and state.y == 3: longest = state continue for step in state.directions(): if 0 <= step.x < 4 and 0 <= step.y < 4: queue.append(step) return len(longest.path) if __name__ == '__main__': prefix = get_input(day=17, year=2016).strip() print('Part 1: {}'.format(part1(prefix))) print('Part 2: {}'.format(part2(prefix)))
def part1(lines): door_public, card_public = lines door_loop = None card_loop = None loop_number = 1 public = 7 while door_loop is None or card_loop is None: print(f"{loop_number}: {public}") loop_number += 1 public = (7 * public) % 20201227 if card_loop is None and public == card_public: card_loop = loop_number if door_loop is None and public == door_public: door_loop = loop_number private = transform(door_public, card_loop) assert private == transform(card_public, door_loop) return private def part2(lines): return "Merry Christmas!" if __name__ == "__main__": assert part1([17807724, 5764801]) == 14897079 LINES = line_parser(get_input(day=25, year=2020)) print(f"Part 1: {part1(LINES)}") print(f"Part 2: {part2(LINES)}")
if new_molecule == 'e': shortest = steps + 1 return shortest elif new_molecule != molecule and new_molecule not in seen: seen.add(new_molecule) queue.append((steps + 1, new_molecule, 0)) raise ValueError("Cannot make molecule") def test_part2(): replacements = [ ('H', 'HO'), ('H', 'OH'), ('O', 'HH'), ('e', 'H'), ('e', 'O'), ] assert part2(replacements, 'HOHOHO') == 6 def parse(text): lines = text.splitlines() replacements = [tuple(line.split(' => ')) for line in lines[:-2]] return replacements, lines[-1] if __name__ == '__main__': replacements, init = parse(get_input(day=19, year=2015)) print("Part 1: {}".format(part1(replacements, init))) print("Part 2: {}".format(part2(replacements, init)))
"""Take input from a user and print the corresponding acronym.""" from get_input import get_input def generate_acronym(string): """Create an acronym from a given string input and return it.""" words = string.split() letters = [word[0] for word in words] acronym = ''.join(letters) return acronym.upper() if __name__ == "__main__": INPUT = get_input() print generate_acronym(INPUT)
assert list('1') == checksum('00') assert list('0') == checksum('10') assert list('0') == checksum('01') assert list('100') == checksum('110010110100') def expand(curve): new_curve = list(curve) new_curve.append('0') replace = {'0': '1', '1': '0'} for d in reversed(curve): new_curve.append(replace[d]) return new_curve def test_expand(): assert list('100') == expand('1') assert list('001') == expand('0') assert list('11111000000') == expand('11111') assert list('1111000010100101011110000') == expand('111100001010') def part2(line, space=35651584): return part1(line, space=space) if __name__ == '__main__': line = get_input(day=16, year=2016).strip() print('Part 1: {}'.format(part1(line))) print('Part 2: {}'.format(part2(line)))
dist = [0] * buckets dist[0] = volume while True: yield dist dist[0] -= 1 dist[1] += 1 if dist[0] < 0: i = 1 while dist[0] < 0: if i + 1 >= len(dist): raise StopIteration dist[i + 1] += 1 dist[0] += dist[i] - 1 dist[i] = 0 i += 1 def parse(line): ingredient = re.compile( r'(?P<name>\w+): capacity (?P<capacity>-?\d+), ' + 'durability (?P<durability>-?\d+), flavor (?P<flavor>-?\d+), ' + 'texture (?P<texture>-?\d+), calories (?P<calories>-?\d+)') m = ingredient.match(line) return {k: int(v) if k != 'name' else v for k, v in m.groupdict().items()} if __name__ == '__main__': ingredients = line_parser(get_input(day=15, year=2015), parse=parse) print("Part 1: {}".format(part1(ingredients))) print("Part 2: {}".format(part2(ingredients)))
queue.append((i + 1, used + [buckets[i]])) queue.append((i + 1, used)) def test_storage_gen(): buckets = [15, 10, 5, 5, 20] assert len(list(storage_gen(buckets, 25))) == 4 def part1(buckets, volume=150): count = 0 for b in storage_gen(buckets, volume): count += 1 return count def part2(buckets, volume=150): shortest = [] for b in storage_gen(buckets, volume): if shortest == [] or len(b) < len(shortest[0]): shortest = [b] elif len(b) == len(shortest[0]): shortest.append(b) return len(shortest) if __name__ == '__main__': buckets = line_parser(get_input(day=17, year=2015)) print("Part 1: {}".format(part1(buckets))) print("Part 2: {}".format(part2(buckets)))
'samoyeds': lambda v: v == 2, 'pomeranians': lambda v: v < 3, 'akitas': lambda v: v == 0, 'vizslas': lambda v: v == 0, 'goldfish': lambda v: v < 5, 'trees': lambda v: v > 3, 'cars': lambda v: v == 2, 'perfumes': lambda v: v == 1, } aunts = filter_aunts(aunts, props) assert len(aunts) == 1 return list(aunts.keys())[0] def parse(line): aunt_n = line.index(':') aunt = int(line[4:aunt_n]) props = {} for prop in line[aunt_n + 2:].split(', '): k, v = prop.split(': ') props[k] = int(v) return (aunt, props) if __name__ == '__main__': aunts = dict(line_parser(get_input(day=16, year=2015), parse=parse)) # Part 1: 103 # Part 2: 405 print("Part 1: {}".format(part1(aunts))) print("Part 2: {}".format(part2(aunts)))
"""Take input from a user and print out the given input with the white space between words replaced by an underscore.""" from get_input import get_input def replace_space(string): """Replace all the whitespace found in a given string with an underscore and return it. """ return '_'.join(string.split()) if __name__ == "__main__": INPUT = get_input() print replace_space(INPUT)
def decrypt(name, shift): decrypted = [] for char in name: if char == ' ': decrypted.append(char) continue decrypted_char = chr(((ord(char) - ord('a')) + shift) % 26 + ord('a')) decrypted.append(decrypted_char) return ''.join(decrypted) day = int(os.path.basename(__file__).replace('day', '').replace('.py', '')) data = get_input.get_input(day) lines = data.split('\n') sum_sectorIDs = 0 for line in lines: pieces = line.split('-') meta = pieces[-1].split('[') checksum = meta[1].replace(']', '') sectorID = int(meta[0]) char_list = list(itertools.chain.from_iterable(pieces[:-1:])) counted = dict(Counter(char_list)) counted_sorted = OrderedDict(sorted(counted.items(), key=lambda t: (-t[1], ord(t[0]))))
def parameter(): global progress_percentage if request.method == 'GET': try: fn = request.args.get("fn") except TypeError: return "Invalid URL!" return render_template('parameter.html', fn=fn, version=tossa.get_version()) if request.method == 'POST': progress_percentage = 0 #read with open("static/pwords.txt", "r") as f: pwords = f.read().splitlines() with open("static/nwords.txt", "r") as f: nwords = f.read().splitlines() try: n_topics = int(request.values.to_dict().get('n_topics')) probability_threshold = float( request.values.to_dict().get('probability_threshold')) / 100 #add win_size = int(request.values.to_dict().get('win_size')) bigram_min = int(request.values.to_dict().get('bigram_min')) trigram_min = int(request.values.to_dict().get('trigram_min')) assert n_topics > 0 and 0 < probability_threshold < 1 and win_size > 0 and bigram_min > 0 and trigram_min > 0 fn = request.args.get("fn") pwords = list( set(request.values.to_dict().get('pwords').split(';') + pwords)) nwords = list( set(request.values.to_dict().get('nwords').split(';') + nwords)) except: return "Please input valid parameters!" logger.info(f'filename: {fn}; PosWords: {pwords}; NegWords: {nwords};') # analyze and generate files for rendering tossa.preprocess(version=None) progress_percentage += 10 #tossa.parse_dependency() progress_percentage += 10 tossa.build_w2v_model() progress_percentage += 10 tossa.calc_senti_words(pwords, nwords) progress_percentage += 10 #tossa.map_dependency() tossa.topic_modeling(n_topics, 'bigram') progress_percentage += 20 tossa.prepare_review_list(probability_threshold) progress_percentage += 10 # add main_run(n_topics, win_size, bigram_min, trigram_min, fn) progress_percentage += 10 # cmd = "python get_input.py result/youtube " + str(n_topics) # os.system(cmd) get_input(n_topics, fn) progress_percentage += 10 tossa.prepare_summary() progress_percentage += 10 logger.info('Finished processing. Redirecting to summary page...') return redirect(f"/summary?fn={fn}")
def make_set(table, seed): seen = set() queue = [seed] while queue: p = queue.pop() if p not in seen: seen.add(p) queue.extend(table[p]) return seen def part1(table): return len(make_set(table, 0)) def part2(table): return len(set(frozenset(make_set(table, v)) for v in table.keys())) def parse(line): ppid, pids = line.split(' <-> ') return (int(ppid), tuple(int(p) for p in pids.split(', '))) if __name__ == '__main__': table = dict(line_parser(get_input(day=12, year=2017), parse=parse)) print("Part 1: {}".format(part1(table))) print("Part 2: {}".format(part2(table)))