def arithmetic(puzzle="SEND+MORE=MONEY", base=10) -> None: problem = re.split(r"[\s+=]", puzzle) # remove spaces problem = list(filter(lambda w: len(w) > 0, problem)) letters = { letter: facile.variable(range(base)) for letter in set("".join(problem)) } # expressions expr_pb = [[letters[a] for a in word] for word in problem] def horner(a: Expression, b: Expression): return 10 * a + b words = [reduce(horner, word) for word in expr_pb] # constraints facile.constraint(facile.alldifferent(letters.values())) facile.constraint(facile.sum(words[:-1]) == words[-1]) for word in expr_pb: facile.constraint(word[0] > 0) assert facile.solve(letters.values()) # print solutions for word, numbers in zip(problem, expr_pb): strings = [str(n.value()) for n in numbers] print(f"{word} = {''.join(strings)}")
def arithmetic(puzzle="SEND+MORE=MONEY", base=10): problem = re.split("[\s+=]", puzzle) # remove spaces problem = list(filter(lambda w: len(w) > 0, problem)) # letters letters = {l: fcl.variable(range(base)) for l in set("".join(problem))} # expressions expr_pb = [[letters[a] for a in word] for word in problem] words = [reduce(lambda a, b: 10 * a + b, word) for word in expr_pb] # constraints fcl.constraint(fcl.alldifferent(letters.values())) fcl.constraint(sum(words[:-1]) == words[-1]) for word in expr_pb: fcl.constraint(word[0] > 0) assert fcl.solve(letters.values()) # print solutions for word, numbers in zip(problem, expr_pb): strings = [str(n.value()) for n in numbers] print(word + " = " + "".join(strings))
def test_nosolution() -> None: a, b, c = [facile.variable(0, 1) for _ in range(3)] facile.constraint(a != b) facile.constraint(b != c) facile.constraint(c != a) sol = facile.solve([a, b, c]) assert not sol.solved
def tile(sizes, bigsize): n = len(sizes) xs = [facile.variable(0, bigsize - sizes[i]) for i in range(n)] ys = [facile.variable(0, bigsize - sizes[i]) for i in range(n)] for i in range(n-1): for j in range(i+1, n): c_left = xs[j] + sizes[j] <= xs[i] # j on the left of i c_right = xs[j] >= xs[i] + sizes[i] # j on the right of i c_below = ys[j] + sizes[j] <= ys[i] # etc. c_above = ys[j] >= ys[i] + sizes[i] facile.constraint(c_left | c_right | c_below | c_above) # Redundant capacity constraint def full_line(xy): for i in range(bigsize): # equivalent to (xy[j] >= i - sizes[j] + 1) & (xy[j] <= i) intersections = \ [xy[j].in_interval(i - sizes[j] + 1, i) for j in range(n)] scal_prod = sum([s * k for s, k in zip(sizes, intersections)]) facile.constraint(scal_prod == bigsize) full_line(xs) full_line(ys) if facile.solve(xs + ys, heuristic=facile.Heuristic.Min_min): try: import matplotlib.pyplot as plt import matplotlib.cm as colormap from random import random as rand fig = plt.figure() ax = fig.gca() def fill_square(x, y, s): plt.fill([x, x, x+s, x+s], [y, y+s, y+s, y], color=colormap.Pastel1(rand())) fill_square(0, 0, bigsize) for (x, y, s) in zip(xs, ys, sizes): fill_square(x.value(), y.value(), s) ax.set_xlim((0, bigsize)) ax.set_ylim((0, bigsize)) ax.set_aspect(1) ax.set_xticks(range(bigsize + 1)) ax.set_yticks(range(bigsize + 1)) fig.set_size_inches(7, 7) ax.set_frame_on(False) plt.pause(10) except Exception as e: # if matplotlib fails for an unknown reason print (e) for (x, y, s) in zip(xs, ys, sizes): print (x.value(), y.value(), s)
def tile(sizes, bigsize): n = len(sizes) xs = [facile.variable(0, bigsize - sizes[i]) for i in range(n)] ys = [facile.variable(0, bigsize - sizes[i]) for i in range(n)] for i in range(n - 1): for j in range(i + 1, n): c_left = xs[j] + sizes[j] <= xs[i] # j on the left of i c_right = xs[j] >= xs[i] + sizes[i] # j on the right of i c_below = ys[j] + sizes[j] <= ys[i] # etc. c_above = ys[j] >= ys[i] + sizes[i] facile.constraint(c_left | c_right | c_below | c_above) # Redundant capacity constraint def full_line(xy): for i in range(bigsize): # equivalent to (xy[j] >= i - sizes[j] + 1) & (xy[j] <= i) intersections = \ [xy[j].in_interval(i - sizes[j] + 1, i) for j in range(n)] scal_prod = sum([s * k for s, k in zip(sizes, intersections)]) facile.constraint(scal_prod == bigsize) full_line(xs) full_line(ys) if facile.solve(xs + ys, heuristic=facile.Heuristic.Min_min): try: import matplotlib.pyplot as plt import matplotlib.cm as colormap from random import random as rand fig = plt.figure() ax = fig.gca() def fill_square(x, y, s): plt.fill([x, x, x + s, x + s], [y, y + s, y + s, y], color=colormap.Pastel1(rand())) fill_square(0, 0, bigsize) for (x, y, s) in zip(xs, ys, sizes): fill_square(x.value(), y.value(), s) ax.set_xlim((0, bigsize)) ax.set_ylim((0, bigsize)) ax.set_aspect(1) ax.set_xticks(range(bigsize + 1)) ax.set_yticks(range(bigsize + 1)) fig.set_size_inches(7, 7) ax.set_frame_on(False) plt.pause(10) except Exception as e: # if matplotlib fails for an unknown reason print(e) for (x, y, s) in zip(xs, ys, sizes): print(x.value(), y.value(), s)
def n_queens(n: int, *args, **kwargs) -> facile.Solution: queens = [facile.variable(range(n)) for i in range(n)] diag1 = [queens[i] + i for i in range(n)] diag2 = [queens[i] - i for i in range(n)] facile.constraint(facile.alldifferent(queens)) facile.constraint(facile.alldifferent(diag1)) facile.constraint(facile.alldifferent(diag2)) return facile.solve(queens, *args, **kwargs)
def picross_solve( lines: list[list[int]], columns: list[list[int]], ) -> tuple[facile.Solution, facile.Array]: n, m = len(lines), len(columns) grid = facile.Array.binary((n, m)) sol = facile.solve(grid) return sol, grid
def test_magical() -> None: array = [facile.variable(range(10)) for i in range(10)] for i in range(10): sum_ = facile.sum(x == i for x in array) facile.constraint(sum_ == array[i]) solution = facile.solve(array) assert solution.solved assert solution.solution == [6, 2, 1, 0, 0, 0, 1, 0, 0, 0]
def test_2d_array() -> None: n = 5 # array = facile.Array.binary((n, n)) var_array = [[facile.variable(0, 1) for _ in range(n)] for _ in range(n)] array = facile.array(np.array(var_array)) for i in range(n): facile.constraint(array[:, i].sum() == 1) facile.constraint(array[i, :].sum() == 1) x, y = facile.variable(range(n)), facile.variable(range(n)) facile.constraint(array[x, y] == 1) # TODO redundant but necessary to test one of the arguments as a variable # facile.constraint(array[:, x].sum() == 1) sol = facile.solve([*array]) assert sol.solved sol = facile.solve([*array, x, y]) assert sol.solved *_, x_, y_ = sol.solution assert array[x_, y_].value() == 1
def n_queen(n): """Solves the n-queen problem. """ queens = [variable(0, n - 1) for i in range(n)] diag1 = [queens[i] + i for i in range(n)] diag2 = [queens[i] - i for i in range(n)] constraint(alldifferent(queens)) constraint(alldifferent(diag1)) constraint(alldifferent(diag2)) if solve(queens): return [x.value() for x in queens] else: return None
def n_queen(n): """Solves the n-queen problem. """ queens = [variable(0, n-1) for i in range(n)] diag1 = [queens[i] + i for i in range(n)] diag2 = [queens[i] - i for i in range(n)] constraint(alldifferent(queens)) constraint(alldifferent(diag1)) constraint(alldifferent(diag2)) if solve(queens): return [x.value() for x in queens] else: return None
def n_queen(n): """Solves the n-queen problem. """ queens = [variable(range(n)) for i in range(n)] # prepare for animation def on_bt(nb_bt): for i, q in enumerate(queens): print(i, q.domain()) constraint(alldifferent(queens)) constraint(alldifferent(queens[i] - i for i in range(n))) constraint(alldifferent(queens[i] + i for i in range(n))) return solve(queens, strategy=queen_strategy, backtrack=True)
def test_basic_array() -> None: var_list = [facile.variable(0, 1) for _ in range(5)] array = facile.array(var_list) x = facile.variable(range(10)) msg = "list indices must be integers or slices, not facile.core.Variable" with pytest.raises(TypeError, match=msg): facile.constraint(var_list[x] == 1) # type: ignore facile.constraint(array[x] == 1) facile.constraint(array.sum() == 1) facile.constraint(x == 1) solution = facile.solve([*array, x]) assert solution.solved assert array.value() == [0, 1, 0, 0, 0]
def tatami_solve(xmax: int, ymax: int) -> list[facile.Solution]: """Solves the tatami problem. The variables in the solve_all must be passed in order: - x coordinates; - y coordinates; - xs the size of the tatami on the x axis (1: vertical, 2: horizontal); - other variables """ if (xmax * ymax) & 1 == 1: raise ValueError( f"The room area must be an even number: {xmax * ymax}") n = xmax * ymax // 2 # noqa: F841 # start with a "simple" solve(), then comment the line when things work return [facile.solve([], backtrack=True)] # the evaluation process expects that you return *all* solutions return facile.solve_all([], backtrack=True)
def test_domains() -> None: a = facile.variable(range(320)) b = facile.variable(range(160)) c = facile.variable(range(130)) d = facile.variable(range(130)) facile.constraint(a + b + c + d == 711) assert len(a.domain()) == 26 assert len(b.domain()) == 26 assert len(c.domain()) == 26 assert len(d.domain()) == 26 facile.constraint(a * b * c * d == 711000000) assert len(a.domain()) == 17 assert len(b.domain()) == 23 assert len(c.domain()) == 20 assert len(d.domain()) == 20 sol = facile.solve([a, b, c, d], backtrack=True) assert sol.solved assert sol.backtrack == 2
def lazy_n_queens(n: int, *args, **kwargs) -> facile.Solution: queens = [facile.variable(range(n)) for i in range(n)] diag1 = [queens[i] + i for i in range(n)] diag2 = [queens[i] - i for i in range(n)] # facile.constraint(facile.alldifferent(queens)) for i, q1 in enumerate(queens): for q2 in queens[i + 1:]: facile.constraint(q1 != q2) # facile.constraint(facile.alldifferent(diag1)) for i, q1 in enumerate(diag1): for q2 in diag1[i + 1:]: facile.constraint(q1 != q2) # facile.constraint(facile.alldifferent(diag2)) for i, q1 in enumerate(diag2): for q2 in diag2[i + 1:]: facile.constraint(q1 != q2) return facile.solve(queens, *args, **kwargs)
import facile # Magical sequence! # The value inside array[i] is equal to the number of i in array array = [facile.variable(0,10) for i in range(10)] for i in range(10): facile.constraint(sum([x == i for x in array]) == array[i]) if facile.solve(array): print ([v.value() for v in array])
# -*- coding: utf-8 -*- """ Find four numbers such that their sum is 711 and their product is 711000000 """ from facile import variable, constraint, solve a = variable(range(0, 330)) b = variable(range(0, 160)) c = variable(range(0, 140)) d = variable(range(0, 140)) constraint(a + b + c + d == 711) constraint(a * b * c * d == 711000000) sol = solve([a, b, c, d]) print("Solution found a={}, b={}, c={}, d={}".format(*sol.solution))
a = facile.variable(range(0, 321)) b = facile.variable(range(0, 161)) c = facile.variable(range(0, 131)) d = facile.variable(range(0, 131)) # Constraints # The problem facile.constraint(a + b + c + d == 711) print("Domains after posting the sum constraint") for x in [a, b, c, d]: domain = x.domain() print(" {!r} (size {})".format(domain, len(domain))) facile.constraint(a * b * c * d == 711000000) print("\nDomains after posting the mul constraint") for x in [a, b, c, d]: domain = x.domain() print(" {!r} (size {})".format(domain, len(domain))) print() # Resolution sol = facile.solve([a, b, c, d], backtrack=True) # wow ! Only two backtracks !! print(sol) print("Solution found: a={}, b={}, c={}, d={}".format(*sol.solution))
# -*- coding: utf-8 -*- """ Basic examples of CSP problems: - a ≠ b - alldifferent(a, b, c) and a + b <= 2c """ from facile import variable, constraint, solve, alldifferent a = variable(0, 1) b = variable(0, 1) constraint(a != b) if solve([a, b]): print ("Solution found a=%d and b=%d" % (a.value(), b.value())) a = variable(0, 2) b = variable(0, 2) c = variable(0, 2) constraint(alldifferent([a, b, c])) constraint(a + b <= 2 * c) if solve([a, b, c]): print ("Solution found a=%d, b=%d and c=%d" % (a.value(), b.value(), c.value()))
s = groups[i].sort() for j in range(nb_golfers): facile.constraint(s[j] == j//size_group) # [2] Use a Global Cardinality Constraint (redundant with [1]) gcc = groups[i].gcc([(size_group, i) for i in range(nb_groups)]) facile.constraint(gcc) # Two golfers do not play in the same group more than once for g1 in range(nb_golfers): for g2 in range(g1+1, nb_golfers): g1_with_g2 = [groups[w][g1] == groups[w][g2] for w in range(nb_weeks)] facile.constraint(sum(g1_with_g2) <= 1) # Breaking the symmetries # - 0 always in the first group, 1 in a group less than 1, ... # - First week (0) a priori chosen for w in range(nb_weeks): for g in range(nb_groups): facile.constraint(groups[w][g] <= g) for g in range(nb_golfers): facile.constraint(groups[0][g] == g//size_group) if (not facile.solve([v for k in groups for v in k ])): print ("No solution found") else: for v in groups: print (v.value())
# Agatha hates everybody except the butler. constraint(hates[agatha, charles] == 1) constraint(hates[agatha, agatha] == 1) constraint(hates[agatha, butler] == 0) # The butler hates everyone not richer than Aunt Agatha. # (richer[i, agatha] = 0) => (hates[butler, i] = 1), for i in range(n): constraint((richer[i, agatha] == 0) <= (hates[butler, i] == 1)) # The butler hates everyone whom Agatha hates. # (hates[agatha, i] = 1) => (hates[butler, i] = 1), for i in range(n): constraint((hates[agatha, i] == 1) <= (hates[butler, i] == 1)) # No one hates everyone. # (sum j: hates[i, j]) <= 2, for i in range(n): constraint(sum([hates[i, j] for j in range(n)]) <= 2) # Who killed Agatha? constraint(victim == agatha) assert solve(list(hates) + list(richer) + [victim, killer]) killer_value = killer.value() assert killer_value is not None msg = "{} killed Agatha." print(msg.format(["Agatha", "The butler", "Charles"][killer_value]))
def tiles(sizes, bigsize): n = len(sizes) xs = [variable(range(bigsize - sizes[i] + 1)) for i in range(n)] ys = [variable(range(bigsize - sizes[i] + 1)) for i in range(n)] for i in range(n - 1): for j in range(i + 1, n): c_left = xs[j] + sizes[j] <= xs[i] # j on the left of i c_right = xs[j] >= xs[i] + sizes[i] # j on the right of i c_below = ys[j] + sizes[j] <= ys[i] # etc. c_above = ys[j] >= ys[i] + sizes[i] constraint(c_left | c_right | c_below | c_above) # Redundant capacity constraint def full_line(xy): for i in range(bigsize): # equivalent to (xy[j] >= i - sizes[j] + 1) & (xy[j] <= i) intersections = [ xy[j].in_interval(i - sizes[j] + 1, i) for j in range(n) ] scal_prod = sum([s * k for s, k in zip(sizes, intersections)]) constraint(scal_prod == bigsize) full_line(xs) full_line(ys) gx = Goal.forall(xs, assign="assign", strategy="min_min") gy = Goal.forall(ys, assign="assign", strategy="min_min") # Now the proper resolution process solution = solve(gx & gy, backtrack=True) print(solution) try: import matplotlib.pyplot as plt # type: ignore fig, ax = plt.subplots(figsize=(7, 7)) def fill_square(x, y, s): plt.fill( [x, x, x + s, x + s], [y, y + s, y + s, y], color=plt.get_cmap("tab20")(random()), ) fill_square(0, 0, bigsize) for (x, y, s) in zip(xs, ys, sizes): fill_square(x.value(), y.value(), s) ax.set_xlim((0, bigsize)) ax.set_ylim((0, bigsize)) ax.set_aspect(1) ax.set_xticks(range(bigsize + 1)) ax.set_yticks(range(bigsize + 1)) ax.set_frame_on(False) plt.pause(10) except ImportError as e: # if matplotlib fails for an unknown reason print(e) for (x, y, s) in zip(xs, ys, sizes): print(x.value(), y.value(), s)
def test_solution() -> None: a = facile.variable([0, 1]) b = facile.variable([0, 1]) facile.constraint(a != b) sol = facile.solve([a, b]) assert sol.solved
] wife = array([variable(range(n)) for i in range(n)]) husband = array([variable(range(n)) for i in range(n)]) # You are your wife's husband, and conversely for m in range(n): constraint(husband[wife[m]] == m) for w in range(n): constraint(wife[husband[w]] == w) for m in range(n): for w in range(n): # m prefers this woman to his wife c1 = rank_men[m][w] < array(rank_men[m])[wife[m]] # w prefers her husband to this man c2 = array(rank_women[w])[husband[w]] < rank_women[w][m] # alias for c1 => c2 constraint(c1 <= c2) # w prefers this man to her husband c3 = rank_women[w][m] < array(rank_women[w])[husband[w]] # m prefers his wife to this woman c4 = array(rank_men[m])[wife[m]] < rank_men[m][w] constraint(c3 <= c4) if solve(list(wife) + list(husband)): for i in range(n): wife_value = wife[i].value() assert wife_value is not None print(f"{men[i]} <=> {women[wife_value]}")
import facile colouring = [facile.variable(range(3)) for i, _ in enumerate(points)] colours = ["ro", "bo", "go"] # Build edges between the five nodes in the inner circle for i in range(5): j, j_ = i, (i + 2) % 5 # % (modulo -> j=4, j_=0) facile.constraint(colouring[j] != colouring[j_]) # Build edges between the inner and the outer circle for i in range(5): facile.constraint(colouring[i] != colouring[i + 5]) # Build edges between the five nodes on the outer circle for i in range(5): j, j_ = 5 + i, 5 + (i + 1) % 5 # % (modulo -> j=9, j_=5) facile.constraint(colouring[j] != colouring[j_]) plot_edges() if facile.solve(colouring): for i, (x_, y_) in enumerate(points): plt.plot(x_, y_, colours[colouring[i].value()]) else: print("No solution found")
# -*- coding: utf-8 -*- """ Find four numbers such that their sum is 711 and their product is 711000000 """ from facile import variable, constraint, solve a = variable(0, 330) b = variable(0, 160) c = variable(0, 140) d = variable(0, 140) constraint(a + b + c + d == 711) constraint(a * b * c * d == 711000000) if solve([a, b, c, d]): [va, vb, vc, vd] = [x.value() for x in [a, b, c, d]] print("Solution found a=%d, b=%d, c=%d, d=%d" % (va, vb, vc, vd)) else: print("No solution found")
constraint(buckets[0][2] == 0) constraint(buckets[steps - 1][0] == 4) constraint(buckets[steps - 1][1] == 4) constraint(buckets[steps - 1][2] == 0) for i in range(steps - 1): # we change the contents of two buckets at a time sum_buckets = sum([buckets[i][b] != buckets[i + 1][b] for b in range(nb)]) constraint(sum_buckets == 2) # we play with a constant amount of water sum_water = sum([buckets[i][b] for b in range(nb)]) constraint(sum_water == 8) for b1 in range(nb): for b2 in range(b1): constraint( # either the content of the bucket does not change (buckets[i][b1] == buckets[i + 1][b1]) | (buckets[i][b2] == buckets[i + 1][b2]) | # or the bucket ends up empty or full (buckets[i + 1][b1] == 0) | (buckets[i + 1][b1] == capacity[b1]) | (buckets[i + 1][b2] == 0) | (buckets[i + 1][b2] == capacity[b2]) ) if solve([b for sub in buckets for b in sub]): for sub in buckets: print([b.value() for b in sub])
# [1] Use a Sorting Constraint (redundant with [2]) s = groups[i, :].sort() for j in range(nb_golfers): facile.constraint(s[j] == j // size_group) # [2] Use a Global Cardinality Constraint (redundant with [1]) gcc = groups[i, :].gcc([(size_group, i) for i in range(nb_groups)]) facile.constraint(gcc) # Two golfers do not play in the same group more than once for g1 in range(nb_golfers): for g2 in range(g1 + 1, nb_golfers): g1_with_g2 = [groups[w, g1] == groups[w, g2] for w in range(nb_weeks)] facile.constraint(facile.sum(g1_with_g2) <= 1) # Breaking the symmetries # - 0 always in the first group, 1 in a group less than 1, ... # - First week (0) a priori chosen for w in range(nb_weeks): for g in range(nb_groups): facile.constraint(groups[w, g] <= g) for g in range(nb_golfers): facile.constraint(groups[0, g] == g // size_group) if not facile.solve(list(groups)): print("No solution found") else: print(groups.value())
buckets = [ [variable(0, capacity[b]) for b in range(nb)] for i in range(steps)] constraint(buckets[0][0] == 8) constraint(buckets[0][1] == 0) constraint(buckets[0][2] == 0) constraint(buckets[steps - 1][0] == 4) constraint(buckets[steps - 1][1] == 4) constraint(buckets[steps - 1][2] == 0) for i in range(steps - 1): # we change the contents of two buckets at a time constraint( sum([buckets[i][b] != buckets[i+1][b] for b in range(nb)]) == 2) # we play with a constant amount of water constraint(sum([buckets[i][b] for b in range(nb)]) == 8) for b1 in range(nb): for b2 in range(b1): constraint( # either the content of the bucket does not change (buckets[i][b1] == buckets[i+1][b1]) | (buckets[i][b2] == buckets[i+1][b2]) | # or the bucket ends up empty or full (buckets[i+1][b1] == 0) | (buckets[i+1][b1] == capacity[b1]) | (buckets[i+1][b2] == 0) | (buckets[i+1][b2] == capacity[b2]) ) if solve([b for sub in buckets for b in sub]): for sub in buckets: print ([b.value() for b in sub])
old_gold, kools, chesterfields, lucky_strike, parliaments = cigarettes constraint(alldifferent(colors)) constraint(alldifferent(people)) constraint(alldifferent(animals)) constraint(alldifferent(drinks)) constraint(alldifferent(cigarettes)) constraint(englishman == red) constraint(spaniard == dog) constraint(coffee == green) constraint(ukrainian == tea) constraint(green == ivory + 1) constraint(old_gold == snails) constraint(kools == yellow) constraint(milk == 3) constraint(norwegian == 1) constraint(abs(fox - chesterfields) == 1) constraint(abs(horse - kools) == 1) constraint(lucky_strike == fruit_juice) constraint(japanese == parliaments) constraint(abs(norwegian - blue) == 1) assert solve(colors + people + animals + drinks + cigarettes) water_drinker = [n for n, p in zip(names, people) if p.value() == water.value()] zebra_owner = [n for n, p in zip(names, people) if p.value() == zebra.value()] print("The {} drinks water.".format(water_drinker[0])) print("The {} owns the zebra.".format(zebra_owner[0]))
# -*- coding: utf-8 -*- """ Basic examples of CSP problems: - a ≠ b - alldifferent(a, b, c) and a + b <= 2c """ from facile import variable, constraint, solve, alldifferent a = variable(0, 1) b = variable(0, 1) constraint(a != b) if solve([a, b]): print("Solution found a=%d and b=%d" % (a.value(), b.value())) a = variable(0, 2) b = variable(0, 2) c = variable(0, 2) constraint(alldifferent([a, b, c])) constraint(a + b <= 2 * c) if solve([a, b, c]): print("Solution found a=%d, b=%d and c=%d" % (a.value(), b.value(), c.value()))
s = groups[i].sort() for j in range(nb_golfers): facile.constraint(s[j] == j // size_group) # [2] Use a Global Cardinality Constraint (redundant with [1]) gcc = groups[i].gcc([(size_group, i) for i in range(nb_groups)]) facile.constraint(gcc) # Two golfers do not play in the same group more than once for g1 in range(nb_golfers): for g2 in range(g1 + 1, nb_golfers): g1_with_g2 = [groups[w][g1] == groups[w][g2] for w in range(nb_weeks)] facile.constraint(sum(g1_with_g2) <= 1) # Breaking the symmetries # - 0 always in the first group, 1 in a group less than 1, ... # - First week (0) a priori chosen for w in range(nb_weeks): for g in range(nb_groups): facile.constraint(groups[w][g] <= g) for g in range(nb_golfers): facile.constraint(groups[0][g] == g // size_group) if (not facile.solve([v for k in groups for v in k])): print("No solution found") else: for v in groups: print(v.value())
import facile # Magical sequence! # The value inside array[i] is equal to the number of i in array array = [facile.variable(0, 10) for i in range(10)] for i in range(10): facile.constraint(sum([x == i for x in array]) == array[i]) if facile.solve(array): print([v.value() for v in array])
# -*- coding: utf-8 -*- """ Find four numbers such that their sum is 711 and their product is 711000000 """ from facile import variable, constraint, solve a = variable(0, 330) b = variable(0, 160) c = variable(0, 140) d = variable(0, 140) constraint(a + b + c + d == 711) constraint(a * b * c * d == 711000000) if solve([a, b, c, d]): [va, vb, vc, vd] = [x.value() for x in [a, b, c, d]] print ("Solution found a=%d, b=%d, c=%d, d=%d" % (va, vb, vc, vd)) else: print ("No solution found")
import facile import functools # The list comprehension mechanism is always helpful! [s, e, n, d, m, o, r, y] = [facile.variable(range(10)) for i in range(8)] # A shortcut letters = [s, e, n, d, m, o, r, y] # Constraints facile.constraint(s > 0) facile.constraint(m > 0) facile.constraint(facile.alldifferent(letters)) send = functools.reduce(lambda x, y: 10 * x + y, [s, e, n, d]) more = functools.reduce(lambda x, y: 10 * x + y, [m, o, r, e]) money = functools.reduce(lambda x, y: 10 * x + y, [m, o, n, e, y]) facile.constraint(send + more == money) if facile.solve(letters): [vs, ve, vn, vd, vm, vo, vr, vy] = [x.value() for x in letters] print("Solution found :") print print(" %d%d%d%d" % (vs, ve, vn, vd)) print("+ %d%d%d%d" % (vm, vo, vr, ve)) print("------") print(" %d%d%d%d%d" % (vm, vo, vn, ve, vy)) else: print("No solution found")
facile.constraint(buckets[0][0] == 8) facile.constraint(buckets[0][1] == 0) facile.constraint(buckets[0][2] == 0) facile.constraint(buckets[steps - 1][0] == 4) facile.constraint(buckets[steps - 1][1] == 4) facile.constraint(buckets[steps - 1][2] == 0) for i in range(steps - 1): # we change the contents of two buckets at a time facile.constraint( sum([buckets[i][b] != buckets[i + 1][b] for b in range(nb)]) == 2) # we play with a constant amount of water facile.constraint(sum([buckets[i][b] for b in range(nb)]) == 8) for b1 in range(nb): for b2 in range(b1): facile.constraint( # either the content of the bucket does not change (buckets[i][b1] == buckets[i + 1][b1]) | (buckets[i][b2] == buckets[i + 1][b2]) | # or the bucket ends up empty or full (buckets[i + 1][b1] == 0) | (buckets[i + 1][b1] == capacity[b1]) | (buckets[i + 1][b2] == 0) | (buckets[i + 1][b2] == capacity[b2])) print(facile.solve([b for sub in buckets for b in sub], backtrack=True)) for sub in buckets: print([b.value() for b in sub])