Re: Modulo tout retourné dans les clefs

Le 04/09/2021 11:40, Benoit a écrit :

 
N’y a-t-il pas :
 
—      3 007 : 97 x 31 ==> 10 x 7 x 3 = 210 erreurs
—  7 000 005 : 97 x 72 165 ==> 7 x 3 x 5 = 105 erreurs
- 50 000 008 : 97 x 515464 ==> 6 X 5 X 2 = 60 erreurs

>
Oui. Bien vu, et bien calculé. Outre 100 007, les nombres 3 007, 7 000 005
et 50 000 008 sont les seuls pour lesquels le changement de deux chiffres
*dans le même sens* est une erreur indétectable. Et tu as bien calculé le
nombre de possibilités pour chaque.
>
Mais il ne faut pas oublier que l'on peut aussi *augmenter* un chiffre tout
en *diminuant* un autre chiffre. Cela veut dire qu'en plus de chercher les
multiples de 97 de la forme (d1 × 10^n + d2) il faut aussi considérer ceux
de la forme (d1 × 10^n - d2).

 
Et pourquoi ne pourrait-on pas diminuer les deux ? Ou, plus simplement,
faire les quatre possibilités ++, +-, -+ ou --.

On peut très bien le faire, ce qui te donnera exactement deux fois plus de
résultats puisque à chaque nombre que l'on peut augmenter correspond le
nombre que l'on peut diminuer. En choisissant le sens de modification
d'un des deux chiffres et en laissant libre le sens de l'autre chiffre
(donc ++ et +- mais pas -+ ni --) je compte les « paires de nombres
indiscernables » plutôt que les « nombres faisant partie d'une paire ».

[...]
 

Et les résultats non détaillés (juste le total) pour tous les nombres à
deux chiffres qui sont premiers avec 10 :
========================================
$ code_correcteur.py 10 99
[…]
Meilleur total : 2167 pour 93
========================================

 
Là je n’ai franchement pas les outils adéquats. Quoique réalisable, mais
long à mettre en place.

Mon programme python :
========================================================================
#!/usr/bin/env python3

import sys

def calcule_pour(modulo, verbose):
    somme = 0
    for n in range(2, 13):
        mul = 10 ** n
        # d1 est le premier chiffre, entre 1 et 9
        for d1 in range (1, 10):
            nombre = d1 * mul + 9
            resid = nombre % modulo
            if resid <= 18:
                nombre = nombre - resid
                # d2 est compris entre -9 et -1 ou entre 1 et 9
                d2 = 9 - resid
                positions = 13 - n
                if verbose:
                    print(f"{nombre} ←{positions}→ {d1:+d} {d2:+d}")
                # var1 et var2 sont les comptes de chiffres possibles
                # à la position de d1 et d2
                var1 = 10 - d1
                var2 = 10 - abs(d2)
                compte = positions * var1 * var2
                if verbose:
                    print(f" {positions}×{var1}×{var2} = {compte}")
                somme += compte
    print("Total pour", modulo, "=", somme)
    return somme

if len(sys.argv) == 2:
    modulo = int(sys.argv[1])
    calcule_pour(modulo, True)

if len(sys.argv) == 3:
    min = -1
    best = 0
    first = int(sys.argv[1])
    last = int(sys.argv[2])
    for modulo in range(first,last+1):
        if modulo % 2 != 0 and modulo % 5 != 0:
            somme = calcule_pour(modulo, False)
            if min < 0 or somme < min:
                min = somme
                best = modulo
    print("Meilleur total :", min, "pour", best)
========================================================================

--
Olivier Miakinen