addition — Recherche de solutions d’une énigme

Ce programme met en œuvre plusieurs algorithmes de recherche de solutions de l’énigme suivante.

Par quels chiffres faut-il remplacer les lettres pour que l’addition suivante soit correcte ?

\[\begin{split}\begin{array}{lcccc} & & &U&N \\ + & & &U&N \\ + & D&E&U&X \\ + & C&I&N&Q \\ \hline = & N&E&U&F \\ \end{array}\end{split}\]

La première solution présentée mets sept minutes à trouver les solutions, tandis que la dernière fait le même travail en moins de deux secondes.

Algorithmes

Version 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
def addition1():
    """Force brute, naïve."""
    for C in range(10):
        for D in range(10):
            for E in range(10):
                for F in range(10):
                    for I in range(10):
                        for N in range(10):
                            for Q in range(10):
                                for U in range(10):
                                    for X in range(10):
                                        if (
                                            C != D
                                            and C != E
                                            and C != F
                                            and C != I
                                            and C != N
                                            and C != Q
                                            and C != U
                                            and C != X
                                            and D != E
                                            and D != F
                                            and D != I
                                            and D != N
                                            and D != Q
                                            and D != U
                                            and D != X
                                            and E != F
                                            and E != I
                                            and E != N
                                            and E != Q
                                            and E != U
                                            and E != X
                                            and F != I
                                            and F != N
                                            and F != Q
                                            and F != U
                                            and F != X
                                            and I != N
                                            and I != Q
                                            and I != U
                                            and I != X
                                            and N != Q
                                            and N != U
                                            and N != X
                                            and Q != U
                                            and Q != X
                                            and U != X
                                        ):
                                            if (
                                                (10 * U + N)
                                                + (10 * U + N)
                                                + (1000 * C + 100 * I + 10 * N + Q)
                                                + (1000 * D + 100 * E + 10 * U + X)
                                                == 1000 * N + 100 * E + 10 * U + F
                                            ):
                                                yield (C, D, E, F, I, N, Q, U, X)

La première version est très naïve, et n’utilise aucune fonctionnalité avancée du langage Python (si ce n’est le yield pour itérer les solutions).

Chaque lettre a sa propre boucle (qui balaye tous les chiffres de 0 à 9), et avant de tester si les variables correspondent à une solution, on vérifie que chaque variable est différente avec un if qui teste chacune des 28 combinaisons possibles.

Cette version est très lente : l’exécution prend presque sept minutes.

Version 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
def addition2():
    """Manière un peu plus élégante de s'assurer que les lettres sont toutes différentes."""
    for C in range(10):
        for D in range(10):
            for E in range(10):
                for F in range(10):
                    for I in range(10):
                        for N in range(10):
                            for Q in range(10):
                                for U in range(10):
                                    for X in range(10):
                                        if len(set((C, D, E, F, I, N, Q, U, X))) == 9:
                                            if (
                                                (10 * U + N)
                                                + (10 * U + N)
                                                + (1000 * C + 100 * I + 10 * N + Q)
                                                + (1000 * D + 100 * E + 10 * U + X)
                                                == 1000 * N + 100 * E + 10 * U + F
                                            ):
                                                yield (C, D, E, F, I, N, Q, U, X)

Le if de la première version (qui teste si les variables sont distinctes) n’est pas très élégant. Cette seconde version remplace cette trentaine de lignes par une unique : len(set((C, D, E, F, I, N, Q, U, X))) == 9. Ce test vérifie que l’ensemble des neuf variables contient neuf éléments (si deux variables sont égales, la taille de l’ensemble sera moindre).

J’ai été surpris de constater que cette version est plus lente que la précédente : plus de dix minutes.

Version 3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
def addition3():
    """N'énumère que les cas où les valeurs des lettres sont toutes différentes."""
    for C in range(10):
        for D in range(10):
            if D == C:
                continue
            for E in range(10):
                if E in (C, D):
                    continue
                for F in range(10):
                    if F in (C, D, E):
                        continue
                    for I in range(10):
                        if I in (C, D, E, F):
                            continue
                        for N in range(10):
                            if N in (C, D, E, F, I):
                                continue
                            for Q in range(10):
                                if Q in (C, D, E, F, I, N):
                                    continue
                                for U in range(10):
                                    if U in (C, D, E, F, I, N, Q):
                                        continue
                                    for X in range(10):
                                        if X in (C, D, E, F, I, N, Q, U):
                                            continue
                                        if (
                                            (10 * U + N)
                                            + (10 * U + N)
                                            + (1000 * C + 100 * I + 10 * N + Q)
                                            + (1000 * D + 100 * E + 10 * U + X)
                                            == 1000 * N + 100 * E + 10 * U + F
                                        ):
                                            yield (C, D, E, F, I, N, Q, U, X)

