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