éNoncés+corrections bac2010

Année Scolaire : 2011-2012 4 SC

REPUBLIQUE TUNISIENNE
MINISTERE DE L’EDUCATION

EXAMEN DU BACCALAUREAT - SESSION DE JUIN 2010
SECTIONS: Mathématiques + Sciences Expérimentales + Sciences Techniques
EPREUVE : Pratique d’informatiques DUREE : 1 h COEFFICIENT : 0,5
DATE : 25 mai 2010 à 10 h

Important :
 Une solution modulaire au problème est exigée.
 Enregistrez au fur et à mesure votre programme dans le dossier Bac2010 se trouvant
sur la racine C: en lui donnant comme nom votre numéro d’inscription.

Ecrire un programme Pascal qui permet de déterminer si un entier donné n (n :?: 10) est
divisible par 7 ou non, en appliquant la méthode suivante :
1) supprimer le chiffre des unités de n
2) calculer la valeur absolue de la différence entre le nombre obtenu en 1) et le double
du chiffre d'unité supprimé
3) recommencer les étapes 1) et 2) jusqu'à obtenir un nombre à un seul chiffre
4) si ce chiffre obtenu en 3) est égal à 0 ou égal à 7 alors le nombre u est divisible par 7.

Grille d’évaluation
Nombre
Travail fourni
de points
 Décomposition en modules utiles à la solution proposée (déclarations et appels) 4
 Structures de données adéquates 2
 Saisie et contrôle des données 3
 Traitement avec les structures de contrôles adéquates 8
 Compilation 3

Lycée Attarine Ariana 2012



DATE : 25 mai 2010 à 10 h

Program P25Mai2010_10h;
uses wincrt;
Var
N:LongInt;
{**************************************}
Procedure SaisieDe_N(Var N : LongInt);
Begin
Repeat
Write('Saisir N: ');
Readln(N);
Until (10<=N);
End;
{**************************************}
Function DivisiblePar7(N:LongInt):Boolean;
Var
U,R:LongInt;
Begin
Repeat
U:=N MOD 10;
R:=N DIV 10;
N:= ABS(R - 2*U); {ABS Renvoi la valeur absolue d'un nombre}
Until (N<=9);

DivisiblePar7:= (N =7) OR (N=0);
{** ou encore...
DivisiblePar7:=N IN [0,7];
{** ou encore...
IF N IN [0,7] THEN
DivisiblePar7:=TRUE
ELSE DivisiblePar7:=FALSE;
{** ou encore...
IF (N =7) OR (N=0) THEN
DivisiblePar7:=TRUE
ELSE DivisiblePar7:=FALSE;}
End;
{**************************************}
Begin
SaisieDe_N(N);
IF DivisiblePar7(N) THEN
Write(N,' est divisible par 7')
ELSE Write(N,' n''est pas divisible par 7')
{** ou encore...
IF DivisiblePar7(N)=True THEN...}
End.




DATE : 25 mai 2010 à 8 h 30
mn
Important :
1. Une solution modulaire au problème est exigée.
2. Enregistrez au fur et à mesure votre programme dans le dossier Bac2010 se trouvant sur la racine C: en lui
donnant comme nom votre numéro d’inscription.

Pour vérifier si un entier positif K de n chiffres est un nombre de KAPREKAR ou non, on peut
suivre la méthode suivante :
1) élever K au carré
2) additionner l'entier formé par les n chiffres de droite du carré de K avec l'entier formé par le
reste des chiffres du carré de K
3) si la somme trouvée à l'étape 2) est égale à K alors le nombre est dit de KAPREKAR
Exemples:
● Si K= 9 alors n=1 et K2 = 81
L'entier formé par les n chiffres de droite est égal à 1 et 1'entier formé par le reste des
chiffres est égal à 8.
On constate que 1 + 8 = 9 = K, donc 9 est un nombre de KAPREKAR.
● Si K= 45 alors n =2 et K2 = 2025
L'entier formé par les n chiffres de droite est égal à 25 et l'entier formé par le reste des
On constate que 25 +20 = 45 = K, donc 45 est un nombre de KAPREKAR. .
● Si K=297 alors n = 3 et K2 = 88209
L'entier formé par les n chiffres de droite est égal à 209 et l'entier formé par le reste des
On constate que 209 + 88 = 297 = K, donc 297 est un nombre de KAPREKAR.
Travail demandé :
Ecrire un programme Pascal qui permet de déterminer tous les nombres de KAPREKAR
inférieurs ou égaux à 1000 en utilisant la méthode décrite ci-dessus.
Grille d’évaluation
Nombre
Travail fourni
de points
 Décomposition en modules utiles à la solution proposée (déclarations et appels) 4
 Structures de données adéquates 2
 Saisie et contrôle des données 3
 Traitement avec les structures de contrôles adéquates 8
 Compilation 3



