def shortest_path(source, goal): queue = QueueFrontier() source_movies = people[source]["movies"] for i in source_movies: temp_node = Node(source, None, i) queue.push(temp_node) while (queue.empty() != True): parent_node = queue.frontier[0] neighbours = get_neighbours(parent_node.state) answer = [] push = answer.append for n in neighbours: temp_node = Node(n[1], parent_node, n[0]) if temp_node.state == goal: while (temp_node.parent != None): push((temp_node.action, temp_node.state)) temp_node = temp_node.parent return answer[::-1] else: response = any(x.state == temp_node.state for x in queue.frontier) if (response == False): queue.push(temp_node) queue.remove() return None
def number_to_linked_list(n): head = None for i in str(n): tmp = Node(int(i)) tmp.next = head head = tmp return head
def __init__(self, ast_node): Node.__init__(self) self.car = ast_node.car.cdr self.cdr = ast_node.cdr assert type(self.car) == AbstractSyntaxTree.IdentifierNode self.name = self.car.name self.lambda_expr =\ AbstractSyntaxTree.LambdaNode(self.car.cdr) self.car.cdr = self.lambda_expr
def reverse_list(head): new_head = None cur = head while cur: node = Node(cur.data) node.next = new_head new_head = node cur = cur.next return new_head
def bfs(goal, pos, tail, bounds): visited, queue = set(), [Node(None, pos)] visited.add(pos) while queue: vertex = queue.pop(0) if vertex.pos == goal: return vertex for neighbour in get_neighbors(vertex.pos, tail, bounds): if neighbour not in visited: visited.add(neighbour) queue.append(Node(vertex, neighbour)) return None
def test_a1(self): head = Node(1) head.next = Node(1) head.next.next = Node(2) head.next.next.next = Node(2) head.next.next.next.next = Node(2) head.next.next.next.next.next = Node(3) result = remove_dupes_a(head) self.assertEqual(result.toList(), [1, 2, 3])
def main(): with open('PuzzleGame\one_input') as input_file: i = 0 for line in input_file.readlines(): puzzle_dimension, max_depth, max_search_path, values = line.split() root_board = np.array(build_initial_board(int(puzzle_dimension), values), np.int32) root_node = Node(root_board, 0, 0, 0) build_boards(root_node) start_dfs(root_node, max_depth) save_to_file(list_of_solution_moves, f'{i}_dfs_solution.txt') save_to_file(list_of_search_moves, f'{i}_dfs_search.txt') i += 1 clean_up()
def astar_search(goal, pos, tail, bounds): open = [] closed = [] start_node = Node(None, pos) goal_node = Node(None, goal) open.append(start_node) while len(open) > 0: open.sort() current_node = open.pop(0) closed.append(current_node) if current_node == goal_node: return current_node (x, y) = current_node.pos neighbors = [(x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1)] for next_neighbor in neighbors: if not is_reachable(next_neighbor, tail, bounds): continue neighbor = Node(current_node, next_neighbor) if neighbor in closed: continue # Generate heuristics (Manhattan distance) neighbor.g = abs(neighbor.pos[0] - start_node.pos[0]) + abs(neighbor.pos[1] - start_node.pos[1]) neighbor.h = abs(neighbor.pos[0] - goal_node.pos[0]) + abs(neighbor.pos[1] - goal_node.pos[1]) neighbor.f = neighbor.g + neighbor.h # Check if neighbor is in open list and if it has a lower f value if add_to_open(open, neighbor): # Everything is green, add neighbor to open list open.append(neighbor) return []
def __init__(self, ast_node): Node.__init__(self) self.name = ast_node.car.name self.car = ast_node.car.cdr self.cdr = ast_node.cdr
def test_a2(self): head = Node(1) result = remove_dupes_a(head) self.assertEqual(result.toList(), [1])
def test_b3(self): head = Node(1) head.next = Node(1) result = remove_dupes_b(head) self.assertEqual(result.toList(), [1])
#state_space = [1, 2, 3, 4, 5] #initial_state = State([1, 3], [2, 4, 5]) #final_state = State([], [1, 2, 3, 4, 5]) #final_state = State([5], [1, 2, 3, 4]) #state_space = [1, 2, 3, 4] #initial_state = State([2, 3], [1]) #initial_state = State([1, 4], [3, 2]) #final_state = State([], [1, 2, 3, 4]) #state_space = [1, 2, 3] #initial_state = State([2, 3], [1]) #initial_state = State([1, 3], [2]) #final_state = State([], [1, 2, 3]) if __name__ == '__main__': root = Node(None, initial_state) #solution = bfs_search(root, [], final_state, state_space) solution = aStar_search(root, [], final_state, state_space) path = [solution] while solution.parent: solution = solution.parent path.append(solution) print(f'Solution Path\n{path[::-1]}') print(f'It took {algorithms.expansion_count} expansions (equal to depth)')
if valid_response: update_tag_settings(new_tags) ############## BEGIN CONFIG ##################### print 'reading settings' settings = Config() ############## BEGIN SPEAKER ##################### print 'reading settings' speaker = Speaker(settings) speaker.play_startup_sound() ############## BEGIN CLOUD ##################### print 'initing cloud' cloud = Cloud(settings) ############## BEGIN DOOR ##################### print 'initing_door' door = Door('back_door', settings) door.DOOR_OPENED += door_opened door.DOOR_CLOSED += door_closed ############## BEGIN NODE ################### print 'setting up node' node = Node(settings) node.OPEN_DOOR_REQUEST += request_door_open node.REFRESH_USERS_REQUEST += request_refresh_users node.start() ############## BEGIN SENSOR ################### print 'setting up sensor' sensor = Sensor("outside_sensor") sensor.FOUND_TAG += found_tag sensor.start()
def __init__(self, ast_node): Node.__init__(self) self.car = ast_node self.param_list = ast_node assert type(self.param_list) == AbstractSyntaxTree.ListNode self.body_expr = ast_node.cdr
def __init__(self, parse_node): Node.__init__(self)
def __init__(self, parse_node): Node.__init__(self) self.name = parse_node.value
def __init__(self, ast_node): Node.__init__(self) self.car = ast_node.car.cdr self.predicate_expr = self.car self.left_expr = ast_node.car.cdr.cdr self.right_expr = ast_node.car.cdr.cdr.cdr
right_status = self.lca_helper(root.right, p, q) if right_status.num_target_nodes == 2: return right_status return Status(num_target_nodes=left_status.num_target_nodes + right_status.num_target_nodes + (p.val, q.val).count(root.val), ancestor=root) sol = Solution() tree: Node = TreeHelper.create_tree([ 3, 5, 1, 6, 2, 0, 8, None, None, 7, 4, ]) # ancestor = sol.lowestCommonAncestor(tree, Node(5, None, None), Node(1, None, None)) ancestor = sol.lowestCommonAncestor(tree, Node(5, None, None), Node(4, None, None)) print(ancestor.val)
def __init__(self, parse_node): Node.__init__(self) operator_node = parse_node.car self.name = parse_node.value
def __init__(self, parse_node): Node.__init__(this) this.value = value
def __init__(self, ast_node=None): Node.__init__(self) if ast_node: self.car = ast_node.car self.cdr = ast_node.cdr
def __init__(self, parse_node): Node.__init__(self) self.value = value
def __init__(self, parse_node): Node.__init__(self) self.cdr = parse_node.cdr
def minimax(board): """ Returns the optimal action for the current player on the board. """ # create a node using the input board input_node = Node(parent=None, state=board, value=None) # if board is terminal, return None if terminal(board) == True: return None # check whose turn it is num_x = 0 num_o = 0 for row in board: for cell in row: if cell == X: num_x = num_x + 1 if cell == O: num_o = num_o + 1 if num_o == num_x: current_player = X else: current_player = O # create a stack queue stack_queue = StackQueue() # explore the current board possible_boards = explore_board(board)[0] moves = explore_board(board)[1] # keep track of all the possible moves possible_move_nodes = [] # create a node for each possible board for board_state in possible_boards: new_node = Node(parent=input_node, state=board_state, value=None) # add the new node to the frontier stack_queue.frontier.append(new_node) possible_move_nodes.append(new_node) # continue exploring the frontier while it is not empty while stack_queue.frontier != []: # remove a node from the frontier current_node = stack_queue.remove() # check if current node is terminal if terminal(current_node.state) == True: # check who won the game utility_value = utility(current_node.state) # assign to each node and its parent nodes the value while current_node.parent != None: current_node.value = utility_value current_node = current_node.parent if terminal(current_node.state) == False: # if current node is not terminal, explore it possible_board_states = explore_board(current_node.state)[0] # create a node for each board state and add it to the frontier for board_state in possible_board_states: new_node = Node(parent=current_node, value=None, state=board_state) stack_queue.frontier.append(new_node) # once the frontier is empty, go over all the possible moves, and choose at random the ones that match the computers goal if current_player == X: optimal_moves = [] for node in possible_move_nodes: if node.value == 1: # get the index of the node node_index = possible_move_nodes.index(node) move = moves(node_index) optimal_moves.append(move) # return a random optimal move random_index = randint(0, len(optimal_moves) - 1) return optimal_moves[random_index] if current_player == O: optimal_moves = [] for node in possible_move_nodes: if node.value == -1: # get the index of the node node_index = possible_move_nodes.index(node) move = moves(node_index) optimal_moves.append(move) # return a random optimal move random_index = randint(0, len(optimal_moves) - 1) return optimal_moves[random_index]