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])
