CPI - 1ère Année - Année Universitaire 2014/2015 - (Semestre 1)

EMD1 d’ALGORITHMIQUE

Date : Mardi 25 Novembre 2014

Durée : 3 Heures
DOCUMENTS INTERDITS

Il y a des nombres très surprenants. Prenez par exemple le nombre (entier positif > 9) N = 197. Si
vous considérez ses x chiffres comme les premiers éléments d’une suite : 1 , 9 , 7 , et si ensuite chaque
élément est égal à la somme des x éléments précédents, il arrive de retomber sur le nombre de départ :
Par exemple si N = 197, on obtient la suite 1 , 9 , 7 , 17, 33, 57 , 107 , 197
197 est appelé un nombre de KEITH alors que 198 n’est pas un nombre de KEITH. En effet, pour 198 on
aura la suite suivante : 1 , 9 , 8 , 18 , 35, 61 , 114 , 210
C’est Michael KEITH qui a défini ces nombres en 1987. Ces nombres de KEITH sont aussi appelés les
Repfigits , (mot obtenu à partir de la contraction des mots repetitive Fibonacci-like digit).

Travail à Faire :
 On vous demande de retrouver tous les nombres de KEITH composés de 2, 3 et 4 chiffres et de les
afficher sous la forme suivante :

(Extrait du résultat)

Nota : on considère les fonctions suivantes déjà construites :

Fonction EXTR_NB( n : entier ; c, p : entier) : entier

// Rôle : extrait de N un nombre de C chiffres à partir de la position P (incluse)
// les positions sont numérotées de droite à gauche
//------------------------------------------------------------------------------------

Fonction NB_POS (n : entier ) : entier

// Rôle : Donne le nombre de chiffres composant N
//------------------------------------------------------------------
Barème: Découpage et sa justification (3 pts) , recherche des nombres de KEITH (7pts) , affichage selon le
format donné (6pts), programmation (4pts)

