Voilà un petit casse-tête posé par un gamin de 8 ans … la question qu'il m'a posé est :
«ça existe un nombre que quand tu bouges le dernier chiffre devant tu as le double ?»
La question semble simple : on cherche un nombre naturel N écrit en base 10 qui lorsqu'on déplace le chiffre des unités dans la position de plus fort poids on se retrouve avec le nombre 2×N.
Je vous partage ça car je me suis un peu creusé la tête dessus et au final c'est pas si évident que ça … rien que pour trouver le plus petit nombre qui vérifie la propriété (car il existe).
Edit: Pour donner un exemple, si on essaye de trouver un quadruple au lieu d'un double on peut trouver 205128. En effet si on déplace le chiffre des unités dans la position de plus fort poids on obtient 820512 et on peut remarquer que 820512 = 205128 × 4.
Après avoir essayé de mettre ça en équation, j'ai vite laissé tomber. J'ai décidé d'en faire un exercice de programmation. J'ai écrit un petit programme en C en m'efforçant d'être un minimum astucieux sur les calculs (ne pas calculer directement le nombre de chiffres, c'est trop long).
Le programme :
/* dbl.c : cherche les nombres qui ont la propriété suivante :
* --> Lorsqu'on place le chiffre de droite tout à gauche
* le nombre obtenu est le n-uple de l'original
* (n=2 : double, n=3 : triple, n=4 : quadruple, etc.)
*/
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
// Tableau des puissances de 10 (var. globale éviter les recopies)
int puiss10[] = {1, 10, 100,
1000, 10000, 100000,
1000000, 10000000, 100000000,
1000000000} ;
int permute(int n, int nch)
// Retourne p(n) = nombre obtenu à partir de n en plaçant le chiffre
// de droite tout à gauche. Exemple : 205128 --> 820512.
// Le nombre n comporte nch chiffres.
{
int cd = n % 10 ; // chiffre de droite)
return cd * puiss10[nch - 1] + (n - cd) / 10 ; // je crois que n / 10 suffit
}
int saisir_int(char prompt[], int a, int b)
// Saisie d'un entier entre a et b
{
int valeur ;
while(true)
{
printf("%s", prompt) ;
scanf("%d", &valeur) ;
if ((valeur >= a) && (valeur <= b))
return valeur ;
printf("%d est invalide\n", valeur) ; // pour bien faire il manque
} // le vidage du tampon
}
int main(void)
{
printf("Recherche des nombres k entre 10 et L tels que p(k) = n × k,\n");
printf("où p est la fonction qui place à gauche le chiffre de droite.\n");
int n = saisir_int("Facteur n = ", 1, 9);
int lim = saisir_int("Limite L = ", 10, 1000000000);
int nbrchiffres = 2 ; // nombre de chiffres de k
int puiss10suiv = 100 ; // puissance de 10 qui suit k
for (int k = 10 ; k <= lim ; k++)
{
if (k % puiss10suiv == 0) // on a un chiffre de plus
{
nbrchiffres ++ ;
puiss10suiv *= 10 ;
}
int pk = permute(k, nbrchiffres) ;
if (pk == n * k)
printf(" %d × %d = %d\n", k, n, pk) ;
}
} // oups, j'ai oublié de retourner EXIT_SUCCESS
Pour ×2 le plus petit nombre est suffisamment grand pour ne pas pouvoir être trouvé par brute force … mais il existe. Il faut effectivement passer par une équation.
Quant au ×5, ce n'est pas une «coïncidence» pour te mettre sur la piste on a le «chiffre qui bouge» qui vaut 7 et 7× la partie immobile qui vaut 7×14285=99995=10⁵-5 ce qu'on pourrait lire comme «10 exposant le nombre de chiffres de la partie immobile - le multiplicateur» … Tu trouves ainsi une famille de solutions en concaténant plusieurs copies de la plus petite solution : {14285, 1428514285, 142851428514285, …} mais il y en a d'autres comme 183673469387755102040816326530612244897959 ×5 = 918367346938775510204081632653061224489795.
Celle pour ×2 est plus courte que le dernier exemple ^_^
Encore un peu de force brute ... Il ffaut que 10^k - 2 soit un multiple de 19? Le langage C ne permet pas une bonne précision. Allons y en Python: - for k in range(100): if (10**k-2) % 19 == 0: print(k) - et on trouve: - 17 35 53 71 89 - 10^17 ça n'est pas tout à fait un petit nombre. Au moins 56 bits en binaire.
On ajoute 18 à chaque exposant pour passer au suivant.
edit: # Je fais le test avec k=17 # Puisque b est un chiffre, on a 0 <= b <= 9 # Mais avec b==0, on aura Ab==0, donc pas intéressant. for b in range(1, 9+1): A = b*(10**17 - 2) // 19 if b*10**17+A == 20*A+2*b: print(A,b,sep='') - 52631578947368421 105263157894736842 157894736842105263 210526315789473684 263157894736842105 315789473684210526 368421052631578947 421052631578947368 473684210526315789
edit2: Pour géénéraliser le raisonnement de NoelAntin, on pourrait avoir bA = 2Ab, bA = 3Ab, bA = 4Ab, bA = 5Ab, ..., bA = nAb
Pour n = 2, on aura b(10^k-2) = 19A il faudra k = 17, 35, 53, 71, 89, 107, 125, 143, 161, 179, etc. Pour n = 3, on aura b(10^k-3) = 29A il faudra k = 27, 55, 83, 111, 139, 167, 195, 223, 251, 279, etc. Pour n = 4, on aura b(10^k-4) = 39A il faudra k = 5, 11, 17, 23, 29, 35, 41, 47, 53, 59, etc. Pour n = 5, on aura b(10^k-5) = 49A il faudra k = 41, 83, 125, 167, 209, 251, 293, 335, 377, 419, etc. Pour n = 6, on aura b(10^k-6) = 59A il faudra k = 57, 115, 173, 231, 289, 347, 405, 463, 521, 579, etc.
On motera que pour 5 par exemple, on obtient des solutions pour des valeurs relattibement petites. C'est que 49 n'est pas premier et si b vaut 7, A pourra être plus petit. Pour 4, on obtient déjà des solutions pour des nombres assez petits et 39 n'est pas premier non plus. Le cas de n = 6 semble le pire cas de ce que j'ai calculé.
edit3:
il faut en plus que n*(Ab) ne change pas d'ordre de grandeur. Si on est avec 5 chiffres, il faut rester avec 5 chiffres. Je n'ai pas considéré ce cas ...
- Edité par PierrotLeFou 15 octobre 2021 à 8:48:50
Le Tout est souvent plus grand que la somme de ses parties.
Pas mal, le raisonnement est là. Mais il est à noter, Pierrot, que 52631578947368421 n'est pas une solution car 52631578947368421 x 2 = 105263157894736842 et non 15263157894736842. Dans le cas général, une solution doit avoir son dernier chiffre au moins égal au multiplicateur.
Les cas où b*10-1 n'est pas premier et admet pour diviseurs 3 ou 7 (car 2 ou 5 ne divisent pas b*10-1) pourra donner une famille de solutions plus «petites». Dans le cas de la base 10 cela est vérifié pour 39=3*13, 49=7*7, et 69=3*23.
On peut généraliser encore plus en essayant avec plus de bases.
Voilà donc un petit problème sympa qui nous amène loin des capacités d'un petit bonhomme de 8 ans (non, ce n'était pas Gauss mais juste un gosse).
Je m'en suis rendu compte à la fin, d'où mon edit3 ... La condition est nécessaire mais pas suffisante. Il faudra que je trouve autre chose de plus. En Python ça se fait bien de tester si le nombre de chiffres est le même ...
Le Tout est souvent plus grand que la somme de ses parties.
Je suis toujours à la recherche d'une autre condition pour résoudre correctement le problème. En passant, si n=1 (1x), k vaudra 1, 2, 3, ... Par exemple pour k=2 il faut 2 chiffres identiques. En effet bb = 1*bb (22=1*22, 99=1*99) Avec n chiffres, il seront également identiques: 333=1*333, 666[6]=1*[6]666 En Python, on peut tester facilement ce que ça donne en ramenant le dernier chiffre au début. Je teste avec n=4 et k=5: - 102564 128205 153846 179487 205128 230769 - Les petits chiffres pour le dernier n'apparaissent pas (1, 2, 3) Si b*(10**k-n) == (10*n-1)*A bA aura k+1 chiffres, et ce doit être la même chose pour Ab A aura k chiffres, donc A < 10**k mais si on doit multiplier Ab par n, il faut presque A < 10**k / n
Le Tout est souvent plus grand que la somme de ses parties.
Merci pour les idées. En effet, pour que bA soit pair, il faut que A soit pair. Si on a bA = 4Ab, il faut que les 2 derniers chiffres de A soient divisibles par 4 Si bA = 3Ab, il faut que la somme des chiffres soit un multiple de 3. Même chose pour 9. si bA = 5Ab, il faut que le dernier chiffre de A soit 0 ou 5 Moins évident dans le cas général.
Le Tout est souvent plus grand que la somme de ses parties.
[énigme] Tu bouges ça double !
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.