def insertar_en_pos(self, i, x): """ Inserta el elemento x en la posicion i. Si la posicion es invalida, levanta IndexError""" if i < 0 or i > self.len: raise IndexError('Posición inválida') nuevo = n.Nodo(x) if i == 0: # Caso particular, insertar al principio nuevo.prox = self.prim self.prim = nuevo else: # Buscar el nodo anterior a la posicion deseada anterior = self.prim actual = anterior.prox for pos in range(1, i): anterior = anterior.prox actual = actual.prox # Intercalar el nuevo nodo anterior.prox = nuevo nuevo.prox = actual self.len += 1
def duplicar_elemento(self, elemento): """Recibe un elemento y duplica todas sus apariciones dentro de la lista """ if self.esta_vacia(): raise ValueError("Lista vacía.") act = self.prim while act: if act.dato == elemento: # Ojo con crearlo afuera del while, puede ser mas de uno nuevo = n.Nodo(elemento) if act == self.ultimo: act.prox = nuevo nuevo.prox = None self.ultimo = nuevo else: nuevo.prox = act.prox act.prox = nuevo self.len += 1 # Si lo agrego no lo evalúo en la sgte vuelta act = act.prox.prox else: act = act.prox
def expandir1(lista,padre): while lista[0].__len__() > 0: accion = deepcopy(padre.accion) accion.append(lista[0].pop(0)) n = nodo.Nodo(lista[1].pop(0),padre,accion,padre.costo+1) filaNodo.append(n)
def filter(self, funcion): """ recibe: una funcion devuelve: una nueva lista enlazada con los elementos (de la lista actual) que cumplieron con el criterio de la funcion """ if self.esta_vacia(): raise ValueError("La lista esta vacía.") nueva = ListaEnlazada() act = self.prim while act: dato = funcion(act.dato) if not dato: act = act.prox continue nuevo_nodo = n.Nodo(act.dato) if nueva.esta_vacia(): nueva.prim = nuevo_nodo nueva.ultimo = nuevo_nodo else: nueva.ultimo.prox = nuevo_nodo nueva.ultimo = nuevo_nodo nueva.len += 1 act = act.prox return nueva
def hacer_movimiento_m(board): posibles = genera_hijo(board) mejor_mov = n.Nodo("", -999) for mov in posibles: if mov.valor > mejor_mov.valor: mejor_mov = mov return mejor_mov.movimiento
def genera_hijo(lista): mov = [] for i in lista.legal_moves: lista.push(i) valor = valor_heuristicas(lista) aux = n.Nodo(i, valor, lista.fen()) mov.append(aux) lista.pop() return mov
def insertar_al_final(self, x): """ Agrega un elemento al final ; si la lista esta vacia se actualiza el primero y el ultimo""" # print(f"DEBUGG : ENTRO {x}") nuevo = n.Nodo(x) if self.esta_vacia(): self.prim = self.ultimo = nuevo else: self.ultimo.prox = nuevo self.ultimo = nuevo self.len += 1
def obtener_sucesores(estado_actual): """ Obtiene los sucesores. Reglas: - Se conservan solo los sucesores con el mayor y menor valor de la heuristica. :param estado_actual: Estado actual del cual obtendra los sucesores. :return: Lista con los sucesores. """ sucesores = [] # obtener solo el maximo y el minimo min_heuristica = 100 min_nodo = nodo.Nodo([0, 0, 0]) max_heuristica = -100 max_nodo = nodo.Nodo([0, 0, 0]) for indice, elem_max in enumerate(estado_actual): for elem_new in xrange(elem_max): # Creo una copia del estado actual estado_aux = estado_actual[:] estado_aux[indice] = elem_new # Calcular heuristica. heuristica = evaluar_jugada(estado_aux) # Guardar el menor de los sucesores para el minimo. if heuristica < min_heuristica: min_heuristica = heuristica min_nodo = nodo.Nodo(estado_aux, evaluar_jugada(estado_aux)) # Guardar el mayor de los sucesores para el maximo. if heuristica > max_heuristica: max_heuristica = heuristica max_nodo = nodo.Nodo(estado_aux, evaluar_jugada(estado_aux)) # Guardar los sucesores. sucesores.append(min_nodo) sucesores.append(max_nodo) return sucesores
def minimo(estado_actual, jugadas): if estado_actual.estado_objetivo(): return estado_actual.heuristica * -1 if estado_actual.estado_final(): return estado_actual.heuristica * -1 valor_min = 100 aux = nodo.Nodo([0, 0, 0]) for sucesor in obtener_sucesores(estado_actual.estado): valor = maximo(sucesor, jugadas) if valor <= valor_min: aux = sucesor valor_min = valor jugadas[0] = aux.estado return valor_min
def append(self, x): """ Agrega un elemento al final ; si la lista esta vacia se actualiza el primero """ # print(f"DEBUGG : ENTRO {x}") nuevo = n.Nodo(x) if self.esta_vacia(): self.prim = nuevo return act = self.prim while act.prox: act = act.prox act.prox = nuevo self.len += 1
def MakeGrid(Bounds, rows, cols): x_increment = (Bounds[0].GetUL.GetLng() - Bounds[1].GetUL.GetLng()) / cols y_increment = (Bounds[1].GetUL.GetLat() - Bounds[3].GetDR.GetLat()) / rows current = Bounds[0].GetUL nodes = [] for i in range(0, rows): lat_next = current.GetLat() + y_increment nodes.append([]) for j in range(0, cols): lng_next = current.GetLng() + x_increment node = nodo.Nodo(lat_next / 2, lng_next / 2, 0) nodes[j].append(node) current = coor.Coordinate(current.GetLat(), lng_next) current = coor.Coordinate(lat_next, current.GetLng()) return nodes
def suma_acumulativa(self): """ Devuelve una lista enlazada con la suma acumulativa en cada nodo """ nueva = ListaEnlazada() if self.esta_vacia(): return nueva act = self.prim suma_ac = 0 while act: suma_ac += act.dato nodo = n.Nodo(suma_ac) nueva.append(nodo) act = act.prox return nueva
def minimo(estado_actual, jugadas): """ Reorna la jugada con menor valor de la heuristica. :param estado_actual: Jugada a evaluar. :param jugadas: Variable donde se guarda la jugada a realizar. :return: Valor de laheuristica. """ if estado_actual.estado_objetivo(): return estado_actual.heuristica * -1 if estado_actual.estado_final(): return estado_actual.heuristica * -1 # Obtener los sucesores. valor_min = 100 aux = nodo.Nodo([0, 0, 0]) for sucesor in obtener_sucesores(estado_actual.estado): # Guardar la peor jugada. valor = maximo(sucesor, jugadas) if valor <= valor_min: aux = sucesor valor_min = valor # Guardar la posible jugada a realizar. jugadas[0] = aux.estado return valor_min
def estado_inicial(): """ Define el estado inicial. :return: Instancia del nodo con el estado inicial. """ return nodo.Nodo([7, 5, 3])
def busquedaNoInformada(edoInicial, edoFinal, algoritmo): global estadoFinal estadoFinal = edoFinal n = nodo.Nodo(edoInicial, None, [], 1) _busquedaNoInformada(n, algoritmo)
def estado_inicial(): """ Define el estado inicial. :return: Tupla con el estado inicial. """ return nodo.Nodo([7, 5, 3])