ATTENTION: Votre solution doit ABSOLUMENT :

 être basée sur la MODULARITE
 tenir compte du formalisme étudié en cours
 être soignée (tout travail non soigné ne pourra en aucun cas prétendre à la note max.
prévue dans le barème !
Alors soignez votre travail et bon courage !

(EMD1_CPI_2014_2015.doc – CHERGOU - MEDJAOUI)

 CORRIGE
NOTE IMPORTANTE : ceci est un corrigé type, toute autre solution cohérente est recevable.

Nota : nous avons limité exprès la taille de N à 2,3 ou 4 chiffres pour 2 raisons. La première est qu’il nous faut travailler avec des
objets élémentaires (nous n’avons pas encore fait des Exos sur les données structurées), la seconde est pour éviter des algorithmes
trop longs. Car une fois que l’on aura compris comment ça marche pour des nombres de 2 ou 3 chiffres, il est très facile de
généraliser ( sans dépasser les limites des entiers longs bien entendu).

1. Découpage modulaire :
On aura besoin d’un module qui vérifie si un nombre est un nombre de Keith ou pas et d’un module qui nous affiche
les suites des nombres selon le format donné, que ce nombre soit de Keith ou pas (on pourra ainsi l’utiliser dans
d’autres cas). Par la suite comme il est demandé de n’afficher que les suites correspondant aux nombres de Keith,
nous devons d’abord vérifier si notre nombre est un nombre de Keith et si c’est le cas on affiche la suite lui
correspondant. Cet affichage peut être intégré dans l’algorithme principal, mais nous proposons un module pour rendre
notre algorithme principal très simple à construire.
Par ailleurs il faut extraire les différents chiffres du nombre de départ et connaître le nombre de positions d’un nombre
(ces 2 modules sont donnés dans le sujet).

Fonction

N : entier Keith entier

Rôle : donne vrai si N (composé de 2,3 ou 4 chiffres) est un nombre de Keith

Procédure

N : entier AfSuiteN

Rôle :affiche une suite dont chaque élément est égal aux x éléments qui le précèdent (x =2,3,ou 4
selon que N contient 2,3 ou 4 positions – la suite s’arrête lorsqu’un élément est > N)

1. Construction de l’algorithme principal

Analyse :
Puisque notre nombre est composé de 2, 3 ou 4 chiffres, il suffit de
 Faire varier x de 10 à 9999 et à chaque fois
o Si X est un nombre de Keith , on affiche la suite lui correspondant

Algorithme emd1
Variable x : Entier
Fonctions Keith et afSuiteN

DEBUT
Ecrire ('Les nombres de Keith composes de 2, 3 et 4 chiffres sont : ')
Pour X allant de 10 à 9999 Faire
Si keith (x) Alors
afSuiteN (x)
FIN

2. Construction du module Keith

Nota : un indice dans l’énoncé nous oriente vers les suites de Fibonacci. Nous allons donc nous en inspirer pour notre
analyse.
Analyse :
Il faut d’abord décomposer N en ses x différents chiffres. Lesquels vont constituer les premiers éléments de la suite.
Ensuite chaque élément est = somme des x derniers éléments. Donc :
  si N est composé de 2 chiffres :
o On extrait le 1er chiffre C1 qui devient le 1er élément de la suite
o On extrait le 2ième chiffre C2 qui devient le 2ième élément de la suite
o On répète ce qui suit :
 Le prochain élément ELEM = C1 + C2
 On met C2 dans C1 // C2 devient le 1er élément
 On met ELEM dans C2 // ELEM devient le 2ième élément
On s’arrête lorsque (ELEM = N) OU (ELEM > N) // c’est un nombre de Keith ou non
o Si ELEM = N donc N est un nombre de Keith
 Si N est composé de 3 chiffres :
On refait la même chose que précédemment mais on aura besoin des 3 premiers éléments C1,C2 et C3
 Si N est composé de 4 chiffres :
On refait la même chose que précédemment mais on aura besoin des 4 premiers éléments C1,C2,C3 ,C4

Nota : on observe que pour généraliser, on peut aller jusqu’à N composé de 9 chiffres. Mais si l’analyse est facile ,
l’algorithme est un peu long. Une solution plus élégante est possible avec les tableaux.

Fonction Keith ( n : Entier ) : booléen

Variables c1,c2,c3,c4,c5,c6,c7,c8,c9,elem : Entier
Fonctions extr_Nb et Nb_pos

DEBUT
Si Nb_Pos(N) = 2 Alors
Dsi
c1  extr_Nb(N,1,1)
c2  extr_Nb(N,1,2)
Répéter
Elem  c1+c2
c1  c2
c2  elem
Jusqu’à (n = elem) OU (elem > n)
Fsi
Sinon
Si Nb_Pos(N) = 3 Alors
DSI
c1  extr_Nb(N,1,1)
c2  extr_Nb(N,1,2)
c3  extr_Nb(N,1,3)
Répéter
Elem  c1+c2+c3
c1  c2
c2  c3
c3  elem
Jusqu’à (n = elem) OU (elem > n)
FSI
Sinon
Si Nb_Pos(N) = 4 Alors
DSi
c1  extr_Nb(N,1,1)
c2  extr_Nb(N,1,2)
c3  extr_Nb(N,1,3)
c4  extr_Nb(N,1,4)
Répéter
Elem  c1+c2+c3+c4
c1  c2
c2  c3
c3  c4
c4  elem
Jusqu’à (n = elem) OU (elem > n)
Fsi
Si elem = n Alors Keith  Vrai
Sinon Keith  Faux
FIN
 3. Construction de AfSuiteN

Nota : cette partie du problème aurait pu être traitée dans l’algorithme principal, mais nous avons privilégié de la
modulariser , car elle est extraite en très grande partie du module Keith mais de plus notre algorithme principal sera
énormément simplifié et de plus le module pourra être réutilisé.

Analyse :
Dans notre analyse nous allons reprendre la même analyse que celle du module de Keith, en y insérant seulement des
écritures pour afficher les premiers éléments de la suite , et lorsque l’on calcule un élément. On affiche donc les
éléments d’une suite que N soit un nombre de Keith ou pas. Donc
 si N est composé de 2 chiffres :
o On extrait le 1er chiffre C1 qui devient le 1er élément de la suite
o On extrait le 2ième chiffre C2 qui devient le 2ième élément de la suite
o On écrit C1 et C2
o On répète ce qui suit :
 Le prochain élément ELEM = C1 + C2
 On écrit Elem
 On met C2 dans C1 // C2 devient le 1er élément
 On met ELEM dans C2 // ELEM devient le 2ième élément
On s’arrête lorsque (ELEM = N) OU (ELEM > N) // c’est un nombre de Keith ou non
 Si N est composé de 3 chiffres :
On refait la même chose que précédemment mais on aura besoin des 3 premiers éléments C1,C2 et C3
 Si N est composé de 4 chiffres :
On refait la même chose que précédemment mais on aura besoin des 4 premiers éléments C1,C2,C3 ,C4
 Procédure Keith ( n : Entier ) : booléen
Variables c1,c2,c3,c4,c5,c6,c7,c8,c9,elem : Entier
Fonctions extr_Nb et Nb_pos

DEBUT
Si Nb_Pos(N) = 2 Alors
Dsi
c1  extr_Nb(N,1,1)
c2  extr_Nb(N,1,2)
écrire (C1, C2)
Répéter
Elem  c1+c2
Ecrire (elem)
c1  c2
c2  elem
Jusqu’à (n = elem) OU (elem > n)
Fsi
Sinon
Si Nb_Pos(N) = 3 Alors
DSI
c1  extr_Nb(N,1,1)
c2  extr_Nb(N,1,2)
c3  extr_Nb(N,1,3)
écrire (C1, C2, C3)
Répéter
Elem  c1+c2+c3
Ecrire (elem)
c1  c2
c2  c3
c3  elem
Jusqu’à (n = elem) OU (elem > n)
FSI
Sinon
Si Nb_Pos(N) = 4 Alors
DSi
c1  extr_Nb(N,1,1)
c2  extr_Nb(N,1,2)
c3  extr_Nb(N,1,3)
c4  extr_Nb(N,1,4)
écrire (C1, C2, C3,C4)
Répéter
Elem  c1+c2+c3+c4
Ecrire (elem)
c1  c2
c2  c3
c3  c4
c4  elem
Jusqu’à (n = elem) OU (elem > n)
Fsi
FIN

Essayez de trouver une solution avec les tableaux !

PROGRAMMES
********************************************************************************
Program emd11415;
Uses crt;
var x:longint;
{$i E:\ALGO\MODULES\Keith.fon}
{$i E:\ALGO\MODULES\afSuiteN.fon}
BEGIN
Clrscr;
Writeln('Les nombres de Keith composes de 2, 3 et 4 chiffres sont : ');
for x:= 10 to 9999 do
if keith(x) then
afSuiteN(x);
readln;
END.
*******************************************************************************
Function Keith (n:longint):boolean;
// ---------------------------------------------------------------------
// donne vrai si N (compos‚ de 2,3 ou 4 chiffres) est un nombre de Keith
// ---------------------------------------------------------------------
var c1,c2,c3,c4,c5,c6,c7,c8,c9,elem :integer;
{$i E:\ALGO\MODULES\extr_Nb.fon}
{$i E:\ALGO\MODULES\Nb_pos.fon}
BEGIN
If Nb_Pos(N)=2 then
BEGIN
c1:=extr_Nb(N,1,1);
c2:=extr_Nb(N,1,2);
repeat
elem:=c1+c2;
c1:=c2;
c2:=elem;
until (n = elem) or (elem > n);
END
else
If Nb_Pos(N)=3 then
BEGIN
c1:=extr_Nb(N,1,1);
c2:=extr_Nb(N,1,2);
c3:=extr_Nb(N,1,3);
repeat
elem:=c1+c2+c3;
c1:=c2;
c2:=c3;
c3:=elem;
until (n = elem) or (elem > n);
END
else
If Nb_Pos(N)=4 then
BEGIN
c1:=extr_Nb(N,1,1);
c2:=extr_Nb(N,1,2);
c3:=extr_Nb(N,1,3);
c4:=extr_Nb(N,1,4);
repeat
elem:=c1+c2+c3+c4;
c1:=c2;
c2:=c3;
c3:=c4;
c4:=elem;
until (n = elem) or (elem > n);
END;
if elem =n then Keith := true
else Keith := False;
END;
Procedure AfSuiteN (n:longint);
// ---------------------------------------------------------------------
// affiche la suite du nombre de Keith N (compos‚ de 2,3 ou 4 chiffres)
// ---------------------------------------------------------------------

var c1,c2,c3,c4,c5,c6,c7,c8,c9,elem :integer;

{$i E:\ALGO\MODULES\extr_Nb.fon}
{$i E:\ALGO\MODULES\Nb_pos.fon}

BEGIN
write(N,' : ');
If Nb_Pos(N)=2 then
BEGIN
c1:=extr_Nb(N,1,1);
c2:=extr_Nb(N,1,2);
write(c1,',',c2,',');
repeat
elem:=c1+c2;
Write(elem,',');
c1:=c2;
c2:=elem;
until (n = elem) or (elem > n);
END
else
If Nb_Pos(N)=3 then
BEGIN
c1:=extr_Nb(N,1,1);
c2:=extr_Nb(N,1,2);
c3:=extr_Nb(N,1,3);
write(c1,',',c2,',',c3,',');
repeat
elem:=c1+c2+c3;
c1:=c2;
c2:=c3;
c3:=elem;
Write(elem,', ');
until (n = elem) or (elem > n);
END
else
If Nb_Pos(N)=4 then
BEGIN
c1:=extr_Nb(N,1,1);
c2:=extr_Nb(N,1,2);
c3:=extr_Nb(N,1,3);
c4:=extr_Nb(N,1,4);
write(c1,',',c2,',',c3,',',c4,',');
repeat
elem:=c1+c2+c3+c4;
c1:=c2;
c2:=c3;
c3:=c4;
c4:=elem;
Write(elem,',');
until (n = elem) or (elem > n);
END;
writeln;
END;
**************************************************************************************
BAREME
1. Ce corrigé est un corrigé type, toute autre solution sera retenue dans la mesure où elle est cohérente
et les concepts appliqués
2. La démarche doit être modulaire ( au moins pour vérifier si N est un nombre de Keith ) sinon la note
finale est divisée par 2) – exception faite éventuellement à la partie affichage
3. Tenir compte :
 de la Structuration des idées dans l’analyse, la clarté, la précision, la concision et le soin
