def start_game(self):
a = False
while a == False:
if Tree().height() == True:
print("It's your step, {}. You are 'X'".format(
self.first_name))
try:
self.position = int(input('Enter cells position: '))
except ValueError:
print("Please try again")
if self.position > 0 and self.position <= 9:
if self.board[self.position - 1] == None:
self.board[self.position - 1] = 'X'
self.print_board()
self.count += 1
Tree().insert('O')
self.position.remove(self.position)
else:
raise ValueError('Try again')
else:
raise ValueError('Try again')
else:
print("It's computer step")
self.position = random.choice(self.possible_position)
if self.board[self.position - 1] == None:
self.board[self.position - 1] = 'O'
self.print_board()
self.count += 1
Tree().insert('O')
if self.check() == True:
break
print("You win")
def turn(self):
if self.board.last_turn == "0":
coordinates = input("Enter coordinate: ").split()
if self.board.state[int(coordinates[0])][int(
coordinates[1])] != "_":
raise IndexError
if int(coordinates[0]) > 2 or int(coordinates[1]) > 2 or 0 > int(
coordinates[0]) or 0 > int(coordinates[1]):
raise IndexError
new_row = ""
for j in range(3):
if j != int(coordinates[1]):
new_row += self.board.state[int(coordinates[0])][int(
coordinates[0])]
else:
new_row += "x"
self.board.state[int(coordinates[0])] = new_row
self.board.last_turn = "x"
else:
tree = Tree(self.board)
tree.generate()
if tree.root.right.check() > tree.root.left.check():
self.board = tree.root.right.root.data
else:
self.board = tree.root.left.root.data
self.board.last_turn = "0"
self.board.show_board()
def recursion(tree):
free_cells = tree.root.free_cells()
if not free_cells or tree.root.check_win():
return
if len(free_cells) == 1:
board = deepcopy(tree.root)
board.last_move = board.get_player(board.last_move)
board.data[free_cells[0][0]][free_cells[0]
[1]] = board.last_move
tree.right = Tree(board)
recursion(tree.right)
return
board1 = deepcopy(tree.root)
board1.last_move = board1.get_player(board1.last_move)
position = random.choice(free_cells)
free_cells.remove(position)
board1.data[position[0]][position[1]] = board1.last_move
tree.right = Tree(board1)
board2 = deepcopy(tree.root)
board2.last_move = board2.get_player(board2.last_move)
position = random.choice(free_cells)
free_cells.remove(position)
board2.data[position[0]][position[1]] = board2.last_move
tree.left = Tree(board2)
recursion(tree.right)
recursion(tree.left)
def _process_matched_orders(self, new_order: Order,
matched_order_node: Tree):
matched_order = matched_order_node.orders[0]
# if new_order.qty matches matched_order.qty
# 1. register expected: trade, new_order(X), matched_order(X)
# 2. remove matched_order from the book
# 3. remove the node from the tree if no more orders with same price
# new_order fully filled nothing else to do
if new_order.qty == matched_order.qty:
self._expected_trades.append(
Trade(matched_order.qty,
matched_order.price)) # add expected Trade
self._expected_x_orders.add(
new_order.order_id) # add expected new_order(X)
self._expected_x_orders.add(
matched_order.order_id) # add expected matched_order(X)
self._orders_by_id.pop(matched_order_node.orders.popleft().order_id
) # del matched_order from dict and tree
new_order.qty = 0
if len(matched_order_node.orders) == 0:
matched_order_node.remove_me()
# new_order.qty < matched_order.qty
# 1. decrease matched_order.qty
# 2. register expected messages: trade, new_order(X)
# new_order fully filled nothing else to do
elif new_order.qty < matched_order.qty:
matched_order.qty = matched_order.qty - new_order.qty
self._expected_trades.append(
Trade(new_order.qty,
matched_order.price)) # add expected Trade
self._expected_x_orders.add(
new_order.order_id) # add expected new_order(X)
new_order.qty = 0
# new_order.qty > matched_order.qty
# 1. decrease new_order.qty
# 2. register expected messages: trade, matched_order(X)
# 3. remove matched_order from the book
# 4. remove the node from the tree if no more orders with the same price
# otherwise recursive call to try to fill the rest of qty
else:
new_order.qty = new_order.qty - matched_order.qty
self._expected_trades.append(
Trade(matched_order.qty, matched_order.price))
self._expected_x_orders.add(
matched_order.order_id) # add expected matched_order(X)
self._orders_by_id.pop(matched_order_node.orders.popleft().order_id
) # del matched_order from dict and tree
if len(matched_order_node.orders) == 0:
matched_order_node.remove_me()
else:
self._process_matched_orders(new_order, matched_order_node)
def __init__(self):
self._orders_by_id: Dict[int, Order] = dict()
self._s_orders_by_price: Tree = Tree(
config.MAX_PRICE_THRESHOLD) # add an artificial root.
self._b_orders_by_price: Tree = Tree(
config.MIN_PRICE_THRESHOLD) # add an artificial root.
self._expected_trades: Deque[Trade] = deque(
) # expected trades when new orders coming in
self._expected_x_orders: Set[int] = set(
) # orders to be deleted as result of expected trades
self._errors = ErrorsDictionary()
self._recent_trade_price: float = config.MAX_PRICE_THRESHOLD
self._recent_trade_qty: int = 0
def make_step(self, field, current, cur_node=None):
"""
Makes step on field
"""
fst = False
new_node = Tree(field)
if cur_node == None:
cur_node = new_node
fst = True
if field.is_full() or field.winner_sign():
cur_node.add_node(Node(field))
for x in range(3):
for y in range(3):
if field.field[x][y] == " ":
field.field[x][y] = Board.PLAYER_SIGNS[current]
self.make_step(deepcopy(field), (current + 1) % 2,
new_node)
field.field[x][y] = " "
if fst:
win_rates = [win_rate(node, current) for node in new_node.childs]
step = win_rates.index(max(win_rates))
field.field = new_node.childs[step].data.field
return
else:
cur_node.add_node(new_node)
return cur_node
def post(_id):
db = Tree.from_file()
if _id in db:
return jsonify(error=('This key already exists in the database, use '
'PUT to update the key')), 500
return add_request_to_db(db, _id)
def insert(self, data):
'''
插入
'''
if not self.base:
self.base = Tree(data=data)
return
pp = None
p = self.base
while p:
pp = p
p = p.ltree if p.data > data else p.rtree
new_p = Tree(data=data)
if pp.data > data:
pp.ltree = new_p
else:
pp.rtree = new_p
def compute_score(self):
has_winner = self.has_winner()
if has_winner:
winner_scores = {
Board.NOUGHT_WINNER: 1,
Board.CROSS_WINNER: -1,
Board.DRAW: 0
}
return winner_scores[has_winner]
n1 = Node(self)
board = Tree()
board.root = n1
right_board = left_board = copy.deepcopy(self)
left_move, right_move = left_board.make_random_move(
), right_board.make_random_move()
board.root.left = Node(left_move)
board.root.right = Node(right_move)
return left_board.compute_score() + right_board.compute_score()
class Index(object):
def __init__(self, database, table, key):
self.key = key
self.table = table
self.database = database
self.btree = Tree(self.database, self.table, self.key)
self.db_file = db_file_path(DATA_META_DB)
def create(self, value, data_offset):
# key = to_bytes(key)
value = to_bytes(value)
# table = to_bytes(table)
# database = to_bytes(database)
index = IndexStruct()
# index.database = self.database
# index.table = self.table
# index.key = self.key
index.value = value
index.offset = 0
index.data_offset = data_offset
self.btree.add(index)
self.btree.saveTree()
# with open(self.db_file, "ab+") as f:
# index.offset = f.tell()
# f.write(bytes(index))
def get(self, value):
# if not os.path.exists(self.db_file):
# return None
# key = to_bytes(key)
# value = to_bytes(value)
# table = to_bytes(table)
# database = to_bytes(database)
index = self.btree.find(value)
# index = None
# with open(self.db_file, "rb") as f:
# content = f.read(ctypes.sizeof(IndexStruct))
# while content:
# index = IndexStruct.from_buffer_copy(content)
# if index.database == database and index.table == table and index.key == key and index.value == value:
# break
# content = f.read(ctypes.sizeof(IndexStruct))
# index = None
return index
def delete(_id):
db = Tree.from_file()
try:
del db[_id]
except KeyError:
return jsonify(error='No data was found for this id'), 404
db.commit()
return jsonify(succes='deleted')
def computer(self):
tree = Tree()
tree.set_root(deepcopy(self.board))
def new_check(board):
if self.check_board(board) == self.comput:
return 1
elif self.check_board(board) == self.player:
return -1
elif self.check_board(board) == 0:
return 0
else:
return None
def add(item, state=True):
if self.check_board(item.data) in ["O", 0, "X"]:
item.res = new_check(item.data)
else:
for i in range(3):
if len(item.children) == 2:
break
for j in range(3):
if item.data[i][j] == " ":
new = deepcopy(item.data)
new[i][j] = self.comput if state else self.player
tree.add(item, new)
add(item.children[-1], state=not state)
if len(item.children) == 2:
break
add(tree._root)
def calculate(item, func):
if item.res != None:
return item.res
item.res = func(item.children, key=lambda x: \
calculate(x, min if func == max else max)).res
return item.res
calculate(tree._root, max)
board = max(tree._root.children, key=lambda x: x.res)
self.board = board.data
def compute_score(self):
"""
The function returns sum of all scores in binary tree
"""
board = Tree(self)
if self.has_winner():
winner_scores = {
Board.NOUGHT_WINNER: 1,
Board.CROSS_WINNER: -1,
Board.DRAW: 0
}
return winner_scores[self.has_winner()]
board.key = Node(self)
left_board = deepcopy(self)
left_move = left_board.make_random_move()
board.key.left = Node(left_move)
right_board = deepcopy(self)
right_move = right_board.make_random_move()
board.key.right = Node(right_move)
return left_board.compute_score() + right_board.compute_score()
def count_score(self):
has_winner = self.has_winner()
if has_winner:
scores = {
Board.NOUGHT_WINNER: 1,
Board.CROSS_WINNER: -1,
Board.DRAW: 0
}
return scores[has_winner]
else:
board = Tree()
board.root = Node(self)
board_left = copy.deepcopy(self)
board_right = copy.deepcopy(self)
move_L = board_left.make_random_move()
move_R = board_right.make_random_move()
board.root.left = Node(move_L)
board.root.right = Node(move_R)
result = board_left.count_score() + board_right.count_score()
return result
def compute_score(self):
"""
Chooses better move
:return: int
"""
has_winner = self.has_winner()
if has_winner:
winner_scores = {
Board.NOUGHT_WINNER: 1,
Board.CROSS_WINNER: -1,
Board.DRAW: 0
}
return winner_scores[has_winner]
board = Tree()
board.root = Node(self)
left_board = copy.deepcopy(self)
right_board = copy.deepcopy(self)
left_move = left_board.make_random_move()
right_move = right_board.make_random_move()
board.root.left = Node(left_move)
board.root.right = Node(right_move)
return left_board.compute_score() + right_board.compute_score()
def build_decision_tree(self):
"""Build decision tree for TicTacToe game"""
self.tree = Tree()
def recurse(board, node=None, player=self.first_player):
"""Recursively build tree of all possible
moves in TicTacToe game
player: 1 if human makes a move, 0 - if computer"""
if node is None:
curr_node = self.tree.add_root(board)
else:
curr_node = self.tree.add_child(node, board)
# if current state is not final yet:
curr_state = \
curr_node.item.current_state(first_player=self.first_player)
if curr_state is None:
for i in range(3):
for j in range(3):
if curr_node.item.board[i][j] is None:
move = (Board.FIRST_MARK
if player ^ self.first_player ^ 1 else
Board.SECOND_MARK, (i, j))
next_board = Board.new_board(curr_node.item, move)
recurse(next_board, curr_node, player ^ 1)
if player:
# consider that human makes the best move
curr_node.score = min(c.score for c in curr_node.children)
else:
# try to make teh best move
curr_node.score = max(c.score for c in curr_node.children)
else:
curr_node.score = curr_state
recurse(self.board)
def map():
script = Script()
tree = Tree.from_file()
temp_tree = Tree(filename='map.db')
temp_tree.compact()
script.add_string(request.get_data())
data = []
for k, v in tree:
temp_tree[k] = script.invoke('mapper', k, v)
data = script.invoke('reducer', temp_tree.__iter__())
return jsonify(result=data)
def main():
for j in range(30):
tree = Tree(max_size=3)
for i in range(j + 1):
tree[i] = i**2
fancy_print(tree)
print(tree)
print('COMMMMIITTTTTT')
tree.commit()
print('IMPORRRTTTTT')
new_tree = Tree.from_file()
print(new_tree)
print('IMUPPORRTTAANTT', new_tree)
fancy_print(new_tree)
new_tree[2] = 20
fancy_print(new_tree)
print('IMUPPORRTTAANTT', new_tree)
fancy_print(new_tree)
new_tree[3] = 30
print('IMUPPORRTTAANTT', new_tree)
fancy_print(new_tree)
del new_tree[0]
fancy_print(new_tree)
print('IMUPPORRTTAANTT', new_tree)
fancy_print(new_tree)
print(getsize(new_tree.filename))
print('COOOOMMMPPPAAACCCTTT')
new_tree.compact()
print(getsize(new_tree.filename))
print('IMPORT COOOOMMMPPPAAACCCTTT')
new_tree = Tree.from_file()
new_tree[2] = 30
print("PRRRRRINIINNT 11111")
fancy_print(new_tree)
del new_tree[3]
print("PRRRRRINIINNT 2222222")
fancy_print(new_tree)
print()
print()
def main():
'''
Launches the tic-tac-toe game
'''
board = Board()
free_list = board.free_cells()
choice = random.choice(free_list)
board.move(choice)
while not board.is_filled():
board.draw()
#move of the player
try:
move = input("The coordinates of your move: ").split(",")
board.move((int(move[0]),int(move[1])) , False)
except IndexError:
continue
#move of the computer
tree = Tree(copy.deepcopy(board))
tree.build_tree()
right_wins = tree.count_wins(tree._root._right)
left_wins = tree.count_wins(tree._root._left)
if right_wins > left_wins:
move = board.last_move(tree._root._right)
else:
move = board.last_move(tree._root._left)
board.move(list(move)[0])
#check for winning combination
win = board.check_win()
if win == 1:
return "You lose the game!"
elif win == -1:
return "You win the game!"
return "The draw!"
def get():
db = Tree.from_file()
l = []
for k, v in db:
l.append({'id': k, 'data': v})
return jsonify(items=l)
class Interface:
"""
Interface of the tic-tac-toe game
Attributes:
+ play_tree: btree.Tree
+ board: board.Board
+ side: str
Methods:
+ __init__(): NoneType
+ choose_side(): NoneType
+ computer_turn(): NoneType
+ make_turn(): NoneType
+ check_victory(): NoneType
+ main(): NoneType
"""
def __init__(self):
self.play_tree = None
self.board = Board()
self.side = None
def choose_side(self):
"""() -> NoneType
Allows a player to choose 'x' or 'o'
"""
while True:
try:
self.side = input('Enter your side ("x" or "o"): ')
if self.side != 'x' and self.side != 'o':
raise ChoosingSideError
break
except ChoosingSideError:
print('Wrong string to choose side')
def computer_turn(self):
"""() -> NoneType
Generates computer's turn
"""
self.play_tree = Tree(self.board)
self.board = self.play_tree.choose('x' if self.side == 'o' else 'o')
def make_turn(self):
"""() -> NoneType
Allows player to draw his symbol
"""
while True:
try:
row = int(input('Enter row: '))
col = int(input('Enter column: '))
self.board.change(row, col, self.side)
break
except (ValueError, TypeError, KeyError) as e:
if str(e) == "'this position is already taken'":
print('This position is already taken')
else:
print('You should enter two (one per line) integers ' +
'between 1 and 3 inclusively')
winner = self.board.victory()
if winner == 'n':
self.computer_turn()
def check_victory(self):
"""() -> NoneType
If here is victory on the board, prints message and stops the
game
"""
winner = self.board.victory()
if winner != 'n':
if winner == 't':
print("It's a tie!")
else:
print(self.board)
print('"{0}" won!'.format(winner))
sys.exit(0)
def main(self):
self.choose_side()
if self.side == 'o':
self.computer_turn()
while True:
print(self.board)
self.check_victory()
self.make_turn()
def computer_turn(self):
"""() -> NoneType
Generates computer's turn
"""
self.play_tree = Tree(self.board)
self.board = self.play_tree.choose('x' if self.side == 'o' else 'o')
def put(_id):
db = Tree.from_file()
if _id not in db:
return jsonify(error=('No data was found for this id, use POST if'
' you want to add a new document')), 404
return add_request_to_db(db, _id)
def get(_id):
db = Tree.from_file()
try:
return jsonify(data=db[_id])
except KeyError:
return jsonify(error='No data was found for this id'), 404
from btree import Node, Tree tree = Tree() tree.add(3) tree.add(4) tree.add(0) tree.add(8) tree.add(2) tree.printTree() print(tree.height())
from btree import Node, Tree
def level_traversal(root):
queue = [root]
level = 0
while len(queue) > 0:
level+= 1
size = len(queue)
print("level = ", level)
while size > 0:
node = queue.pop(0)
print(node.v)
if node.l:
queue.append(node.l)
if node.r:
queue.append(node.r)
size -= 1
tree = Tree()
tree.add(3)
tree.add(4)
tree.add(0)
tree.add(8)
tree.add(2)
level_traversal(tree.getRoot())
def post():
db = Tree.from_file()
_id = uuid.uuid4()
return add_request_to_db(db, _id)
def delete():
db = Tree.from_file()
db.root = db._create_leaf()
db.commit()
db.compact()
return jsonify()
def compact():
Tree.from_file().compact()
return jsonify(success='compacted')
def game(board):
"""
Start two moves - first one of a player, second one of a computer. Return Board
representation of result.
:param board: Board
:return: Board
"""
# I know how to use exceptions, but here it would be too hard, because I have to continue game.
def get_pos(text):
"""
Get number from one to three from player.
:param text: str
:return: int
"""
i = input(text)
if i in ['1', '2', '0']:
return int(i)
else:
print("Sorry, you had to enter a number from 0 to 2! Please, try again!")
return get_pos(text)
def get_input(board):
"""
Get position from player.
:param board: Board
:return: tuple
"""
# Getting player input:
col = get_pos("Player, please, enter column number (from 0 to 2): ")
row = get_pos("Player, please, enter row number (from 0 to 2): ")
# Checking input:
if tuple([row, col]) not in board.free_positions():
print("Sorry, but this position is not free! Please, try again!")
return get_input(board)
return tuple([row, col])
# First move is made by a player.
tupl = get_input(board)
row = tupl[0]
col = tupl[1]
# Make a new board:
new_board = Board()
# Make a move on a new board:
field = board.data[:]
field[row][col] = False
new_board.set_field(field)
new_board.set_last_move(tupl, False)
# Check if game is finished and if it is, return new board.
if new_board.get_state() == 1 or not new_board.free_positions():
return new_board
# Print new version of a board on the screen:
new_board.print_board()
print("_" * 120)
# Now it is time for a robot to choose its path.
# Building a binary search tree:
tree = Tree(new_board)
tree.finish()
final_board = tree.best_board()
print("Robot made its choice!")
final_board.print_board()
print("_" * 120)
return final_board
