def resolver(metodo_busqueda, posiciones_personas): """ Devuelve un nodo resultado, a partir de una búqueda especificada. Argumentos: metodo_busqueda -- nombre de método a usar (string); posiciones_personas -- lista de tuplas. Cada tupla representa la posicion de una persona en la grilla (aún por rescatar). """ """ Estado inicial: Lista compuesta de 4 posiciones: 1era posicion: Tupla. Posicion del robot en la grilla. 2da posicion: Lista de tuplas. Posiciones de la grilla que el robot va hundiendo (inutilizando). 3era posicion: Lista de tuplas. Posiciones de la grilla donde se ubican las personas aún no rescatadas. 4ta posicion: Booleano. Es True si el robot esta 'ocupado' (esta cargando personas), caso contrario False. """ ESTADO_INICIAL = ((0, 0), (), posiciones_personas, False) problema = RescatePersonas(ESTADO_INICIAL) if metodo_busqueda == 'astar': return astar(problema, graph_search=True) elif metodo_busqueda == 'depth_first': return depth_first(problema, graph_search=True) elif metodo_busqueda == 'breadth_first': return breadth_first(problema, graph_search=True) elif metodo_busqueda == 'greedy': return greedy(problema, graph_search=True)
def play_move_ai(game, current_player, memory, user_args): my_viewer = ConsoleViewer() my_problem = HanabiProblem(game) result = breadth_first(my_problem, viewer=my_viewer) #result = breadth_first(my_problem) print result.state print print_game(result.game_states[result.state], -1, True) print result.path()
def find_path(source: List[List[str]], dest: List[List[str]]) -> TaskExec: tp = TaskProblem(goal=dest, initial_vars=source) result = breadth_first(tp, graph_search=True) if result: return result.path() return []
def BFS(SearchingProblem): print("---Breadth First Search---") before = datetime.now() search = breadth_first(SearchingProblem) #search = breadth_first(SearchingProblem,viewer=my_viewer) after = datetime.now() print("Path -->",search.path()) print("Time -->", (after - before).total_seconds()) print("Path cost-->",search.cost) print("-" * 40)
def main(): start_board = Board.board_from_file(sys.argv[1]) duplication_checks = sys.argv[2] method = sys.argv[3] heuristic = '' check_duplicates = 'graph' in duplication_checks if 'star' in method: heuristic = sys.argv[4] if heuristic == 'max_moves': start_board.heuristic = heuristics.max_moves elif heuristic == 'min_moves': start_board.heuristic = heuristics.min_moves elif heuristic == 'max_movable_pegs': start_board.heuristic = heuristics.max_movable_pegs elif heuristic == 'man': start_board.heuristic = heuristics.manhattan_distance else: print('You did not pick a viable heuristic. Exiting...') return start = time.time() if method == 'dfs': result = depth_first(start_board, check_duplicates) elif method == 'bfs': result = breadth_first(start_board, check_duplicates) elif method == 'astar': result = astar(start_board, check_duplicates) elif method == 'ildf': result = iterative_limited_depth_first(start_board, check_duplicates) else: print('You must choose a valid search method. Exiting...') return end = time.time() print("-" * 30) print('Search:', sys.argv[2], 'on', sys.argv[3], sys.argv[4] if len(sys.argv) > 4 else '') print('Input File:', sys.argv[1]) if result: path = result.path() for step in path: print(step[0], '-->', Board.board_from_state(step[1])) print('Duration: {0:.4f} seconds'.format(end - start)) print('Nodes Visited:', len(path)) else: print("No solution found!") print("-" * 30)
def resolver(metodo_busqueda, posiciones_aparatos): Inicial = [(3,3)] for ap in posiciones_aparatos: Inicial.append((ap[0], ap[1], 300)) if metodo_busqueda == "breadth_first": return breadth_first(Problem(tuple(Inicial)), graph_search=True) if metodo_busqueda == "astar": return astar(Problem(tuple(Inicial)), graph_search=True) if metodo_busqueda == "greedy": return greedy(Problem(tuple(Inicial)), graph_search=True) if metodo_busqueda == "depth_first": return depth_first(Problem(tuple(Inicial)), graph_search=True)
def resolver(metodo_busqueda, posicion_rey, controlar_estados_repetidos): problema = HnefataflProblem(posicion_rey) visor = BaseViewer() if metodo_busqueda == "breadth_first": resultado = breadth_first(problema, graph_search=controlar_estados_repetidos) return resultado if metodo_busqueda == "depth_first": return depth_first(problema, graph_search=controlar_estados_repetidos) if metodo_busqueda == "greedy": return greedy(problema, graph_search=controlar_estados_repetidos) if metodo_busqueda == "astar": return astar(problema, graph_search=controlar_estados_repetidos)
def createProblem(vx, vy, x_comida, y_comida): problem = MarioGame((vx, vy), (x_comida, y_comida)) result = breadth_first(problem, graph_search=True) path = [x[1] for x in result.path()] moves = result.path() moves = moves[1:] lm = [] for i in moves: lm.append(i[0]) lm.reverse() return lm
def resolver(metodo_busqueda): visor = BaseViewer() if metodo_busqueda == 'breadth_first': result = breadth_first(entrega1tradicional(INITIAL), graph_search=True, viewer=visor) if metodo_busqueda == 'depth_first': result = depth_first(entrega1tradicional(INITIAL), graph_search=True, viewer=visor) if metodo_busqueda == 'limited_depth_first': result = iterative_limited_depth_first(entrega1tradicional(INITIAL),10, viewer=visor) if metodo_busqueda == 'greedy': result = greedy(entrega1tradicional(INITIAL), graph_search=True, viewer=visor) if metodo_busqueda == 'astar': result = astar(entrega1tradicional(INITIAL), graph_search=True, viewer=visor) return result
def main(): # to record running time import time start = time.time() #### Uncomment an algorithm to use #### # result = depth_first(FifteenPuzzleProblem(INITIAL), 1) result = breadth_first(FifteenPuzzleProblem(INITIAL), 1) # result = limited_depth_first(FifteenPuzzleProblem(INITIAL), depth_limit=8) # result = iterative_limited_depth_first(FifteenPuzzleProblem(INITIAL),1) end = time.time() def report_result(result): count = 1 for action, state in result.path(): print("**** STEP NUMBER: {} ****".format(count)) count += 1 print('Move number', action) print(state) # Running time print("\ntime taken: ", end - start) report_result(result) # visualize the solution using pygraph module, to use pygraph see: http://github.com/iamaziz/pygraph try: from pygraph.dgraph import PyGraph except ImportError: pass name = 'easy-BFS' def vizit(name): g = PyGraph() for i in range(len(result.path())): try: a1, s1 = result.path()[i] a2, s2 = result.path()[i + 1] r = [s1, a2, s2] relation = ' '.join(r) g.add_relation(relation) except IndexError: pass g.draw_graph("15-puzzle-{}".format(name), orientation="LR")
def resolver(metodo_busqueda, posicion_rey, controlar_estados_repetidos): INITIAL = posicion_rey problema = HnefataflProblema(posicion_rey) visor = BaseViewer() #Busqueda en amplitud if (metodo_busqueda == 'breadth_first'): resultado = breadth_first(problema, graph_search=controlar_estados_repetidos, viewer=visor) return resultado #Busqueda en profundidad if (metodo_busqueda == 'depth_first'): resultado = depth_first(problema, graph_search=controlar_estados_repetidos, viewer=visor) return resultado #Busqueda avara if (metodo_busqueda == 'greedy'): resultado = greedy(problema, graph_search=controlar_estados_repetidos, viewer=visor) return resultado #Busqueda A Estrella if (metodo_busqueda == 'astar'): resultado = astar(problema, graph_search=controlar_estados_repetidos, viewer=visor) return resultado # for action, state in resultado.path(): # print action # print resultado.path() # print 'produndidad: ' + str(resultado.depth) # print state # print 'El costo es: ' + str(resultado.cost) # print visor.stats #if __name__ == '__main__': # resolver('breadth_first', (5,3),True)
def resolver(metodo_busqueda, posiciones_personas): inicial = GenerarEstado(posiciones_personas) problema = RescateHieloProblem(inicial) if metodo_busqueda == "breadth_first": return breadth_first(problema, graph_search=True, viewer=ConsoleViewer()) if metodo_busqueda == "greedy": return greedy(problema, graph_search=True, viewer=ConsoleViewer()) if metodo_busqueda == "depth_first": return depth_first(problema, graph_search=True, viewer=ConsoleViewer()) if metodo_busqueda == "astar": return astar(problema, graph_search=True, viewer=ConsoleViewer())
def resolver(metodo_busqueda, posiciones_personas): state = ((0, 0), (posiciones_personas), ()) my_viewer = BaseViewer() if 'astar': result = astar(TpProblem(state), graph_search=True, viewer=my_viewer) elif 'breadth_first': result = breadth_first(TpProblem(state), graph_search=True, viewer=my_viewer) elif 'depth_first': result = depth_first(TpProblem(state), graph_search=True, viewer=my_viewer) elif 'greedy': result = greedy(TpProblem(state), graph_search=True, viewer=my_viewer) return result
def resolver(metodo_busqueda, franceses, piratas): viewer = None letra = 0 franceses = list(franceses) piratas = list(piratas) for barcos in piratas: if letra == 0: piratas[0] = list(piratas[0]) piratas[0].insert(0, 'A') piratas[0].append(0) piratas[0].append(0) piratas[0] = tuple(piratas[0]) if letra == 1: piratas[1] = list(piratas[1]) piratas[1].insert(0, 'B') piratas[1].append(0) piratas[1].append(0) piratas[1] = tuple(piratas[1]) if letra == 2: piratas[2] = list(piratas[2]) piratas[2].insert(0, 'C') piratas[2].append(0) piratas[2].append(0) piratas[2] = tuple(piratas[2]) letra = letra + 1 estado = ((tuple(piratas), tuple(franceses))) problem = Barcos_Piratas(estado) if metodo_busqueda == "breadth_first": resultado = breadth_first(problem, graph_search=True, viewer = viewer) elif metodo_busqueda == "greedy": resultado = greedy(problem, graph_search=True, viewer = viewer) elif metodo_busqueda == "depth_first": resultado = depth_first(problem, graph_search=True, viewer = viewer) elif metodo_busqueda == "astar": resultado = astar(problem, graph_search=True, viewer = viewer) elif metodo_busqueda == "uniform_cost": resultado = uniform_cost(problem, graph_search=True, viewer = viewer) return resultado
def createProblem(listaSnake, food, method, direction): problem = SnakeGame((listaSnake[0].rect.x, listaSnake[0].rect.y), (food.rect.x, food.rect.y), listaSnake, direction) if method == "astar": result = astar(problem, graph_search=True) elif method == "dfs": result = depth_first(problem, graph_search=True) else: result = breadth_first(problem, graph_search=True) if result == None: return False moves = result.path() moves = moves[1:] lm = [] for i in moves: lm.append(i[0]) lm.reverse() return lm
def resolver(metodo_busqueda, posicion_rey, controlar_estados_repetidos): problema = HnefataflProblema(posicion_rey) visor = BaseViewer() #Busquedas, Grafo -> graph_search=True if (metodo_busqueda == 'breadth_first'): # En amplitud resultado = breadth_first(problema, graph_search=controlar_estados_repetidos, viewer=visor) elif (metodo_busqueda == 'depth_first'): # Profundidad resultado = depth_first(problema, graph_search=controlar_estados_repetidos, viewer=visor) elif (metodo_busqueda == 'greedy'): # Avara resultado = greedy(problema, graph_search=controlar_estados_repetidos, viewer=visor) elif (metodo_busqueda == 'astar'): # Estrella resultado = astar(problema, graph_search=controlar_estados_repetidos, viewer=visor) print(visor.stats) return resultado
def resolver(metodo_busqueda, posiciones_aparatos): estado = [ (3, 3, 0), ] nuevo_estado = ((), ) lista_aparatos = [] posiciones_aparatos = list(posiciones_aparatos) for artefacto in posiciones_aparatos: lista_artefacto = list(artefacto) lista_aparatos.append(lista_artefacto) posiciones_aparatos = tuple(posiciones_aparatos) for aparato in lista_aparatos: aparato.append(300) for aparato in lista_aparatos: tupla_aparato = tuple(aparato) estado.append(tupla_aparato) nuevo_estado = tuple(estado) problema = BomerobotProblem(nuevo_estado) if metodo_busqueda == 'breadth_first': resultado = breadth_first(problema, graph_search=True) return resultado if metodo_busqueda == 'depth_first': resultado = depth_first(problema, graph_search=True) return resultado if metodo_busqueda == 'greedy': resultado = greedy(problema, graph_search=True) return resultado if metodo_busqueda == 'astar': resultado = astar(problema, graph_search=True) return resultado
def is_goal(self, state): """ This method evaluates whether the specified state is the goal state. state : The game state to test. """ return state == self.goal #------------------------------------------------------------------------------------------------------------------ # Program #------------------------------------------------------------------------------------------------------------------ # Create solver object result = breadth_first(MissionariesAndCannibals(), graph_search=True) # Print results for i, (action, state) in enumerate(result.path()): print() if action == None: print('Initial configuration') elif i == len(result.path()) - 1: print('After moving', action, 'Goal achieved!') else: print('After moving', action) print(state) #------------------------------------------------------------------------------------------------------------------ # End of file
available_actions.append(state[row_zero - 1][col_zero]) if row_zero < 2: available_actions.append(state[row_zero + 1][col_zero]) if col_zero > 0: available_actions.append(state[row_zero][col_zero - 1]) if col_zero < 2: available_actions.append(state[row_zero][col_zero + 1]) return available_actions def result(self, state, action): row_zero, col_zero = find(0, state) row_piece, col_piece = find(action, state) #convert tuples to list state_modifiable = list(list(row) for row in state) state_modifiable[row_zero][col_zero] = action state_modifiable[row_piece][col_piece] = 0 #convert list to tuples state_modifiable = tuple(tuple(row) for row in state_modifiable) return state_modifiable def cost(self, state1, action, state2): return 1 problem = EightPuzzle(INITIAL_STATE) result = breadth_first(problem, viewer=WebViewer())
def is_goal(self, state): return GOAL_STATE == state def actions(self, state): available_actions = [] print(ROOMS.get(state)) for room in ROOMS.get(state): available_actions.append((room)) return available_actions def result(self, state, action): room = action #convert tuples to list state_modifiable = state state_modifiable = (room) #convert list to tuples return state_modifiable def cost(self, state1,action, state2): return 1 problem = Labyrinth(INITIAL_STATE) result = breadth_first(problem, graph_search=True, viewer=WebViewer()) for element in result.path(): print(element) print(result)
state.insert(1 + i, "wa") state.remove("wb") for i in range(sheeps): state.insert(len(state), "sa") state.remove("sb") else: state[0] = "b" for i in range(wolfs): state.insert(1 + i, "wb") state.remove("wa") for i in range(sheeps): state.insert(len(state), "sb") state.remove("sa") return "-".join(state) def is_goal(self, state): if state == "b-wb-wb-wb-sb-sb-sb": return True else: return False test = IbrahimProblem(initial_state="a-wa-wa-wa-sa-sa-sa") result = breadth_first(test) print(result.state) # the goal state print(result.path())
elif action == 'MD': p = t[pos[0]][pos[1] + 1] t[pos[0]][pos[1]] = p t[pos[0]][pos[1] + 1] = 0 return self.convertStateintoTuple(t) def is_goal(self, state): return state == GOAL size = width, height = [800, 600] pygame.init() pantalla = pygame.display.set_mode(size) p = Puzzle() result = breadth_first(Puzzle(INITIAL)) resultado = result.path() print(resultado) done = False interactive = False while not done: font = pygame.font.Font('freesansbold.ttf', 20) if not interactive: for action, state in resultado: y = 1 if action == 'MB': render = font.render("Movio el espacio hacia abajo", True, [255, 255, 255]) pos = [100, 50] pantalla.blit(render, pos) elif action == 'MA':
return list(' ABCDEFGHIJKLMNOPQRSTUVWXYZ') return [] def result(self, state, action): return state + action def is_goal(self, state): return state == GOAL def heuristic(self, state): wrong = sum( [1 if state[i] != GOAL[i] else 0 for i in range(len(state))]) missing = len(GOAL) - len(state) return wrong + missing # Using Breadth-First Search t1 = time.time() problem = HelloProblem(initial_state='') result = breadth_first(problem) print('Time: {:.5f}s'.format(time.time() - t1)) print(result.state) print(result.path()) # Using Greedy Search t1 = time.time() problem = HelloProblem(initial_state='') result = greedy(problem) print('Time: {:.5f}s'.format(time.time() - t1)) print(result.state) print(result.path())
'''Returns true if a state is the goal state.''' return state == GOAL def cost(self, state1, action, state2): '''Returns the cost of performing an action. No useful on this problem, i but needed. ''' return 1 def heuristic(self, state): '''Returns an *estimation* of the distance from a state to the goal. We are using the manhattan distance. ''' rows = string_to_list(state) distance = 0 row_c, col_c = find_location(rows, 'c') row_c_goal, col_c_goal = goal_positions['c'] distance += abs(row_c - row_c_goal) + abs(col_c - col_c_goal) return distance result = breadth_first(SnakeProblem(INITIAL), graph_search=True) for action, state in result.path(): print('Move ', action) print(state)
def test_breadth_first(self): result = breadth_first(self.problem) self.assertEquals(result.state, GOAL)
def actions(self, state): if len(state) < len(GOAL): return list(' ABCDEFGHIJKLMNOPQRSTUVWXYZ') return [] def result(self, state, action): return state + action def is_goal(self, state): return state == GOAL def heuristic(self, state): wrong = sum([1 if state[i] != GOAL[i] else 0 for i in range(len(state))]) missing = len(GOAL) - len(state) return wrong + missing # Using Breadth-First Search t1 = time.time() problem = HelloProblem(initial_state='') result = breadth_first(problem) print('Time: {:.5f}s'.format(time.time() - t1)) print(result.state) print(result.path()) # Using Greedy Search t1 = time.time() problem = HelloProblem(initial_state='') result = greedy(problem) print('Time: {:.5f}s'.format(time.time() - t1)) print(result.state) print(result.path())
def doBreadthFirst(NEWMAP, problem, myviewer): result = breadth_first(problem, graph_search=True, viewer=myviewer) path = [x[1] for x in result.path()] print("Ruta realizada Anchura:") print(result.path()) print(printMap(NEWMAP, problem, path))
def resolver(metodo_busqueda, posiciones_personas): state = ((0, 0), (posiciones_personas), ()) my_viewer = BaseViewer() if 'astar': result = astar(TpProblem(state), graph_search=True, viewer=my_viewer) elif 'breadth_first': result = breadth_first(TpProblem(state), graph_search=True, viewer=my_viewer) elif 'depth_first': result = depth_first(TpProblem(state), graph_search=True, viewer=my_viewer) elif 'greedy': result = greedy(TpProblem(state), graph_search=True, viewer=my_viewer) return result if __name__ == "__main__": my_viewer = BaseViewer() state = ((0, 0), ((2, 1), (3, 4), (4, 2)), ()) result = breadth_first(TpProblem(state), graph_search=True, viewer=my_viewer) print("Stats: ", my_viewer.stats) print("Solucion: ", result.state) print("profundidad_solucion: ", len(result.path())) print("costo_solucion:", result.cost)