4. tout travail non soigné ne pourra en aucun cas prétendre à la note max. prévue dans le barème !

Découpage et la solution doit comporter au moins la fonction Keih

justification  pas de Justification : 0 pt justification correcte : 1pt
3 pts  pour les modules les interfaces doivent être cohérents (1/2pt) et les
rôles clairs (1,5 pts)
Tout module qui ne peut être réutilisé en raison de son interface ou de
son rôle incohérent : 0pt
Recherche des nombres ANALYSE (3 pts)
de keith  décomposition du nombre initial : ½ pt
7 pts  calcul d’un élément : ½ pt
 test de fin de la boucle ( de la forme Répéter) : ½ pt
 détermination d’un nombre de Keith : ½ pt
 prise en charge des nombres de 2, 3 et 4 positions : 1 pt

ALGORITHME (4 pts)
 décomposition du nombre initial : ½ pt
 calcul d’un élément : ½ pt
 test de fin de la boucle ( de la forme Répéter) : ½ pt
 détermination d’un nombre de Keith : ½ pt
 prise en charge des nombres de 2, 3 et 4 positions : 1 pt
respect du formalisme : 1 pt ( être intransigeant sur le formalisme –
entête – déclarations – format des actions – indentation – blocs bien
apparents – encadrement – présentation) : sanctionner en fonction de
votre appréciation de la faute
Affichage selon le  les erreurs les plus classiques que j’entrevois sont :
format donné et 1. pas de module pour l’affichage : pas de sanction
algorithme principal 2. on affiche que le nombre de Keith (et pas la suite) : note max 1 pt
6 pts 3. on affiche toutes les suites (keith ou pas) : note max 3 pt
pour une solution correcte et (intelligente !) on doit retrouver, en
principe, la même analyse et le même algorithme que pour la recherche
d’un nombre de Keith.

De façon générale, on doit d’abord trouver :

 La boucle pour prendre les nombres de 2,3 et 4 chiffres 2 pts
(analyse 1pts, algorithme 1pt)
 déterminer d’abord qu’un nombre est un nombre de Keith et
ensuite l’afficher 2 pts
(analyse 1pts, algorithme 1pt)
 Insérer correctement les écritures 2 pts
(analyse 1pts, algorithme 1pt)
Programmation  Tout programme qui n’aura pas un lien direct avec le problème posé
4 pts et l’algorithme proposé ne sera pas pris en considération.
 Si la partie programmation contient moins de 10 instructions ou une
portion de programme : pas de correction -> 0/4
Ne corriger, au plus, qu’une seule page de programmation (~35
lignes) : - 0.25 pt par erreur de programmation ( 16 erreurs -> 0/4)