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)