def process_fish(fishies: Iterator[int], days_to_run: int) -> int: fish_dict = count_occurrences(fishies) for _ in range(days_to_run): new_fish_dict = {8: fish_dict.get(0, 0)} for days_left in range(1, 9): new_fish_dict[days_left - 1] = fish_dict.get(days_left, 0) new_fish_dict[6] += fish_dict[0] fish_dict = new_fish_dict return sum(fish_dict.values())
def part_2(path: Path) -> Tuple[int, int]: crab_positions = sorted(read_file_as_ints_2(path)) min_crab_position, max_crab_position = crab_positions[0], crab_positions[ -1] crab_position_dict = count_occurrences(crab_positions) print(crab_positions) print(crab_position_dict) print() crabs_to_the_left = {min_crab_position: 0} for position in range(min_crab_position + 1, max_crab_position + 1): crabs_to_the_left[position] = crabs_to_the_left[ position - 1] + crab_position_dict[position - 1] print(crabs_to_the_left) crabs_to_the_right = {max_crab_position: 0} for position in range(max_crab_position - 1, min_crab_position - 1, -1): crabs_to_the_right[position] = crabs_to_the_right[ position + 1] + crab_position_dict[position + 1] print(crabs_to_the_right) print() move_to_the_right = {min_crab_position: 0} for position in range(min_crab_position + 1, max_crab_position + 1): move_to_the_right[position] = move_to_the_right[position - 1] for position2 in range(min_crab_position, position): move_to_the_right[position] += ( position - position2) * crab_position_dict[position2] print(move_to_the_right) move_to_the_left = {max_crab_position: 0} for position in range(max_crab_position - 1, min_crab_position - 1, -1): move_to_the_left[position] = move_to_the_left[position + 1] for position2 in range(max_crab_position, position, -1): move_to_the_left[position] += ( position2 - position) * crab_position_dict[position2] print(move_to_the_left) min_position = min( range(min_crab_position, max_crab_position + 1), key=lambda p: move_to_the_right[p] + move_to_the_left[p]) return min_position, move_to_the_right[min_position] + move_to_the_left[ min_position]
else: game.player = 2 fim = False while(fim == False): player = game.player start = datetime.datetime.now() move = choose_move(game, player) end = datetime.datetime.now() diff = end-start # print("Player " + str(player) + ", MOVE " + str(move) + ", TIME " + str(diff)) resp = game.make_move(player, move[0]+1, move[1]+1) # print(resp) ganhador = game.is_final_state() if(ganhador != None): print("WINNER " + str(ganhador)) print(game.board) utils.count_occurrences(utils.int2str_board(game.board), player) utils.print_occurrences() fim = True moves = game.get_available_moves() if(len(moves) == 0): print("EMPATE") print(game.board) fim = True print("\n########################################################\n")
def __init__(self, name, fields=None, missing_fields=None, links=None, macro_strings=None, process_strings=None, array=None): self.name = name # we should have exactly one of either array or fields defined assert ((fields is None and array is not None) or (fields is not None and array is None)) if array is not None: if fields is None: fields = get_fields(array) array_period = np.min(array['period']) else: array_period = None duplicate_names = [name for name, num in count_occurrences(fname for fname, _ in fields) if num > 1] if duplicate_names: raise Exception("duplicate fields in entity '%s': %s" % (self.name, ', '.join(duplicate_names))) fnames = [name for name, _ in fields] if 'id' not in fnames: fields.insert(0, ('id', int)) if 'period' not in fnames: fields.insert(0, ('period', int)) self.fields = fields # only used in data (to check that all "required" fields are present # in the input file) # one potential solution would be to split the fields argument and # attribute in input_fields and output_fields (regardless of whether # it is split in the simulation/yaml file). # however that might be just a temporary solution as we will soon need # more arguments to fields (default values, ranges, etc...) # another solution is to use a Field class # seems like the better long term solution self.missing_fields = missing_fields self.stored_fields = set(name for name, _ in fields) self.links = links self.macro_strings = macro_strings self.process_strings = process_strings self.processes = None self.expectedrows = tables.parameters.EXPECTED_ROWS_TABLE self.table = None self.input_table = None self.indexed_input_table = None self.indexed_output_table = None self.input_rows = {} #TODO: it is unnecessary to keep periods which have already been # simulated, because (currently) when we go back in time, we always go # back using the output table. self.input_index = {} self.output_rows = {} self.output_index = {} self.base_period = None # we need a separate field, instead of using array['period'] to be able # to get the period even when the array is empty. self.array_period = array_period self.array = None self.lag_fields = [] self.array_lag = None self.num_tmp = 0 self.temp_variables = {} self.id_to_rownum = None self._variables = None self._methods = None
def __init__(self, name, fields=None, links=None, macro_strings=None, process_strings=None, array=None): """ Parameters ---------- name fields : list of tuple (name, type) links : {name: links.Link} macro_strings process_strings array """ self.name = name # we should have exactly one of either array or fields defined assert ((fields is None and array is not None) or (fields is not None and array is None)) if array is not None: if fields is None: fields = get_fields(array) array_period = np.min(array['period']) else: array_period = None if not isinstance(fields, FieldCollection): def fdef2field(name, fielddef): initialdata = True output = True default_value = None if isinstance(fielddef, Field): return fielddef elif isinstance(fielddef, (dict, str)): if isinstance(fielddef, dict): strtype = fielddef['type'] initialdata = fielddef.get('initialdata', True) output = fielddef.get('output', True) default_value = fielddef.get( 'default', default_value_by_strtype[strtype]) elif isinstance(fielddef, str): strtype = fielddef default_value = default_value_by_strtype[strtype] else: raise Exception('invalid field definition') dtype = field_str_to_type(strtype, "field '%s'" % name) else: assert isinstance(fielddef, type) dtype = normalize_type(fielddef) return Field(name, dtype, initialdata, output, default_value) fields = FieldCollection( fdef2field(name, fdef) for name, fdef in fields) duplicate_names = [ name for name, num in count_occurrences(fields.names) if num > 1 ] if duplicate_names: raise Exception("duplicate fields in entity '%s': %s" % (self.name, ', '.join(duplicate_names))) fnames = set(fields.names) if 'id' not in fnames: fields.insert(0, Field('id', int)) if 'period' not in fnames: fields.insert(0, Field('period', int)) self.fields = fields self.links = links if macro_strings is None: macro_strings = {} self.macro_strings = macro_strings self.process_strings = process_strings self.processes = None self.expectedrows = tables.parameters.EXPECTED_ROWS_TABLE self.table = None self.input_table = None self.indexed_input_table = None self.indexed_output_table = None self.input_rows = {} # TODO: it is unnecessary to keep periods which have already been # simulated, because (currently) when we go back in time, we always go # back using the output table... but periods before the start_period # are only present in input_index self.input_index = {} self.output_rows = {} self.output_index = {} self.output_index_node = None self.base_period = None # we need a separate field, instead of using array['period'] to be able # to get the period even when the array is empty. self.array_period = array_period self.array = array self.lag_fields = [] self.array_lag = None self.num_tmp = 0 self.temp_variables = {} self.id_to_rownum = None if array is not None: rows_per_period, index_per_period = index_table(array) self.input_rows = rows_per_period self.output_rows = rows_per_period self.input_index = index_per_period self.output_index = index_per_period self.id_to_rownum = index_per_period[array_period] self._variables = None self._methods = None
def __init__(self, name, fields=None, links=None, macro_strings=None, process_strings=None, array=None): self.name = name # we should have exactly one of either array or fields defined assert ((fields is None and array is not None) or (fields is not None and array is None)) if array is not None: if fields is None: fields = get_fields(array) array_period = np.min(array['period']) else: array_period = None if not isinstance(fields, FieldCollection): def fdef2field(name, fielddef): initialdata = True output = True default_value = None if isinstance(fielddef, Field): return fielddef elif isinstance(fielddef, (dict, str)): if isinstance(fielddef, dict): strtype = fielddef['type'] initialdata = fielddef.get('initialdata', True) output = fielddef.get('output', True) default_value = fielddef.get('default', default_value_by_strtype[strtype]) elif isinstance(fielddef, str): strtype = fielddef default_value = default_value_by_strtype[strtype] else: raise Exception('invalid field definition') dtype = field_str_to_type(strtype, "field '%s'" % name) else: assert isinstance(fielddef, type) dtype = normalize_type(fielddef) return Field(name, dtype, initialdata, output, default_value) fields = FieldCollection(fdef2field(name, fdef) for name, fdef in fields) duplicate_names = [name for name, num in count_occurrences(fields.names) if num > 1] if duplicate_names: raise Exception("duplicate fields in entity '%s': %s" % (self.name, ', '.join(duplicate_names))) fnames = set(fields.names) if 'id' not in fnames: fields.insert(0, Field('id', int)) if 'period' not in fnames: fields.insert(0, Field('period', int)) self.fields = fields self.links = links if macro_strings is None: macro_strings = {} self.macro_strings = macro_strings self.process_strings = process_strings self.processes = None self.expectedrows = tables.parameters.EXPECTED_ROWS_TABLE self.table = None self.input_table = None self.indexed_input_table = None self.indexed_output_table = None self.input_rows = {} # TODO: it is unnecessary to keep periods which have already been # simulated, because (currently) when we go back in time, we always go # back using the output table... but periods before the start_period # are only present in input_index self.input_index = {} self.output_rows = {} self.output_index = {} self.output_index_node = None self.base_period = None # we need a separate field, instead of using array['period'] to be able # to get the period even when the array is empty. self.array_period = array_period self.array = array self.lag_fields = [] self.array_lag = None self.num_tmp = 0 self.temp_variables = {} self.id_to_rownum = None if array is not None: rows_per_period, index_per_period = index_table(array) self.input_rows = rows_per_period self.output_rows = rows_per_period self.input_index = index_per_period self.output_index = index_per_period self.id_to_rownum = index_per_period[array_period] self._variables = None self._methods = None
done = False while not done: # Pergunta quem eh o jogador resp = urllib.request.urlopen("%s/jogador" % host) player_turn = int(resp.read()) # Se jogador == 0, o jogo acabou e o cliente perdeu if player_turn == 0: print("I lose.") resp = urllib.request.urlopen("%s/tabuleiro" % host) data = resp.read() board = utils.parse_board_resp(data) utils.count_occurrences(board, player) utils.print_occurrences() done = True # Se for a vez do jogador if player_turn == player: start = datetime.datetime.now() in_time = True # Fetch moves from server in case a random choice must be made resp = urllib.request.urlopen("%s/movimentos" % host) backup_moves = eval(resp.read()) # Fetch board from server and adjusts the data structure to algorithm execution resp = urllib.request.urlopen("%s/tabuleiro" % host)