def resolver(metodo_busqueda, iteraciones):
problema = CspProblem(slots, dominios, restricciones)
if metodo_busqueda == "backtrack":
resultado = backtrack(problema)
return resultado
if metodo_busqueda == "min_conflicts":
return min_conflicts(problema, iterations_limit=iteraciones)
def resolver(metodo_busqueda, iteraciones):
#problema = CspProblem(variables, dominios, restricciones)
if metodo_busqueda == 'backtrack':
return backtrack(CspProblem(variables, dominios, restricciones))
if metodo_busqueda == 'min_conflicts':
return min_conflicts(CspProblem(variables, dominios, restricciones),
iterations_limit=iteraciones)
def resolver(metodo_busqueda):
problem = CspProblem(variables, dominios, restricciones)
if metodo_busqueda == "backtrack":
r = backtrack(problem, value_heuristic=LEAST_CONSTRAINING_VALUE, variable_heuristic=MOST_CONSTRAINED_VARIABLE, inference=True)
else:
r = min_conflicts(problem, iterations_limit=1000)
return r
def resolver(metodo_busqueda, iteraciones): problem = CspProblem(variables, dominios, restricciones) if metodo_busqueda == 'backtrack': result = backtrack(problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE) else: result = min_conflicts(problem, iterations_limit=iteraciones) return result
def resolver(metodo_busqueda, iteraciones):
problema = generar_problema_entrega2()
if metodo_busqueda == "backtrack":
resultado = backtrack(problema)
elif metodo_busqueda == "min_conflicts":
resultado = min_conflicts(problema, iterations_limit=iteraciones)
return resultado
def resolver(metodo_busqueda, iteraciones):
if metodo_busqueda == "backtrack":
resultado = backtrack(CspProblem(slots, dominios, restricciones), MOST_CONSTRAINED_VARIABLE, LEAST_CONSTRAINING_VALUE)
if metodo_busqueda == "min_conflicts":
resultado = min_conflicts(CspProblem(slots, dominios, restricciones), iterations_limit = iteraciones)
result = {}
for key, value in resultado.items():
result[key] = modulos[value]
return result
def resolver(cajas):
problema = generar_problema_csp_para_amagon(cajas)
inicio = datetime.datetime.now()
asignacion = min_conflicts(problema, iterations_limit=100)
tiempo = (datetime.datetime.now() - inicio).total_seconds()
conflictos = _find_conflicts(problema, asignacion)
print("Numero de conflictos en la solucion: {}".format(len(conflictos)))
print("Tiempo transcurrido: {} segundos".format(tiempo))
def resolver(metodo_busqueda, iteraciones):
problema = csp_conferencia()
if metodo_busqueda == "backtrack":
resultado = backtrack(problema)
#resultado = backtrack(problema, variable_heuristic=MOST_CONSTRAINED_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE)
elif metodo_busqueda == "min_conflicts":
resultado = min_conflicts(problema, iterations_limit=iteraciones)
return resultado
def resolver(metodo_busqueda, iteraciones):
unary()
problem = CspProblem(VARIABLES, DOMAINS, restricciones)
if metodo_busqueda == 'backtrack':
result = backtrack(problem,
value_heuristic=HIGHEST_DEGREE_VARIABLE,
variable_heuristic=MOST_CONSTRAINED_VARIABLE,
inference=False)
if metodo_busqueda == 'min_conflicts':
result = min_conflicts(problem, iterations_limit=iteraciones)
return result
def resolver(metodo_busqueda, iteraciones):
problem = CspProblem(variables, dominios, restricciones)
if metodo_busqueda == 'backtrack':
resultado = backtrack(problem=problem)
grabar('1', resultado, iteraciones=iteraciones)
return resultado
#def backtrack(problem, variable_heuristic='', value_heuristic='', inference=True):
if metodo_busqueda == 'min_conflicts':
resultado = min_conflicts(problem=problem,
iterations_limit=iteraciones)
#print iteraciones, resultado
grabar('2', resultado, iteraciones=iteraciones)
return resultado
def no_en_diagonal(variables, valores):
fila_a = valores[0]
columna_a = int(variables[0][1])
fila_b = valores[1]
columna_b = int(variables[1][1])
return abs(fila_a - fila_b) != abs(columna_a - columna_b)
restricciones = []
for reina_a, reina_b in itertools.combinations(variables, 2):
restricciones.append(((reina_a, reina_b), distinta_fila))
restricciones.append(((reina_a, reina_b), no_en_diagonal))
problem = CspProblem(variables, dominios, restricciones)
print 'backtrack:'
result = backtrack(problem,
variable_heuristic=MOST_CONSTRAINED_VARIABLE,
value_heuristic=LEAST_CONSTRAINING_VALUE,
inference=True)
print result
print 'min_conflicts:'
result = min_conflicts(problem, iterations_limit=100)
print result
constraints = [(('John', 'Anna', 'Tom'), constraint_unique),
(('Tom', 'Anna'), constraint_bigger),
(('John', 'Patricia'), constraint_odd_even)]
problem = CspProblem(variables, domains, constraints)
print('\nSolutions:\n\nNormal:', backtrack(problem))
print('\nMost constrained variable:',
backtrack(problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE))
print('\nHighest degree variable:',
backtrack(problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE))
print('\nLeast constraining value:',
backtrack(problem, variable_heuristic=LEAST_CONSTRAINING_VALUE))
print(
'\nMost constrained variable and least constraining value:',
backtrack(problem,
variable_heuristic=MOST_CONSTRAINED_VARIABLE,
value_heuristic=LEAST_CONSTRAINING_VALUE))
print(
'\nHighest degree and least constraining value:',
backtrack(problem,
variable_heuristic=HIGHEST_DEGREE_VARIABLE,
value_heuristic=LEAST_CONSTRAINING_VALUE))
print('\nMinimum conflicts:', min_conflicts(problem))
def resolver(metodo_busqueda, iteraciones):
problema = CspProblem(casillas, dominios, restricciones)
if metodo_busqueda == "backtrack":
return backtrack(problema)
if metodo_busqueda == "min_conflicts":
return min_conflicts(problema, iterations_limit=iteraciones)
'7V': [x for x in text if len(x) == 2],
'8H': [x for x in text if len(x) == 2],
'8V': [x for x in text if len(x) == 2],
'9V': [x for x in text if len(x) == 2],
'10H': [x for x in text if len(x) == 3],
'11H': [x for x in text if len(x) == 2],
}
restricciones = []
def misma_letra_inicio(variables, valores):
return valores[0][0] == valores[1][0]
restricciones.append((('1H', '1V'), misma_letra_inicio))
restricciones.append((('2V', '2H'), misma_letra_inicio))
restricciones.append((('4H', '4V'), misma_letra_inicio))
restricciones.append((('8H', '8V'), misma_letra_inicio))
restricciones.append((('7H', '7V'), misma_letra_inicio))
def son_distintas(variables, valores):
return valores[0] != valores[1]
for palabra_a, palabra_b in itertools.combinations(variables, 2):
restricciones.append(((palabra_a, palabra_b), son_distintas))
print min_conflicts(CspProblem(variables, dominios, restricciones),
iterations_limit=5000)
if var2 not in INTERCONECTADAS[var1]:
return False
return True
def distintos(vars, vals):
return len(set(vals)) == len(vals)
def escudo_comunicaciones(vars, vals):
if 'escudo' in vals and 'comunicacion' in vals:
var1, var2 = vars
if var1 in INTERCONECTADAS[var2]:
return False
return True
restricciones = []
for pos1, pos2 in itertools.combinations(variables, 2):
restricciones.append(((pos1, pos2), motor_u_ocultamiento))
restricciones.append(((pos1, pos2), torpedos_apuntamiento))
restricciones.append(((pos1, pos2), distintos))
restricciones.append(((pos1, pos2), escudo_comunicaciones))
problema = CspProblem(variables, dominios, restricciones)
# resultado = backtrack(problema, value_heuristic=LEAST_CONSTRAINING_VALUE,
# variable_heuristic=MOST_CONSTRAINED_VARIABLE)
resultado = min_conflicts(problema)
print(resultado)
from simpleai.search import CspProblem, backtrack, min_conflicts, MOST_CONSTRAINED_VARIABLE, HIGHEST_DEGREE_VARIABLE, LEAST_CONSTRAINING_VALUE
variables = ('WA', 'NT', 'SA', 'Q', 'NSW', 'V', 'T')
domains = dict((v, ['red', 'green', 'blue']) for v in variables)
def const_different(variables, values):
return values[0] != values[1] # expect the value of the neighbors to be different
constraints = [
(('WA', 'NT'), const_different),
(('WA', 'SA'), const_different),
(('SA', 'NT'), const_different),
(('SA', 'Q'), const_different),
(('NT', 'Q'), const_different),
(('SA', 'NSW'), const_different),
(('Q', 'NSW'), const_different),
(('SA', 'V'), const_different),
(('NSW', 'V'), const_different),
]
my_problem = CspProblem(variables, domains, constraints)
print backtrack(my_problem)
print backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE)
print backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE)
print backtrack(my_problem, value_heuristic=LEAST_CONSTRAINING_VALUE)
print backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE)
print backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE)
print min_conflicts(my_problem)
constraints = [((i, j), const_different) for i in range(len(variables))
for j in range(i, len(variables)) if i != j]
my_problem = CspProblem(variables.keys(), domains, constraints)
t1 = time.time()
res = backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE)
print('\n\n\n\nMinimum remaining value: {}s'.format(time.time() - t1))
pretty_print(res, variables, values)
t1 = time.time()
res = backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE)
print('\n\n\n\nDegree heuristic: {}s'.format(time.time() - t1))
pretty_print(res, variables, values)
t1 = time.time()
res = backtrack(my_problem, value_heuristic=LEAST_CONSTRAINING_VALUE)
print('\n\n\n\nLeast constraining value: {}s'.format(time.time() - t1))
pretty_print(res, variables, values)
t1 = time.time()
res = min_conflicts(my_problem)
print('\n\n\n\nForward checking: {}s'.format(time.time() - t1))
pretty_print(res, variables, values)
t1 = time.time()
res = result = backtrack(my_problem, inference=False)
print('\n\n\n\nConstraint propagation: {}s'.format(time.time() - t1))
pretty_print(res, variables, values)
def no_supera_3000(variables, valores):
suma = 0
for valor in valores:
suma += equipamientos[valor][1]
return suma < 3000
def no_armadura(variables, valores):
suma1 = 0
for valor in valores:
if equipamientos[valor][0] == 1:
suma1 += 1
return suma1 == 1
def no_espadas(variables, valores):
suma2 = 0
for valor in valores:
if equipamientos[valor][0] == 2:
suma2 += 1
return suma2 == 1
restricciones.append((variables, no_armadura))
restricciones.append((variables, no_espadas))
restricciones.append((variables, no_supera_3000))
print 'Backtrack', backtrack(CspProblem(variables, dominios, restricciones))
print 'Min Conflicts', min_conflicts(CspProblem(variables, dominios,
restricciones),
iterations_limit=10000)
if arriba[0]<0:
arriba = (-1,-1)
abajo = (casilla[0]+1, casilla[1])
if abajo[0] >= largo:
abajo = (-1,-1)
derecha = (casilla[0], casilla[1]+1)
if derecha[1] >= ancho:
derecha = (-1,-1)
izquierda = (casilla[0], casilla[1]-1)
if izquierda[1] < 0:
izquierda = (-1,-1)
restricciones.append(((arriba, abajo, izquierda, derecha), no_adyacentes))
restricciones.append((variables,cantidad_valida))
def imprimir_tablero(resultado):
print '-'*40
for fila in range(largo):
fila_print = ''
for columna in range(ancho):
fila_print += '|%i' %resultado[(fila, columna)]
print fila_print
print '\n'
print 'Backtrack'
imprimir_tablero(backtrack(CspProblem(variables,dominio,restricciones)))
print 'Min conflicts'
imprimir_tablero(min_conflicts(CspProblem(variables,dominio,restricciones), iterations_limit=5000))
from simpleai.search import CspProblem, backtrack, min_conflicts, MOST_CONSTRAINED_VARIABLE, HIGHEST_DEGREE_VARIABLE, LEAST_CONSTRAINING_VALUE
variables = ('WA', 'NT', 'SA', 'Q', 'NSW', 'V', 'T')
domains = dict((v, ['red', 'green', 'blue']) for v in variables)
def const_different(variables, values):
return values[0] != values[1] # expect the value of the neighbors to be different
constraints = [
(('WA', 'NT'), const_different),
(('WA', 'SA'), const_different),
(('SA', 'NT'), const_different),
(('SA', 'Q'), const_different),
(('NT', 'Q'), const_different),
(('SA', 'NSW'), const_different),
(('Q', 'NSW'), const_different),
(('SA', 'V'), const_different),
(('NSW', 'V'), const_different),
]
my_problem = CspProblem(variables, domains, constraints)
print(backtrack(my_problem))
print(backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE))
print(backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE))
print(backtrack(my_problem, value_heuristic=LEAST_CONSTRAINING_VALUE))
print(backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE))
print(backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE))
print(min_conflicts(my_problem))
((variables[20:30]), const_third_row),
((variables[30:40]), const_fourth_row),
((variables[40:50]), const_fifth_row),
((variables[50:60]), const_sixth_row),
((variables[60:70]), const_seventh_row),
((variables[70:80]), const_eight_row),
((variables[80:90]), const_nineth_row),
((variables[90:100]), const_tenth_row),
(list(variables[i] for i in range(0, 100, 10)), const_first_column),
(list(variables[i] for i in range(1, 100, 10)), const_second_column),
(list(variables[i] for i in range(2, 100, 10)), const_third_column),
(list(variables[i] for i in range(3, 100, 10)), const_fourth_column),
(list(variables[i] for i in range(4, 100, 10)), const_fifth_column),
(list(variables[i] for i in range(5, 100, 10)), const_sixth_column),
(list(variables[i] for i in range(6, 100, 10)), const_seventh_column),
(list(variables[i] for i in range(7, 100, 10)), const_eight_column),
(list(variables[i] for i in range(8, 100, 10)), const_nineth_column),
(list(variables[i] for i in range(9, 100, 10)), const_tenth_column),
]
#In order to decrease the run time of the algorithm
variables, domains, constraints = convert_to_binary(variables, domains,
constraints)
my_problem = CspProblem(variables, domains, constraints)
result = min_conflicts(my_problem)
for k, v in result.items():
print(k, v)
return values[0] != values[
1] #expect the value of neighbors to be different
constraints = [
(("WA", "NT"), const_different),
(("WA", "SA"), const_different),
(("SA", "NT"), const_different),
(("SA", "Q"), const_different),
(("NT", "Q"), const_different),
(("SA", "NSW"), const_different),
(("Q", "NSW"), const_different),
(("SA", "V"), const_different),
(("NSW", "V"), const_different),
]
my_problem = CspProblem(variables, domains, constraints)
print(backtrack(my_problem))
print(backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE))
print(backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE))
print(backtrack(my_problem, value_heuristic=LEAST_CONSTRAINING_VALUE))
print(
backtrack(my_problem,
variable_heuristic=MOST_CONSTRAINED_VARIABLE,
value_heuristic=LEAST_CONSTRAINING_VALUE))
print(
backtrack(my_problem,
variable_heuristic=HIGHEST_DEGREE_VARIABLE,
value_heuristic=LEAST_CONSTRAINING_VALUE))
print(min_conflicts(my_problem))
def diferentes(variables, valores):
return valores[0] != valores[1]
def suma_da_bien(variables, valores):
return valores[0] == valores[1] + valores[2]
restricciones = []
for variable1, variable2 in itertools.combinations(casillas, 2):
restricciones.append(((variable1, variable2), diferentes))
restricciones.append((('a', 'b', 'c'), suma_da_bien))
restricciones.append((('b', 'd', 'e'), suma_da_bien))
restricciones.append((('c', 'e', 'f'), suma_da_bien))
restricciones.append((('d', 'g', 'h'), suma_da_bien))
restricciones.append((('e', 'h', 'i'), suma_da_bien))
restricciones.append((('f', 'i', 'j'), suma_da_bien))
if __name__ == '__main__':
problema = CspProblem(casillas, dominios, restricciones)
resultado = backtrack(problema)
print 'backtrack:'
print resultado
resultado = min_conflicts(problema, iterations_limit=500)
print 'min conflicts:'
print resultado
x_b, y_b = b
return not (vals[0] == vals[1] and (x_a == x_b or y_a == y_b))
dominios = {(x, y): range(9) for x in range(9) for y in range(9)}
for valor, posiciones in enumerate(default):
for pos in posiciones:
dominios[pos] = [valor]
variables = dominios.keys()
restricciones = []
for par in itertools.combinations(variables, 2):
restricciones.append((par, eq_fila_columna))
restricciones.append((par, eq_cuadrante))
problem = CspProblem(variables, dominios, restricciones)
print "Inicio..."
print "Min conflicts"
r = min_conflicts(problem, iterations_limit=200)
tablero(r)
print "\n\n"
print "Backtrack"
r = backtrack(problem, value_heuristic=LEAST_CONSTRAINING_VALUE, variable_heuristic=MOST_CONSTRAINED_VARIABLE, inference=True)
tablero(r)
def const_different(variables, values):
return values[0] != values[
1] # expect the value of the neighbors to be different
constraints = [
(('WA', 'NT'), const_different),
(('WA', 'SA'), const_different),
(('SA', 'NT'), const_different),
(('SA', 'Q'), const_different),
(('NT', 'Q'), const_different),
(('SA', 'NSW'), const_different),
(('Q', 'NSW'), const_different),
(('SA', 'V'), const_different),
(('NSW', 'V'), const_different),
]
my_problem = CspProblem(variables, domains, constraints)
print backtrack(my_problem)
print backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE)
print backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE)
print backtrack(my_problem, value_heuristic=LEAST_CONSTRAINING_VALUE)
print backtrack(my_problem,
variable_heuristic=MOST_CONSTRAINED_VARIABLE,
value_heuristic=LEAST_CONSTRAINING_VALUE)
print backtrack(my_problem,
variable_heuristic=HIGHEST_DEGREE_VARIABLE,
value_heuristic=LEAST_CONSTRAINING_VALUE)
print min_conflicts(my_problem)
constraints.append((('M', 'A4'), equals))
print('Variables:', variables)
print('Domains:', domains)
problem = CspProblem(variables, domains, constraints)
print('Solving with backtracking')
result_bt = backtrack(problem,
variable_heuristic=MOST_CONSTRAINED_VARIABLE,
value_heuristic=LEAST_CONSTRAINING_VALUE,
inference=True)
print('Solving with min conflicts')
result_mc = min_conflicts(problem, iterations_limit=500)
print('Binarizing and solving again with backtracking')
new_variables, new_domains, new_constraints = convert_to_binary(
variables, domains, constraints)
result_btb = backtrack(CspProblem(new_variables, new_domains, new_constraints),
variable_heuristic=MOST_CONSTRAINED_VARIABLE,
value_heuristic=LEAST_CONSTRAINING_VALUE)
def human_result(result):
template = """
A4 A3 A2 A1
S E N D
+ M O R E
---------------