Program P25Mai2010_8h_Version1;
uses wincrt;
{** Fonction qui vérifie si un entier***}
{** est de KAPREKAR ou non ***}
Function Kaprekar(K:LongInt):Boolean;
Var
ChK:String;
ChK_Carre:String;
n:Integer;
K_Carre:LongInt;
Droite,Gauche:LongInt;
Ch_Droite,Ch_Gauche:String;
e:Integer;
Begin
{*** Conversion de k en chaîne ChK pour... }
STR(K,ChK);
{*** Déterminer n=nombre de chiffre de K}
n:=Length(ChK);
{*** Calcul du carré de K=K_Carre}
K_Carre:=SQR(K);
{*** Conversion K_Carre en chaine ChK_Carre}
STR(K_Carre,ChK_Carre);
{*** Extraction de la partie droite de ChK_Carre }
Ch_Droite:=Copy(ChK_Carre, Length(ChK_Carre)-n+1 , n);
{*** Extraction de la partie Gauche de ChK_Carre }
Ch_Gauche:=Copy(ChK_Carre, 1 , Length(ChK_Carre)-n);
{*** Conversion de la partie droite en Entier }
VAL(Ch_Droite, Droite, e);
{*** Conversion de la partie gauche en Entier }
VAL(Ch_Gauche, Gauche, e);
{*** Renvoi du résultat TRUE ou FALSE }
Kaprekar:= K=Droite+Gauche;
{ou encore: IF (K=Droite+Gauche) THEN Kaprekar:= TRUE
ELSE Kaprekar:=FALSE;}
End;
{** Procédure qui parcourt les nombres ***}
{** de 1 à 1000 et vérifie pour chaque nombre *}
{** s'il est de kaprekar ou non ***}
{** les nombres de kaprekar seront afficher ***}
Procedure AfficherLesNombresDeKaprekar;
Var
i:Integer;
Begin
FOR i:=1 TO 1000 DO
Begin
IF kaprekar(i) THEN Writeln(i);
End;
End;
Begin {********** Programme Principal **************}
AfficherLesNombresDeKaprekar;
End.



Program P25Mai2010_8h_Version2;
uses wincrt;
{*******************************************}
Function Kaprekar(K:LongInt; Diviseur:Integer):Boolean;
Var
K_Carre:LongInt;
Droite,Gauche:LongInt;
Begin
{*** Carré de K dans K_Carre ******}
K_Carre:=SQR(K);
{*** Extraction de la partie Droite ****}
Droite:=K_Carre MOD Diviseur;
{*** Extraction de la partie Gauche ****}
Gauche:=K_Carre DIV Diviseur;
{*** Renvoi du résultat ******}
Kaprekar:= K=Droite+Gauche;
End;
{*******************************************}
Procedure AfficherLesNombresDeKaprekar;
Var
i:Integer;
Begin
FOR i:=1 TO 1000 DO
Begin
Case i OF
1..9 : IF kaprekar(i,10) THEN Writeln(i);
10..99 : IF kaprekar(i,100) THEN Writeln(i);
100..999: IF kaprekar(i,1000) THEN Writeln(i);
1000 : IF kaprekar(i,10000) THEN Writeln(i);
End;
End;
End;

{********** Programme Principal **************}
Begin
AfficherLesNombresDeKaprekar;
End.



Program P25Mai2010_15h_30mn;
uses wincrt;
Var
Ch:String;
{* Fonction qui vérifie si une chaîne
est composée seulement de lettres majuscules*}
Function Verif(Ch:String):Boolean;
Var i:Integer;
Begin
Repeat
i:=i+1;
Until (i=Length(Ch)) OR NOT (Ch[i] IN ['A'..'Z']);

Verif:= Ch[i] IN ['A'..'Z'];
{Ou encore...
IF Ch[i] IN ['A'..'Z'] THEN
Verif:=True
ELSE Verif:=False; }
End;
{**************************************}
Procedure SaisieDe_Ch(Var Ch : String);
Begin
Repeat
Write('Saisir une Chaîne: ');
Readln(Ch);
Until (Length(Ch)<>0) AND (Verif(Ch)=True);
End;
{**************************************}
Function Poids(Ch:String):Integer;
Var
i,P:Integer;
Begin
P:=0;
FOR i:=1 TO Length(Ch) Do
Begin
Case Ch[i] Of
'A' : P:=P+i*1;
'E' : P:=P+i*5;
'I' : P:=P+i*9;
'O' : P:=P+i*15;
'U' : P:=P+i*21;
'Y' : P:=P+i*25;
End;
End;
Poids:=P;
End;
{**************************************}
Begin
SaisieDe_Ch(Ch);
Write(Poids(Ch));
End.



Program P25Mai2010_15h_30mn;
uses wincrt;
{* === Fonction qui calcule la somme des puissances Kème des chiffres de X
--> X de 4 chiffres == *}
Function Puissance(X:LongInt;K:integer):LongInt;
Var U,D,C,M:Integer; {U:Unité, D:Dizaine, C:Centaine, M:Millier}
Begin
M:=X DIV 1000;
C:=X MOD 1000 DIV 100;
D:=X MOD 100 DIV 10;
U:=X MOD 10;

Case K OF {On peut aussi utiliser IF K=1 THEN...}
1 :Puissance:=M + C + D + U;
2 :Puissance:=M*M + C*C + D*D + U*U;
3 :Puissance:=M*M*M + C*C*C + D*D*D + U*U*U;
4 :Puissance:=M*M*M*M + C*C*C*C + D*D*D*D + U*U*U*U;
End;
End;
{* Fonction qui vérifie la relation décrite dans l'énoncé de l'examen*}
Function Verif(X:LongInt):Boolean;
Var
K:Integer;
Res:Longint;
Begin
K:=0;
Repeat
K:=K+1;
Res:=Puissance(X,K)
Until (Res=X) OR (K=5);

Verif:= Res=X; {Ou encore... IF Res=X THEN Verif:=True ELSE Verif:=False; }
End;
{**************************************}
Procedure Traitement;
Var i:Longint;
Begin
{On Parcourt tous les nombres à 4 chiffres}
FOR i:=1000 TO 9999 DO
IF Verif(i) =TRUE THEN Writeln(i);
End;
{**************************************}
Begin
Traitement;
End.



Program P26Mai2010_14h;
uses wincrt;
Type
Vecteur=Array[1..9] of Char;
Var
T:Vecteur;
N:Integer;
MOT:String;
{************************************************************}
Procedure Saisir_N(Var N:Integer);
Begin
Repeat
Write('N= ');
Readln(N);
Until (N>=5) AND (N<=9);
End;
{************************************************************}
Procedure RemplirLeTableau(Var T:Vecteur;N:Integer);
Var
i:Integer;
Begin
For i:=1 To N Do
Begin
Repeat
Write('T[',i,']= ');
Readln(T[i]);
Until (T[i] IN ['a'..'z']);
End;
End;
{****=== Fonction Qui Vérifie Si Une Ch est Composée ===*****}
{****=== Seulement De Lettres Alphabétiques Minuscules=******}
Function AlphaMinus(MOT:String):Boolean;
Var
i:integer;
Begin
i:=1;
While (MOT[i] in ['a'..'z']) AND (i<Length(MOT)) Do
Begin
i:=Succ(i); {ou i:=i+1}
End;
AlphaMinus:=MOT[i] in ['a'..'z'];
End;



{******=== Procedure De Saisie de Ch ===*******}
Procedure Saisir_MOT(Var MOT : String);
Begin
Repeat
Write('Saisir le Mot: ');
Readln(MOT);
Until (Length(MOT)IN [1..7]) AND (AlphaMinus(MOT));
End;
{******=== Procedure Traitement ===*******}
Procedure Traitement(T:Vecteur;N:integer;MOT:String);
Type
Position=Array['a'..'z'] of integer;
Var
Tp:Position; {Tp: Tableau indicé par des lettres minuscules
et qui contient les positions des lettres de T
pour les lettres apparaissants plus qu'une fois on maintient
la position de la première occurrence : regardez le 3ème
exemple de l'examen, pour le mot pascal la lettre 'a'
apparait 2 fois dans le mot et 2 fois dans le tableau (pos 2 et pos
8) mais dans le résultat, le prog affiche la pos 2 pour les 2 'a'}
i:integer;
j:Char; {compteur du tableau Tp}
Temp,Res:String;
Begin
{initialisation ds cases de Tp par des 0}
For j:='a' to 'z' do Tp[j]:=0;
{Remplissage de Tp par les positions des lettres de T}
For i:=1 to N Do
Begin
IF Tp[T[i]]=0 THEN {vérif si la case n'est pas encore remplie}
Tp[T[i]]:=i;
End;
{**************************************************************}
Res:='';
i:=0;
Repeat
i:=i+1;
STR(Tp[MOT[i]],temp);
Res:=Res+Temp;
Until (i=Length(MOT)) OR (Res[Length(Res)]='0');
{Affichage du résultat******}
IF Res[Length(Res)]<>'0' THEN
Write(Res)
ELSE Write('On ne peut pas former la chaîne à partir des car du tab');

End;
Begin
Saisir_N(N);
RemplirLeTableau(T,N);
Saisir_MOT(MOT);
Traitement(T,N,MOT);
End.


éNoncés+corrections bac2010

Contenu connexe

Tendances

Similaire à éNoncés+corrections bac2010

éNoncés+corrections bac2010