Particularités numériques (constantes de Kaprekar)

Particularités numériques (constantes de Kaprekar)

Nous allons parler dans cet article, inspiré de la vidéo suivante, des constantes de Kaprekar et aller un peu plus loin.

constantes de Kaprekar
Kaprekar

Le problème mathématique sur un nombre à 3 chiffres pour obtenir une des constantes de Kaprekar 495

Exposé théorique

Étant donné un nombre entier \(n\) à 3 chiffres non tous identiques, noté \(\overline{x_1x_2x_3}\), on considère les fonctions:$$b(n)=\overline{x_ix_jx_k},~\text{avec }x_i \geqslant x_j \geqslant x_k$$et:$$s(n)=\overline{x_mx_nx_p},~\text{avec }x_m \leqslant x_n \leqslant x_p.$$On note ensuite:$$d(n)=b(n)-s(n).$$Alors, il existe un entier r>0 tel que pour tout entier \(q \geqslant r\), \(d^q(n)=495\), en prenant pour convention que:$$d^q(n) = \underbrace{(d \circ d \circ \cdots \circ d)}_{q\text{ fois}}(n).$$

Un exemple

Prenons:$$n=847$$. Alors,$$b(n)=874$$et$$s(n)=478$$. Ici, on forme le plus grand entier possible avec les chiffres de n (c’est b(n) – b pour “biggest”) et le plus petit nombre possible avec ces mêmes chiffres (c’est s(n) – s pour “smallest”).

Ensuite, on calcule la différence:$$d(n)=874-478=396.$$On applique alors à 396 la fonction d à nouveau. On trouve:$$d(396)=963-369=594,$$ puis on applique à nouveau d à 594:$$d(594)=954-459=495.$$Si on applique à nouveau d à 495, on trouve:$$d(495)=954-459=495.$$

Ainsi, pour tout entier \(q \geqslant 3\),$$d^q(847)=495.$$

Le problème mathématique sur un nombre à 4 chiffres pour obtenir une des constantes de Kaprekar 6174

Si on fait la même chose sur un nombre à quatre chiffres, on constate qu’il existe un entier r à partir duquel \(d^q(n)=6174\).

Par exemple, si on prend:$$n=4521$$on a:$$d(n)=5421-1245=4176$$et$$d^2(n)=7641-1467=6174.$$On peut voir aussi que \(d(6174)=6174\) donc inutile d’aller plus loin.

Un programme Python

Comme je suis une grosse feignasse, je n’aime pas faire de calculs répétitifs donc je préfère écrire un programme qui fait ça pour moi…

def d(n):
    L = list( str(n) )
    L.sort()
    smallest = ''.join(L)
    L.reverse()
    biggest = ''.join( L )
    return int(smallest) , int(biggest) , int(biggest)-int(smallest)

n = int( input("Entrez un nombre entier : ") )
ant = 0

while d(ant) != d(n):
    print('{} --> {} , {} --> différence = {}'.format(n , d(n)[0] , d(n)[1] , d(n)[2]))
    ant = n
    n = d(ant)[2]

Ce n’est sans doute pas un programme optimal, mais… après tout, je suis en vacances ! Et il fait le job…

L’idée est de voir les différents résultats de \(d^q(n)\), et ça fonctionne bien. Bien sûr, en l’état, si vous entrez un entier à plus de 4 chiffres, ça ne fa pas fonctionner…

Le problème mathématique sur un nombre à 5 chiffres et plus : constantes de Kaprekar ?

Constat mathématique

Si on prend un nombre à 5 chiffres, on s’aperçoit que les choses changent. À l’aide du programme précédent, on le stoppant manuellement, on s’aperçoit qu’il y a un cycle.

Par exemple, si on prend:$$n=12345$$cela donne:

12345 --> 12345 , 54321 --> différence = 41976
41976 --> 14679 , 97641 --> différence = 82962 <====
82962 --> 22689 , 98622 --> différence = 75933
75933 --> 33579 , 97533 --> différence = 63954
63954 --> 34569 , 96543 --> différence = 61974
61974 --> 14679 , 97641 --> différence = 82962 <==== cycle

En prenant:$$n=28018$$on a:

28018 --> 1288 , 88210 --> différence = 86922
86922 --> 22689 , 98622 --> différence = 75933 <===
75933 --> 33579 , 97533 --> différence = 63954
63954 --> 34569 , 96543 --> différence = 61974
61974 --> 14679 , 97641 --> différence = 82962
82962 --> 22689 , 98622 --> différence = 75933 <=== cycle

En prenant:$$n=98174$$on a:

98174 --> 14789 , 98741 --> différence = 83952 <===
83952 --> 23589 , 98532 --> différence = 74943
74943 --> 34479 , 97443 --> différence = 62964
62964 --> 24669 , 96642 --> différence = 71973
71973 --> 13779 , 97731 --> différence = 83952 <=== cycle

Bon, on ne va pas tous les faire mais bon… allez ! Un dernier et j’arrête: pour$$n=10101$$on a:

10101 --> 111 , 11100 --> différence = 10989
10989 --> 1899 , 99810 --> différence = 97911
97911 --> 11799 , 99711 --> différence = 87912
87912 --> 12789 , 98721 --> différence = 85932
85932 --> 23589 , 98532 --> différence = 74943 <===
74943 --> 34479 , 97443 --> différence = 62964
62964 --> 24669 , 96642 --> différence = 71973
71973 --> 13779 , 97731 --> différence = 83952
83952 --> 23589 , 98532 --> différence = 74943 <=== cycle

Modification du programme Python

Plutôt que de d’interrompre manuellement le programme, autant le modifier pour qu’il s’arrête de lui-même quand une boucle est détectée:

def d(n):
    L = list( str(n) )
    L.sort()
    smallest = ''.join(L)
    L.reverse()
    biggest = ''.join( L )
    return int(smallest) , int(biggest) , int(biggest)-int(smallest)

n = int( input("Entrez un nombre entier : ") )
ant = 0
N = [ n ]
add = False

while not add:
    print('{} --> {} , {} --> différence = {}'.format(n , d(n)[0] , d(n)[1] , d(n)[2]))
    n = d(n)[2]
    if n not in N:
        N += [ n ]
    else:
        add = True

Ainsi, en entrant:$$n=78545$$on a:

78545 --> 45578 , 87554 --> différence = 41976
41976 --> 14679 , 97641 --> différence = 82962
82962 --> 22689 , 98622 --> différence = 75933
75933 --> 33579 , 97533 --> différence = 63954
63954 --> 34569 , 96543 --> différence = 61974
61974 --> 14679 , 97641 --> différence = 82962

Pour \(n=55155\), on a:

55155 --> 15555 , 55551 --> différence = 39996
39996 --> 36999 , 99963 --> différence = 62964
62964 --> 24669 , 96642 --> différence = 71973
71973 --> 13779 , 97731 --> différence = 83952
83952 --> 23589 , 98532 --> différence = 74943
74943 --> 34479 , 97443 --> différence = 62964

(ah zut ! j’avais promis d’arrêter…)

Ce qu’il y a de bien avec ce programme est que l’on peut entrer un nombre entier quelconque, ça fonctionne!

Pour en savoir un peu plus, vous pouvez regarder par exemple la page https://www.dcode.fr/algorithme-kaprekar

Stéphane Pasquet
Stéphane Pasquet

Laissez votre message

Supportscreen tag