Discussion :

[simokhobouz]

bounjour a tout svp je veux avoir une solution pour un algo de Armstrong

[valentin03]

Il d'y a pas d'algo d'Amstrong mais un nombre d'Amstrong
Pour l'obtenir, tu découpe la chaîne en caractères, tu en extrait les valeurs, tu élève les valeurs au cube et tu additionne.
C'est pas sorcier.
La question qui se pose, c'est: A quoi peut bien servir une manip pareille.

[wiwaxia]

A quoi peut bien servir une manip pareille.

À l'entraînement des malheureux débutants en programmation .

L'énoncé exact du problème consistant en la recherche des entiers égaux à la somme des puissances (c) des (c) chiffres qui les composent, en notation décimale.

Deux options pour leur recherche, par exemple pour (c = 3):
a) un balayage simple du domaine, suivi de la décomposition de l'entier considéré n = <ijk> = (100*i) + (10*j) + k

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
FOR n:= 100 TO 999 DO 
 ...

b) trois boucles imbriquées:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
FOR i:= 1 TO 9 DO
  FOR j:= 0 TO 9 DO
    FOR k:= 0 TO 9 DO ...

avec vérification de l'égalité: (100*i) + (10*j) + k = i³ + j³ + k³ .

Les solutions dépendent de la base de numération.
On rencontre beaucoup de variantes à cet énoncé; le travail mathématique consiste à borner les solutions, afin de ne pas se lancer dans des recherches inutiles.

Exemple: 145 = 1! + 4! + 5! . Trouver l'autre solution égale à la somme des factorielles de ses chiffres.

[valentin03]

@: wiwaxia: J'ai trouvé ça;
" est un entier naturel n non nul qui est égal à la somme des puissances p-ièmes de ses chiffres en base dix, où p désigne le nombre de chiffres de n"
Avec l'ambiguïté de n qui ici est en même temps le nombre cherché et engendre p.

[wiwaxia]

La seconde référence citée dans l'article de Wikipédia décrit les quatre sortes de nombres d'Armstrong; sous cet aspect la demande de simokhobouz est floue, faute d'indiquer ce qu'il recherche.
Il s'agit vraisemblablement du cas le plus simple, celui des nombres de quatrième espèce d'ordre (p), vérifiant: n = S_k=1^c(d_k)^p ,
où (d_k) représente le k^ème chiffre compté à partir de la droite: n = <d_cd_c-1 ... d₂d₁> = S_k=1^c(10^(k-1)*d_k) .

L'article disponible sur MathWorld fournit de nombreuses informations.

1°) Le problème étudié, ainsi que quelques variantes, relèvent du même algorithme, celui de la recherche d'un entier égal à la somme de (c) termes dépendant chacun du chiffre correspondant: n = S_k=1^cF(d_k) ;
la fonction entière en cause pouvant être:
# F(d) = d^p (nombres d'Armstrong de 4^me espèce),
# F(d) = d^d (nombres d'Armstrong de 2^nde espèce),
# F(d) = d! (fonction factorielle) ... liste non limitative.
Il est alors avantageux de calculer une fois pour toutes les 10 valeurs de la fonction, lors de l'initialisation d'une liste de 10 entiers; plusieurs codes sont envisageables, par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
VAR F: ARRAY[0..9] OF LongInt;    
 
FOR k:= 0 TO 9 DO F[k]:= Cube(k);

La valeur de la fonction est alors directement donnée par F[d].


2°) Le recours à (c) boucles imbriquées, dans le cas d'un petit nombre de chiffres, paraît le plus facile à mettre en oeuvre, en raison de la simplicité du passage de la séquence de chiffres à l'entier correspondant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
u:= d[c];
FOR k:= (c - 1) DOWNTO 1 DO BEGIN
                              v:= 10 * u; u:= v + d[k]
                            END;
n:= u;

Le passage inverse semble plus approprié à un nombre quelconque de chiffres:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
u:= n;
FOR k:= 1 TO c DO BEGIN
                    v:= u DIV 10; d[k]:= u MOD 10; u:= v
                  END;

Il faut comparer les délais d'exécution, et ne pas oublier que l'on se retrouvera face à un mur au-delà d'une dizaine de chiffres.

[wiwaxia]

Dernier détail, last but not least, l'équation n = S_k=1^cF(d_k), dans laquelle intervient la fonction croissante F(d), admet-elle des solutions entières à (c) chiffres dans la base considérée ?

L'entier (n) est borné par N_min = <1000...0> ("1", suivi de (c-1) zéros), soit N_min = 10^(c-1) ,
et N_max = <999...9> (c chiffres "9"), soit N_max = 10^c - 1 ;
la somme S = S_k=1^cF(d_k) par S_min = F(1) , inférieure aux deux limites précédentes dès que (c>1) ,
et S_max = F(9) * c , dont l'augmentation en fonction de (c) est beaucoup moins rapide que celle de N_max , qui comporte un terme exponentiel.

L'existence d'une solution vérifiant: n = S , donc soumise aux conditions: N_min <= n et S <= S_max , implique une intersection non vide pour des deux domaines [N_min ; N_max] , [S_min ; S_max] ,
et que l'on ait par conséquent: N_min <= S_max , soit: 10^(c-1) <= F(9) * c ou encore c <= lg(10*F(9)*c) .

Dans le cas des nombres d'Armstrong de 4^me espèce (F(d) = d^p) la limite de (c) est celle de la suite: u_k+1 = lg(10*(9^p)*u_k) ,
et l'on trouve pour quelques valeurs de (p):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 2   3.445 771
 3   4.517 639
 4   5.562 218

Ceux ceux de la seconde espèce (F(d) = d^d) correspondent à p = 9 (F(9) = 9⁹), d'où la limite:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 9   10.614 064

Les nombres d'Armstrong de première espèce (F(d) = d^c) conduisent à l'inéquation: 10^c <= 10*9^c*c , d'où: c <= Ln(10*c) / Ln(10/9) et c <= 60.847 858 .

Si vous trouvez les dernières solutions en moins de deux heures, je serais intéressé par la marque de votre PC.
Je vous refile un tuyau : les plus grands entiers ne comportent que 39 chiffres, et ne diffèrent que de (1):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
     115132219018763992565095597973971522400, 
     115132219018763992565095597973971522401

[simokhobouz]

merci a touts pour vous repense
j'ai trouver la solution ça marche bien
et voila le code source en langage C

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
#include<stdio.h>
#include<stdlib.h>
int main(){
	int s,i,j,k,n;
	for(i=0;i<=9;i++){
		for(j=0;j<=9;j++){
			for(k=0;k<=9;k++){ 
			n=100*i+10*j+k;
			s=i*i*i+k*k*k+j*j*j;
			if (s==n && n>=100){
				printf("%d\t",s);
				}		
			}
		}
	}
	return 0;
}

[tbc92]

Avec ce programme, tu recherches les nombres d'Armstrong entre 100 et 999. La question initiale parlait des nombres d'Armstrong en général.