def callback(self, context, dt): self.delta += dt if self.state == 0: h.touch_file(h.path('src', 'src5.c')) self.state = 1 if self.delta > 0.5: h.touch_file(h.path('src', 'sub', 'src6.c')) if self.delta > 1.0: return False return True
def alias(): import json import helpers actionList = json.loads( helpers.read_file('{}/{}'.format(helpers.path('util'), 'action-list.json'))) bashrcFilepath = helpers.run_command_output('cd {} && cd ../'.format( helpers.path('util'))) + '.baconrc' contents = helpers.read_file(bashrcFilepath) pat = re.compile('alias {}='.format()) match = re.search(pat, contents) formattedAlias = '\nalias {}="python {}/actions.py"'.format( actionList['alias'], helpers.path('util')) if not match: contents += formattedAlias helpers.write_file(bashrcFilepath, contents)
def test_find_most_sleepy_guard(self): entries = read_raw_entries(path(__file__, 'test-input.txt')) shifts = process_shifts(entries) guard, mins_asleep = find_most_sleepy_guard(shifts) self.assertEqual(10, guard) self.assertEqual(50, mins_asleep)
def test_find_most_sleepy_minute(self): entries = read_raw_entries(path(__file__, 'test-input.txt')) shifts = process_shifts(entries) guard, mins_asleep = find_most_sleepy_guard(shifts) min = find_sleepiest_minute(guard, shifts) self.assertEqual(24, min)
def profile(): import helpers import os utilDir = helpers.path('util') if not os.path.exists(utilDir + '/profiles/profile.py'): snippet = '''{\n\t"settings" : {\n\n\t\t}\n}''' helpers.run_command('mkdir {}/profiles'.format(utilDir), False) helpers.write_file(utilDir + '/profiles/profile.py', snippet) print("\nprofile added!\n") msg.done
def helpers(): import helpers # get bacon filepath baconHelpersFilepath = helpers.run_command_output( 'cd {} && cd ../ && pwd'.format(helpers.path('util'))).replace( '\n', '') + '/bacon/template/helpers.py' utilityHelpersFilepath = '/{}/{}'.format(helpers.path('util'), 'helpers.py') # get target helpers content content = helpers.read_file(utilityHelpersFilepath) customHelpers = content.split( "# custom helpers start here\n# =========================")[1] # get default helpers template from bacon newDefaultHelpers = helpers.read_file(baconHelpersFilepath) # pack content and save newContent = newDefaultHelpers + customHelpers # print(newContent) helpers.write_file(utilityHelpersFilepath, newContent) msg.done()
def test_movement(self): entries = read_raw_entries(path(__file__, 'tests/movement.txt')) grid_map, elves, goblins = parse_map(entries) print_state('Initial', grid_map, elves, goblins) for i in range(5): j = 0 for f in sort_fighters(elves, goblins): j += 1 f.move(grid_map, elves + goblins) print_state('{}.{}'.format(i, j), grid_map, elves, goblins)
def test_target_selection(self): entries = read_raw_entries( path(__file__, 'tests/target_selection/start_map.txt')) grid_map, elves, goblins = parse_map(entries) print_state('Initial', grid_map, elves, goblins) i = 0 for f in sort_fighters(elves, goblins): i += 1 f.move(grid_map, elves + goblins) print_state('0.{}'.format(i), grid_map, elves, goblins)
def __init__(self, models): super(SimulatorC2, self).__init__() self.name = self.__class__.__name__ # Modelica package dependencies self.deps = ['FluidJM', 'DHP'] # Path to dependencies and problem self.paths = helpers.path(self.deps, models['file']) # Compiler options self.options = { "state_initial_equations": True, "enable_variable_scaling": True } self.simulator_model = models['sim'] self.optimization_problem = models['opt'] self.load()
def __init__(self, models): super(SimulatorC2, self).__init__() self.name = self.__class__.__name__ # Modelica package dependencies self.deps = ['FluidJM', 'DHP'] # Path to dependencies and problem self.paths = helpers.path(self.deps, models['file']) # Compiler options self.options = { "state_initial_equations": True, "enable_variable_scaling": True } self.simulator_model = models['sim'] self.optimization_problem = models['opt'] self.load()
def test_process_shifts(self): entries = read_raw_entries(path(__file__, 'test-input.txt')) shifts = process_shifts(entries) self.assertEqual(5, len(shifts)) self.assertEqual(10, shifts[0].guard_id) self.assertEqual(datetime.date(1518, 11, 1), shifts[0].date) self.assertEqual(5, shifts[0].sleep_times[0].sleep_start) self.assertEqual(25, shifts[0].sleep_times[0].sleep_until) self.assertEqual(20, shifts[0].sleep_times[0].mins_asleep()) self.assertEqual(30, shifts[0].sleep_times[1].sleep_start) self.assertEqual(55, shifts[0].sleep_times[1].sleep_until) self.assertEqual(25, shifts[0].sleep_times[1].mins_asleep()) self.assertEqual(45, shifts[0].mins_asleep()) self.assertEqual( list(range(5, 25)) + list(range(30, 55)), shifts[0].list_of_mins())
def execute(): baconBitsPath = helpers.run_command_output('cd {} && cd ../ && pwd'.format(helpers.path('util')), False).replace('\n', '') baconrcFile = baconBitsPath + '/.baconrc' DATA = helpers.read_file(baconrcFile) utilList = os.listdir(baconBitsPath) addPerks = helpers.kv_set(settings, 'perks') count = 0 # print(utilList) # print(addPerks) APPENDED_DATA_STR = DATA for item in utilList: path = baconBitsPath + '/' + item try: alias = helpers.get_alias(path) except: alias = False if alias: aliasStr = 'alias {ALIAS}="python {PATH}/actions.py"'.format(ALIAS= alias, PATH= path) # print(aliasStr) pat = re.compile(aliasStr) match = re.search(pat, DATA) if not match: count += 1 print('\nadding alias: {}'.format(alias)) APPENDED_DATA_STR += '\n' + aliasStr if addPerks == "True" or addPerks == "true": aliasStrGoto = ''' elif [ $1 = "{ALIAS}" ]; then cd {PATH} #~~~ bacon:goto placeholder'''.format(ALIAS= alias, PATH= path) aliasStrShowme = ''' elif [ $1 = "{ALIAS}" ]; then open {PATH} #~~~ bacon:showme placeholder'''.format(ALIAS= alias, PATH= path) APPENDED_DATA_STR = APPENDED_DATA_STR.replace(' #~~~ bacon:goto placeholder', aliasStrGoto) APPENDED_DATA_STR = APPENDED_DATA_STR.replace(' #~~~ bacon:showme placeholder', aliasStrShowme) if count > 0: helpers.write_file(baconrcFile, APPENDED_DATA_STR) else: print("\n:: Nothing to add ::") msg.done()
def execute(): baconBitsPath = helpers.run_command_output( 'cd {} && cd ../ && pwd'.format(helpers.path('util')), False).replace('\n', '') baconrcFile = baconBitsPath + '/.baconrc' DATA = helpers.read_file(baconrcFile) utilList = os.listdir(baconBitsPath) count = 0 # print(utilList) MODIFIED_DATA_STR = DATA for item in utilList: path = baconBitsPath + '/' + item try: alias = helpers.get_alias(path) except: alias = False if alias: aliasStr1 = ''' elif [ $1 = "{ALIAS}" ]; then cd {PATH} #~~~ bacon:goto placeholder'''.format(ALIAS=alias, PATH=path) aliasStr2 = ''' elif [ $1 = "{ALIAS}" ]; then open {PATH} #~~~ bacon:showme placeholder'''.format(ALIAS=alias, PATH=path) pat = re.compile( 'elif \[ \$1 = "{ALIAS}" \]; then'.format(ALIAS=alias)) match = re.search(pat, DATA) if not match: count += 1 print('\nadding utility to goto and showme: {}'.format(alias)) MODIFIED_DATA_STR = MODIFIED_DATA_STR.replace( ' #~~~ bacon:goto placeholder', aliasStr1) MODIFIED_DATA_STR = MODIFIED_DATA_STR.replace( ' #~~~ bacon:showme placeholder', aliasStr2) if count > 0: helpers.write_file(baconrcFile, MODIFIED_DATA_STR) else: print("\n:: Nothing to add ::") msg.done()
def test_example_2_with_boost(self): entries = read_raw_entries(path(__file__, 'test-input.txt')) armies = parse_input(entries) r, imm_system_wins = solve_24(armies, 1570) self.assertEqual(51, r) self.assertTrue(imm_system_wins)
def test_sample(self): entries = read_raw_entries(path(__file__, 'test-input.txt')) r = solve_18(entries) self.assertEqual(1147, r)
import helpers, json actionList = json.loads( helpers.read_file('{}/{}'.format(helpers.path('util'), 'action-list.json'))) def statusMessage(): if len(actionList['actions']) > 0: print("") for item in actionList['actions']: print('''[ {} {} ]\t\t{}'''.format(actionList['alias'], item['name'], item['description'])) print("") else: print(''' <tool-name> is working successfully! ''') def done(): print(''' [ Process Completed ] ''') def example(): print(''' process working! ''')
def test_example_1(self): entries = read_raw_entries(path(__file__, 'test-input.txt')) armies = parse_input(entries) r, imm_system_wins = solve_24(armies) self.assertEqual(5216, r) self.assertFalse(imm_system_wins)
def test_example(self): stars = read_stars(path(__file__, 'test-input.txt')) solve_10(stars)
def test_solve_7a(self): entries = read_raw_entries(path(__file__, 'test-input.txt')) steps = process_into_steps(entries, 0) r = solve_7a(steps) self.assertEqual('CABDFE', r)
def test_puzzle_sample_1(self): r = run_puzzle(path(__file__, 'test-data/01b-sample-1.txt')) self.assertEqual(0, r)
def test_example(self): nanobots = parse_input(path(__file__, 'test-input.txt')) in_range = solve_23(nanobots) self.assertEqual(7, in_range)
def test_example_1_with_additional_point(self): points = parse_input( path(__file__, 'test-input-1-with-additional-point.txt')) c = solve_25(points) self.assertEqual(1, c)
break if star.has_neighbor(stars): neighbor_count += 1 else: lone_stars += 1 if lone_stars > lone_star_threshold: break if run and (neighbor_count / len(stars) > 0.5): print(time) print_sky(stars) for star in stars: star.update() time += 1 def get_sky_range(stars): min_x = min(stars, key=lambda s: s.x).x max_x = max(stars, key=lambda s: s.x).x min_y = min(stars, key=lambda s: s.y).y max_y = max(stars, key=lambda s: s.y).y return max_x, max_y, min_x, min_y if __name__ == '__main__': stars = read_stars(path(__file__, 'input.txt')) solve_10(stars)
def test_example_1(self): points = parse_input(path(__file__, 'test-input-1.txt')) c = solve_25(points) self.assertEqual(2, c)
polymer = new_polymer return polymer def solve_5b(polymer): letters = list(string.ascii_lowercase) shortest_polymer = len(polymer) * 2 for letter in letters: print(letter) stripped = re.sub(r'[{}{}]'.format(letter, letter.swapcase()), '', polymer) print('{} stripped length: {}'.format(letter, len(stripped))) compressed_polymer_length = len(solve_try_1(stripped)) if (compressed_polymer_length) < shortest_polymer: shortest_polymer = compressed_polymer_length return shortest_polymer if __name__ == '__main__': polymer = read_raw_entries(path(__file__, 'input.txt'))[0] result = solve_try_1(polymer) print('Compressed polymer length: {}'.format(len(result))) polymer = read_raw_entries(path(__file__, 'input.txt'))[0] result = solve_5b(polymer) print('Shortest possible compressed polymer length: {}'.format(result))
def actionlist(): import helpers helpers.run_command('code {}/action-list.json'.format( helpers.path('util')))
key=lambda kv: kv[1]) return sorted_influence_list[len(sorted_influence_list) - 1][1] def solve_6b(points, threshold): grid, max_x, max_y, min_x, min_y = setup_grid(points) total_size = 0 for i in range(min_x, max_x + 1): for j in range(min_y, max_y + 1): if grid[i][j].is_within_threshold(threshold): total_size += 1 return total_size if __name__ == '__main__': entries = read_raw_entries(path(__file__, 'input.txt')) points = convert_points(entries) r = solve_6a(points) print('Largest size: {}'.format(r)) entries = read_raw_entries(path(__file__, 'input.txt')) points = convert_points(entries) r = solve_6b(points, 10000) print('Largest size: {}'.format(r))
def test_solve_6a(self): entries = read_raw_entries(path(__file__, 'test-input.txt')) points = convert_points(entries) r = solve_6a(points) self.assertEqual(17, r)
def test_example_part_2(self): nanobots = parse_input(path(__file__, 'test-input-part-2.txt')) distance = solve_23_part_2(nanobots) self.assertEqual(36, distance)
return max(scores) def solve_9_with_deque(input: str, multiplier: int = 1): player_count, last_marble_value = parse_params(input) last_marble_value *= multiplier scores: List[int] = [] for i in range(0, player_count): scores.append(0) circle = DequeCircle() marble_value = 1 while marble_value <= last_marble_value: score, string_rep = circle.add_marble(marble_value) scores[(marble_value - 1) % player_count] += score marble_value += 1 return max(scores) if __name__ == '__main__': input = read_raw_entries(path(__file__, 'input.txt'))[0].strip() r = solve_9(input, 1) print('9a. Winning score: {}'.format(r)) input = read_raw_entries(path(__file__, 'input.txt'))[0].strip() r = solve_9(input, 100) print('9b. Winning score: {}'.format(r))
def do_action(ARGS): import helpers argDict = helpers.arguments(ARGS) name = helpers.path('util').split('/')[-1] fullPath = helpers.path('util') titleString = "Action" if argDict: if 'args' in argDict: if argDict['args'] == 'true': titleString = "Action With Arguments" newFeature = helpers.user_input(''' -- New {} -- Please give your new action a name [Eg: OpenFile]: '''.format(titleString)) newAction = helpers.user_input(''' What would you like to call the action? ''') basicSnippet = '''import messages as msg import helpers # settings = helpers.get_settings() def execute(): msg.example() ''' argSnippet = '''import messages as msg import helpers # settings = helpers.get_settings() def execute(ARGS): argDict = helpers.arguments(ARGS) print(argDict) ''' finalPath = helpers.path('util') + '/' + newFeature + '.py' statusMsg = ''' NAME: {} NEW MODULE: {} NEW ACTION: {} LOCATION: {}'''.format(name, newFeature, newAction, finalPath) print(statusMsg) template = basicSnippet if argDict: if 'args' in argDict: if argDict['args'] == 'true': template = argSnippet helpers.write_file(finalPath, template) data = helpers.read_file(fullPath + '/actions.py') data = data.replace( '# new imports start here', '''import {} # new imports start here'''.format(newFeature)) basicContent = ''' elif action == "{newAction}": {newFeature}.execute() # new actions start here'''.format(newFeature=newFeature, newAction=newAction) argContent = ''' elif action == "{newAction}": {newFeature}.execute(args) # new actions start here'''.format(newFeature=newFeature, newAction=newAction) newContent = basicContent if argDict: if 'args' in argDict: if argDict['args'] == 'true': newContent = argContent data = data.replace("# new actions start here", newContent) helpers.write_file(fullPath + '/actions.py', data) actionData = json.loads(helpers.read_file(fullPath + '/action-list.json')) newItem = {} newItem['name'] = newAction newItem['description'] = '' actionData['actions'].append(newItem) helpers.write_file(fullPath + '/action-list.json', json.dumps(actionData, indent=4)) msg.done()
def test_example_1(self): entries = read_raw_entries(path(__file__, 'test-input.txt')) r = solve_12_good(entries) self.assertEqual(325, r)