Dans les versions précédentes, chacune des variables prend chacune des dix valeurs possibles, et c’est seulement juste avant de tester si l’addition est vérifiée ou non que l’on teste si les variables sont distinctes. C’est une perte de temps : dés qu’une variable prend la même valeur qu’une variable déjà définie, on peut passer à la valeur supérieure. C’est ce qui est mis en œuvre dans la fonction suivante.

Dans les deux versions précédentes, les boucles itèrent sur \(10^9\) éléments (soit un milliard). Avec cette version (ainsi que toutes les suivantes), les boucles n’itèrent plus que sur \(A^9_{10}\) arrangements (soit environ 3,6 millions). Cela fait 300 fois moins de tests, et explique que le temps d’exécution passe de sept minutes à seulemnt 8,5 secondes.

Version 4

1
2
3
4
5
6
7
def addition4():
    """Utilisation de `itertools.permutations`."""
    for C, D, E, F, I, N, Q, U, X in itertools.permutations(range(10), 9):
        if (10 * U + N) + (10 * U + N) + (1000 * C + 100 * I + 10 * N + Q) + (
            1000 * D + 100 * E + 10 * U + X
        ) == 1000 * N + 100 * E + 10 * U + F:
            yield (C, D, E, F, I, N, Q, U, X)

Cette version est la même que la précédente, sauf que l’énumération des arrangements n’est pas fait « à la main », mais en utilisant la fonction itertools.permutations() correspondante de la bibliothèque standard de Python. Ces fonctions de la bibliothèque standard ont été écrites par des gens plus intelligents que moi, testées depuis des années, écrites en C pour certaines : sauf cas très particulier, elles sont plus rapides que ce que je pourrais écrire.

Et en effet, le simple fait de remplacer mon implémentation des arrangements par l’appel de la bonne fonction de la bibliothèque standard fait passer le temps d’exécution de 8,5 secondes à 3,3 secondes (trois fois plus rapide).

Version 5

1
2
3
4
5
def addition5():
    """Réduction du nombre de multiplications."""
    for C, D, E, F, I, N, Q, U, X in itertools.permutations(range(10), 9):
        if 1000 * (C + D - N) + 100 * I + 10 * (2 * U + N) + (2 * N + Q + X - F) == 0:
            yield (C, D, E, F, I, N, Q, U, X)

Lors de la vérification de l’égalité \((10 \times U + N) + (10 \times U + N) + (1000 \times C + 100 \times I + 10 \times N + Q) + (1000 \times D + 100 \times E + 10 \times U + X) = 1000 \times N + 100 \times E + 10 \times U + F\), onze multiplications sont effectuées. En réarrangeant cette équation (en factorisant par 10, 100, et 1000), on obtient le test \(1000 \times (C + D - N) + 100 \times I + 10 \times (2 \times U + N) + (2 \times N + Q + X - F) = 0\) qui ne contient plus que trois multiplications (en ignorant les multiplications par 2). Cette simple optimisation fait-elle gagner de temps ?

Oui : elle permet de passer de 3,3 secondes à 2,1 secondes (soit un gain d’un tiers).

Version 6

1
2
3
4
5
6
7
8
def _sousfonction6(C):
    solutions = set()
    for D, E, F, I, N, Q, U, X in itertools.permutations(
        itertools.chain(range(0, C), range(C + 1, 10)), 8
    ):
        if 1000 * (C + D - N) + 100 * I + 10 * (2 * U + N) + (2 * N + Q + X - F) == 0:
            solutions.add((C, D, E, F, I, N, Q, U, X))
    return solutions
1
2
3
4
def addition6():
    """Parallélisation."""
    with multiprocessing.Pool() as pool:
        yield from itertools.chain(*pool.imap_unordered(_sousfonction6, range(10)))

La dernière optimisation permet de profiter des plusieurs processeurs utilisés par la plupart des ordinateurs modernes. La fonction de recherche est exécutée 10 fois, pour chacune des valeurs possibles de la première lettre C. Ces fonctions sont appelées avec autant d’exécution parallèles que de processeurs, en utilisant la classe multiprocessing.pool.Pool de la bibliothèque standand, qui gère tout cela de manière automatique.

Sur ma machine (qui possède quatre cœurs), cela permet de passer de 2 secondes d’exécution à seulement 1 seconde. Cela divise le temps d’exécution par deux, ce qui est moins que ce que l’on aurait pu attendre (une division par quatre avec quatre cœurs), mais c’est déjà bien.

Conclusion

Trois principales optimisations sont à remarquer.

  • La réduction de l’espace des solutions recherchées (des versions 2 à 3) a produit un algorithme 300 fois plus rapide. C’est la seule des optisations présentées ici qui réduit la complexité de l’algorithme.
  • L’utilisation de la bibliothèque standard de Python (modules itertools et multiprocessing).
  • La réduction du nombre de multiplications (versions 4 à 5).

Usage

Le binaire python -m jouets.addition n’accepte aucune option (plus précisément, il les ignore toutes). Il recherche les solutions de l’énigme en utilisant toutes les variantes possibles, affiche ces solutions, et le temps d’exécution de chaque fonction.