def asignar_random(prefs):
sol = Planilla(prefs)
while len(sol.estudiantes_sin_topico()) > 0:
e = random.choice(list(sol.estudiantes_sin_topico()))
t = random.choice(list(sol.topicos_sin_estudiante()))
sol.asignar(e, t)
return sol
def asignar_backtracking(prefs):
# Funcion de busqueda por fuerza bruta
# Creamos un objeto de tipo Planilla
sol = Planilla(prefs)
# Hallamos la solucion llamando una funcion auxiliar
solucion = asignar_backtracking_aux(sol)
return solucion
def asignar_greedy(prefs):
'''
Asigna estudiantes y topicos por:
- orden en que un estudiante es listado por prefs.
- orden de preferencias asumiendo que el primero es el mas preferido.
'''
sol = Planilla(prefs)
# Itero a traves de los estudiantes sin topico.
for e in sol.estudiantes_sin_topico():
# Obtengo la lista de preferencias de los topicos del estudiante e.
prefs_e = prefs.preferencias_del_estudiante(e)
# Obtengo los topicos sin estudiante al momento.
topicos_sin_asignar = sol.topicos_sin_estudiante()
i = 0
t_i = prefs_e[i]
while (t_i not in topicos_sin_asignar) and (i < len(prefs_e)):
'''
Mientras sea un topico asignado se sigue iternado. Cuando se encuentra el topico
de menor costo (se itera de menor costo a mayor costo) libre se deja de iterar y se asigna
el topico al estudiante
'''
i = i + 1
t_i = prefs_e[i]
sol.asignar(e, t_i)
return sol
def asignar_random(prefs):
'''
funcion que genera una solucion aleatoria del espacio de soluciones
posibles en la asignacion de topicos a estudiantes
'''
sol = Planilla(prefs)
while len(sol.estudiantes_sin_topico()) > 0:
e = random.choice(list(sol.estudiantes_sin_topico()))
t = random.choice(list(sol.topicos_sin_estudiante()))
sol.asignar(e, t)
return sol
def asignar_greedy(prefs):
sol = Planilla(prefs)
#Recorro todos los estudiantes uno a uno
for student in sol.estudiantes_sin_topico():
#Recorro las preferencias del estudiante en cuestión por orden
#de preferencia
for topic in prefs.preferencias_del_estudiante(student):
#Asigno al estudiante el primer tópico desocupado
if sol.topico_libre(topic) and sol.estudiante_libre(student):
sol.asignar(student, topic)
return sol
def asignar_backtracking(prefs):
#Primero se crea la planilla sobre la que se va a trabajar
planilla = Planilla(prefs)
#planilla_buena = asignar_random(prefs)
if planilla.topicos_con_estudiante==prefs._cantidad:
planilla_buena=planilla
else:
for e in planilla.estudiantes_sin_topico():
for t in planilla.topicos_sin_estudiante():
#paso adelante
planilla.asignar(e, t)
#recursión
planilla=asignar_backtracking(prefs)
#guardo el mejor resultado
if planilla.calcular_costo()<planilla_buena.calcular_costo():
planilla_buena=planilla
#paso atrás
planilla.desasignar(e, t)
return(planilla_buena)
from planilla import Preferencias, Planilla
prefs = Preferencias("Ejemplo3")
print(prefs)
# imprime {1: [2, 1, 3], 2: [1, 2, 3], 3: [1, 3, 2]}
print(prefs.estudiantes())
# imprime {1, 2, 3}
sol = Planilla(prefs)
print(sol)
# imprime {}
sol.asignar(1, 2)
print(sol.estudiantes_con_topico()) # imprime {1}
print(sol.topicos_sin_estudiante()) # imprime {1, 3}
print(sol)
# imprime {1: 2}
sol.asignar(1, 1)
# el estudiante 1 ya tenia topico
# sol.asignar(3, 2)
print(sol)
print(sol.calcular_costo())
print(sol.estudiante_libre(3))
sol.asignar(2, 1)
sol.asignar(3, 3)
print(sol)
print(sol.calcular_costo())
# el topico 2 no estaba disponible
# imprime {1: 2}
# imprime inf
# imprime True
# imprime {1: 2, 2: 1, 3: 3}
# imprime 1
def asignar_backtracking(prefs):
sol = Planilla(prefs)
return asignar_backtracking_internal(sol, prefs)