Il est absolument nécessaire que les
programmes tournent: aucun étudiant ne
peut passer dans le semestre supérieur s'il n'a pas réalisé au moins un
programme qui tourne !
Exercice 1 Développer un algorithme pour trouver tous les nombres d'Armstrong. Le traduire en Java via un schéma-bloc approprié.
Corrigé
partiel 1 Algorithme de
calcul des nombres narcissiques d’ordre n (n= 3 ó Nb. d’Armstrong)
Schéma-bloc proposé pour la classe ‘NbArmstrong’
|
NbArmstrong
|
|
// Pas d’attributs (i.e. donnée-membres) ici ! |
|
// Constructeur : Pas de constructeurs explicités ici ! // Pas de fonctions d’accès ni de procédures modificatrices ! // Autres méthodes : + PROCEDURE calculArmstrong( ) //de classe ó‘static’ en Java + PROC. principale(
args : TABLEAU de CHAINE de
CARACTERES) // ó
‘main’ procédure
(‘void’) de classe (‘static’) et publique (‘public’) _________________________________________________ |
Définition des nombres narcissiques :
Ce sont des entiers naturels N à n digits qui vérifient, lors la décomposition en base 10, la relation du type:
N = … + m*1000
+ c*100+ d*10 + u = … + m^n +
c^n + d^n + u^n;
avec N pris dans l’intervalle [0, … , 10^n -1]. Ici, u indique les unités, d les dizaines, c les centaines et m le digit des milliers, etc …
N est un nombre narcissique d’ordre 1 <=> u = u^1 pour N compris entre 0 et 9;
N est un nombre narcissique d’ordre 2 <=> d*10 + u = d^2 + u^2 pour N compris entre 0 et 99;
N est un nombre d’Armstrong <=> c*100+ d*10 +
u = c^3+d^3+u^3 pour N compris entre 0 et 999;
N est un nombre narcissique d’ordre 4 <=> m*1000+c*100+d*10+u = m^4+c^4+d^4+u^4 avec N entre 0 et 9999;
et ainsi de suite ... [A COMPLETER !]
Question 1 : Quels sont les nombres narcissiques d’ordre 1 ? Réponses= {0, 1, . . . . . . . . . . . . . . . .. }
Question 2 : Et les deux nombres narcissiques triviaux d’ordre 2 ? Réponses = 0 et . . .
Question 3 : Donner deux nombres d’Armstrong triviaux (ó narcissiques d’ordre 3) ? Réponses= . . . et 1
Algorithme : A compléter les points de suspension ci-dessous pour calculer tous les nombres d’Armstrong.
+ PROCEDURE NbArmstrong :: calculArmstrong(
) {
c, d, u, N, n : ENTIER // ó int c, d, u, N, n; en Java
n <- 3 // ‘n’ = 3 ordre des nombres narcissiques ó Nb. d’Armstrong ici !
POUR N DE (10^n – 1) A 0 FAIRE // [par pas de -1]
//ó for( N = (int) Math.pow(10, n) – 1; N > -1;
N--) {
c <-- N DIV . . . // c : digit des centaines
d <-- (N MOD . . . ) DIV . . . // d : digit des dizaines
u <-- N MOD . . . // u : digit des unités
SI (N = c^n + d^n + u^n) ALORS // ‘c^n’ ó (int) Math.pow(c, n) en Java
// ó if ( N = =
(int) Math.pow(c, n) + (int) Math.pow(d, n) + (int) Math.pow(u, n) ) {
ECRIRE( « %d est un nombre d’ Armstrong ! », N)
// ó System.out.printf(« %d est un nombre d’ Armstrong ! », N) ;
FSI
FPOUR
}
// ‘pow’ est une fonction de classe (‘static’) : son appel est précédé par le nom de sa classe, ici ‘Math’ ;
// ‘Math.’ peut être omis
si, au tout début du fichier Java, on
inclue la ligne (cf. JDK 1.5 et plus) :
//
import static java.lang.Math.* ; /*
cf. Lexique
L.A.O. – Java */
Rappel :
DIV est l’opérateur de la division entière. A distinguer de l’opérateur “ / ” qui est aussi une division entre deux réels en Java.
MOD est l’opérateur donnant le reste de la division ‘DIV’ entre deux entiers (‘%’ en Java).
Exemples : 19 DIV 2 = = 9 ; 19 MOD 2 = = 1 (car 19 est impair. A vérifier avec la calculatrice de Windows en affichage scrientifique !)
Variantes de l’algorithme
ci-dessus (optionnel) :
(i) Proposer un autre algorithme pour trouver les nombres d’Armstrong par ordre croissant,
Indication : il suffit de modifier les bornes de ‘POUR … FPOUR’ par :
POUR N DE 0 A (10^n – 1) FAIRE // [par pas = +1]
//ó
for( N =
0; N < (int) Math.pow(10, n); ++N)
{
(ii ) Proposer un algorithme pour la généralisation à l’ordre ‘n’ des nombres narcissiques ( N variant de 0 à Nmax inclus) en utilisant un tableau unidimensionnel pour les coefficients de la décomposition (optionnel).
Le traduire en Java. Que vaut le nombre maximal ‘nMax’ de digits décimaux concernant le type ‘long’ en Java ?
Même question pour les autres types primitifs Java : ‘int’, ‘short’ et ‘byte’. On fournit le tableau comparatif ci-dessous :
Type ‘ENTIER’| t
: occupation | Nmax = 2^(t-1) –
1 | nMax
---------------------------------------------------------------------------------
‘byte’ | 8 bits
| Byte.MAX_VALUE = 127 | 2
‘short’ | 16
bits | Short.MAX_VALUE = 32767 |
4
‘int’ | 32 bits |
Integer.MAX_VALUE = ......... | ..
‘long’ | 64 bits |
Long.MAX_VALUE = ..................| ..
Exercice
2 Mêmes questions pour les nombres parfaits (égaux à la somme de leurs
diviseurs).
Exercice 3 (non corrigé) Mêmes questions pour la suite de Fibonacci (cf. internet pour la définition et les calculs exacts et approchés pour n tendant vers l’infini cf. TypeEntier.MAX_VALUE en Java ci-dessus …).
Autres exercices (cf. énoncé sur ‘arche’- A terminer ...)