def __init__(self, is_p1_turn: bool) -> None:
"""
initialize a new subtractsquare game
#A docstring example is not needed for any functions or methods that
use input() or random.
"""
self.current_state = SubtractSquareState(is_p1_turn)
def count_states_mem(s1: SubtractSquareState, seen: dict) -> int:
"""
Return the number of game states reachable from here *quickly*.
"""
moves = s1.get_possible_moves()
states = [s1.make_move(m) for m in moves]
if s1.__repr__() not in seen:
seen[s1.__repr__()] = 1 + sum([count_states_mem(x, seen) for x in states])
return seen[s1.__repr__()]
def __init__(self, p1_starts):
"""
Initialize this Game, using p1_starts to find who the first player is.
:param p1_starts: A boolean representing whether Player 1 is the first
to make a move.
:type p1_starts: bool
"""
count = int(input("Enter the number to subtract from: "))
self.current_state = SubtractSquareState(p1_starts, count)
class SubtractSquareGame(Game):
"""
Abstract class for a game to be played with two players.
"""
def __init__(self, p1_starts):
"""
Initialize this Game, using p1_starts to find who the first player is.
:param p1_starts: A boolean representing whether Player 1 is the first
to make a move.
:type p1_starts: bool
"""
num = int(input("Enter a number: "))
self.current_state = SubtractSquareState(p1_starts, num)
def get_instructions(self):
"""
Return the instructions for this Game.
:return: The instructions for this Game.
:rtype: str
"""
return "A non-negative whole number is chosen as the starting \n" \
"valueby some neutral entity. In our case, a player will \n" \
"choose it (i.e. through the use of input. The player whose \n" \
"turn it is chooses some square of a positive whole number (\n" \
"such as 1, 4, 9, 16, . . . ) to subtract from the \n" \
"value, provided the chosen square is not larger. After \n" \
"subtracting, we have a new value and the next player \n" \
"chooses a square to ubtract from it. Play continues\n" \
" to alternate between the two players until no moves are\n" \
" possible. Whoever is about to play at that point loses!"
def is_over(self, state):
"""
Return whether or not this game is over.
:return: True if the game is over, False otherwise.
:rtype: bool
"""
return state.current_total == 0
def is_winner(self, player):
"""
Return whether player has won the game.
"""
return (self.current_state.get_current_player_name() != player
and self.is_over(self.current_state))
def str_to_move(self, string):
"""
Return the move that string represents. If string is not a move,
return an invalid move.
"""
if not string.strip().isdigit():
return -1
return int(string.strip())
def __init__(self, is_p1_turn: bool) -> None:
"""Initialize a new subtract sqaure game
Extends Game.__init__
===New Attributes===
current_value - the current value of a subtract square game
current_state - an instance of SubtractSquareState class
Assume starting_value is a non-negative whole number
"""
super().__init__(is_p1_turn)
self.current_value = int(input("Type a non-negative whole number " +
"as the starting value of the game: "))
self.current_state = SubtractSquareState(self.current_player,
self.current_value)
class SubtractSquare:
"""
class game SubtractSquare
"""
current_state: SubtractSquareState
def __init__(self, is_p1_turn: bool) -> None:
"""
initialize a new subtractsquare game
#A docstring example is not needed for any functions or methods that
use input() or random.
"""
self.current_state = SubtractSquareState(is_p1_turn)
def __eq__(self, other: Any) -> bool:
"""
return whether self is equivalent to other
# A docstring example is not needed for any functions or methods that
use input() or random.
"""
return (type(self) == type(other) and self.current_state.is_game_over
== other.current_state.is_game_over
and self.current_state.starting_number
== other.current_state.starting_number
and self.current_state.is_p1_turn
== other.current_state.is_p1_turn)
def __str__(self) -> str:
"""
return a str representation of self
# A docstring example is not needed for any functions or methods that
use input() or random.
"""
return "The current player is: {}, and the current value is: " \
"{}".format(self.current_state.get_current_player_name(),
self.current_state.starting_number)
def get_instructions(self) -> str:
"""
reutrn instruction of game for players
# A docstring example is not needed for any functions or methods that
use input() or random.
"""
instruction = 'Players take turns subtracting square numbers ' \
'from the starting number. The winner is the person ' \
'who subtracts to 0'
return instruction
def is_over(self, current_state: SubtractSquareState) -> bool:
"""
return whether this game is over
# A docstring example is not needed for any functions or methods that
use input() or random.
"""
return current_state.is_game_over
def str_to_move(self, move: str) -> int:
"""
a method whcih converts a string into a move
# A docstring example is not needed for any functions or methods that
use input() or random.
"""
return int(move)
def is_winner(self, player: str) -> bool:
"""
return which player is the winner
# A docstring example is not needed for any functions or methods that
use input() or random.
"""
if not self.current_state.is_game_over:
return False
else:
if self.current_state.is_p1_turn:
if player == 'p1':
return True
return False
else:
if player == 'p2':
return True
return False
def count_states(s1: SubtractSquareState) -> int:
""" Return the number of game states reachable from here.
"""
moves = s1.get_possible_moves()
states = [s1.make_move(m) for m in moves]
return 1 + sum([count_states(x) for x in states])
class SubtractSquareGame(Game):
"""
Abstract class for a game to be played with two players.
"""
def __init__(self, p1_starts):
"""
Initialize this Game, using p1_starts to find who the first player is.
:param p1_starts: A boolean representing whether Player 1 is the first
to make a move.
:type p1_starts: bool
"""
count = int(input("Enter the number to subtract from: "))
self.current_state = SubtractSquareState(p1_starts, count)
def get_instructions(self):
"""
Return the instructions for this Game.
:return: The instructions for this Game.
:rtype: str
"""
instructions = "Players take turns subtracting square numbers from" + \
" the starting number. The winner is the person who subtracts to 0."
return instructions
def is_over(self, state):
"""
Return whether or not this game is over.
:return: True if the game is over, False otherwise.
:rtype: bool
"""
return state.current_total == 0
def is_winner(self, player):
"""
Return whether player has won the game.
Precondition: player is 'p1' or 'p2'.
:param player: The player to check.
:type player: str
:return: Whether player has won or not.
:rtype: bool
"""
return (self.current_state.get_current_player_name() != player
and self.is_over(self.current_state))
def str_to_move(self, string):
"""
Return the move that string represents. If string is not a move,
return an invalid move.
:param string:
:type string:
:return:
:rtype:
"""
if not string.strip().isdigit():
return -1
return int(string.strip())