Algo.tn

Bac pratique 2017-Sujet 1:

Dans un tableau d'entier, l'existence d'au minimum de deux éléments pairs d'une façon consécutive forme ce qu'on appelle une séquence paire.
On se propose d'écrire un programme intitulé Occ_Pair qui permet de remplir un tableau T par N entiers (avec 3≤N≤20) et d'afficher le nombre de séquences paires de ce tableau ainsi que les entiers de chacune de ces séquences.
Exemple :
Pour N=15 et le tableau T suivant:

1. Traduire l'algorithme Occ_Pair en un programme Pascal et ajouter les déclarations nécessaires.
2. Transformer la séquence n°1 en un module en ajoutant les contraintes nécessaires et apporter les modifications nécessaires dans le programme principal.
3. Développer le module Remplir qui permet de remplir le tableau T par N entiers strictement positifs.
4. Développer le module Afficher qui permet d'afficher le nombre de séquences d'entiers pairs du tableau T ainsi que les entiers de chacune de ces séquences.

Program Occ_pair;
Uses Wincrt;
Type
   TAB =  Array[1..20] Of Integer;
Var
   T:  tab;
   n:  Integer;

Procedure saisir(Var N:Integer);
Begin
   Repeat
      Write('Donner la taille du tableau : ');
      Readln(N);
   Until N In [3..20];
End;

Procedure Remplir( Var T:tab; N:Integer);
Var
   i:  Integer;
Begin
   For i:=1 To n Do
      repeat
         write('T[',i,']=');
         Readln(T[i]);
      until T[i]>0 ;
End;
{nb_sequence retourne le nombre de séquences paires }

Function nb_sequence(t:tab;n:Integer):  Integer;
Var
   i,j,nb:  Integer;
Begin
   nb := 0;
   j := 0;
   For i:=1 To n Do
      Begin
         If T[i] Mod 2 =0 Then j := j+1
         Else j := 0;
         If j=2 Then nb := nb+1;
      End;
   nb_sequence := nb;
End;
{ afficher_seq permet d'afficher une séquence de la position i à la position j }

Procedure afficher_seq(t:tab;i,j:Integer);
Var
   k:  Integer;
Begin
   For k:=i To j Do
      Begin
         write(T[k]);
         If k<>j Then write(', ');
      End;
   Writeln;
End;

Procedure afficher(t:tab; n:Integer);
Var
   i,j:  Integer;
Begin
   Writeln('Le nombre de séquences paires est ',nb_sequence(t,n));
   Writeln('Les séquences d''entiers pairs sont :');
   j := 0;
   For i:=1 To n Do
      Begin
         If T[i] Mod 2 =0 Then
            Begin
               j := j+1;
               If (j>=2) And (i=n) Then afficher_seq(t,i-j+1,i);
            End
         Else
            Begin
               If j>=2 Then afficher_seq(t,i-j,i-1 );
               j := 0;
            End;
      End;
End;
Begin
   saisir(N);
   Remplir(T,N);
   Afficher(T,N) ;
End.

Program Occ_pair;
Uses Wincrt;
Type
   TAB =  Array[1..20] Of Integer;
   tab2 =  Array[1..7] Of String;
Var
   T:  tab;
   n:  Integer;

Procedure saisir(Var N:Integer);
Begin
   Repeat
      Write('Donner la taille du tableau : ');
      Readln(N);
   Until N In [3..20];
End;

Procedure Remplir( Var T:tab; N:Integer);
Var
   i:  Integer;
Begin
   For i:=1 To n Do
      repeat
         write('T[',i,']=');
         Readln(T[i]);
      until T[i]>0;
End;
{Extraire permet d'extraire les séquences paires dans un tableau de chaines T2 de taille n2}
Procedure EXTRAIRE(t:tab;n:Integer;Var T2:tab2;Var n2:Integer);
Var
   i,j:  Integer;
   ch,seq:  string;
Begin
   i := 0;
   n2 := 0;
   Repeat
      i := i+1;
      j := 0;
      seq := '';
      While (i<=n) And (t[i] Mod 2=0) Do
         Begin
            j := j+1;
            Str(t[i],ch);
            If j=1 Then seq := ch
            Else seq := seq+','+ch;
            i := i+1;
         End;
      If j>=2 Then
         Begin
            n2 := n2+1;
            t2[n2] := seq;
         End;
   Until (i>=n);
End;

Procedure afficher(t:tab; n:Integer);
Var
   i,n2:  Integer;
   t2:  tab2;
Begin
   extraire(t,n,t2,n2);
   Writeln('Le nombre de séquences paires est ',n2);
   Writeln('Les séquences d''entiers pairs sont :');
   For i:=1 To n2 Do
      Writeln(t2[i]);
End;
Begin
   saisir(N);
   Remplir(T,N);
   Afficher(T,N) ;
End.

Bac pratique 2017-Sujet 2:

le jeu Numbermind est un jeu à deux qui consiste à deviner un numéro de téléphone.
Le principe du jeu est le suivant :

• - Le premier joueur propose une combinaison de 8 chiffres représentant le numéro à deviner.
• - Le deuxième joueur annonce une proposition de 8 chiffres, si cette proposition correspond au numéro à deviner, ce joueur est gagnant sinon on lui affiche sa proposition à laquelle on garde tous les chiffres bien placés et on remplace le reste par des tirets tout en mentionnant les chiffres corrects mais mal placés dans la proposition
• - On répète l'étape précédente jusqu'a trouver le numéro cherché ou atteindre un nombre d'essais égale à 8.

1. Traduire l'algorithme Numbermind en un programme Pascal et ajouter les déclarations nécessaires.
2. Développer le module Verif qui permet de vérifier si le numéro de téléphone proposé est composé uniquement par 8 chiffres.
3. Développer le module Deviner qui consiste à :
   • - vérifier chaque numéro proposé par le deuxième joueur, en gardant les chiffres bien placés et en remplaçant le reste par des tirets tout en mentionnant ceux qui sont correctes mais mal placés dans la proposition et le nombre d'essai qui lui reste.
   • - arrêter le jeu une fois que le deuxième joueur propose un numéro identique au numéro à deviner ou bien on atteint un nombre d'essai égale à 8.
   • - Afficher le message " Bravo, vous avez gagné" si le joueur 2 réussit à deviner le numéro et le message "Désolé, vous avez perdu " s'il ne devine pas le numéro après 8 essais

vous avez 8 essais
Proposer un numéro de téléphone :56426179
5 qui est à la position 1 dans la proposition n'est pas à sa bonne position
6 qui est à la position 2 dans la proposition n'est pas à sa bonne position
2 qui est à la position 4 dans la proposition n'est pas à sa bonne position
1 qui est à la position 6 dans la proposition n'est pas à sa bonne position
il vous reste 7 essais
--4-6---
Proposer un numéro de téléphone :63456331
3 qui est à la position 2 dans la proposition n'est pas à sa bonne position
3 qui est à la position 6 dans la proposition n'est pas à sa bonne position
il vous reste 6 essais
6-456-31
Proposer un numéro de téléphone :68456231
Bravo vous avez gagné

Program numbermind;
Uses Wincrt;
Var
   num:  string;

{ verif permet de verifier que la chaine num est de longueur =8
 et composée par des chiffres uniquement}

Function Verif(num:String):  Boolean;
Var
   i:  Integer;
   ok:  Boolean;
Begin
   ok := True;
   If Length(num)<>8 Then ok := False
   Else
      Begin
         i := 0;
         Repeat
            i := i+1;
            If Not(num[i] In ['0'..'9']) Then ok := False;
         Until (ok=False) Or (i=Length(num));
      End;
   verif := ok;
End;
{ mal_places permet d'afficher les chiffres mal placés }
Procedure mal_places(num,num2:String);
Var
   i:  Integer;
Begin

   For i:=1 To Length(num) Do
      If (num[i]<>num2[i]) And (Pos(num2[i],num)<>0) Then
         Writeln(num2[i],' qui est à la position ',i,' dans la proposition n''est pas à sa bonne position');
End;
{bien_places permet de retourner une chaine contenant les chiffres bien placés }
Function bien_places(num,num2 : String):  string;
Var
   ch3:  string;
   i:  Integer;
Begin
   ch3 := '';
   For i:=1 To Length(num) Do
      If num[i]=num2[i] Then ch3 := ch3+num[i]
      Else ch3 := ch3+'-';
   bien_places := ch3;
End;

Procedure deviner (num:String);
Var
   num2:  string;
   essais:  Integer;
Begin
   essais := 8;
   Writeln('vous avez ',essais,' essais');
   Repeat
      Repeat
         write('Proposer un numéro de téléphone: ');
         Readln(num2);
      Until verif(num2);
      If num2<>num Then
         Begin
            mal_places(num,num2);
            essais := essais-1;
            Writeln('il vous reste ',essais,' essais');
            Writeln(bien_places(num,num2));
         End;
   Until (num2=num) Or (essais=0);
   If num2=num Then Writeln('Bravo, vous avez gagné')
   Else Writeln('Désolé, vous avez perdu');
End;
Begin
   Repeat
      write('Saisir le numéro de téléphone à deviner : ');
      Readln(num);
   Until Verif(num);
   Clrscr;
   Deviner(num);
End.

Bac pratique 2017-Sujet 3:

Dans le but de sécuriser les messages à envoyer, on peut faire appel à une méthode de cryptage.
Une des méthodes utilisées consiste à remplacer chaque lettre du message à crypter par celle qui la suit de p positions dans l'alphabet français, où p désigne le nombre de mots du message.
NB :

• On suppose que le caractère qui suit la lettre "Z" est le caractère "A" et celui qui suit la lettre "z" est le caractère "a".
• Le caractère espace ne subit aucune modification.
• Le code ASCII de la lettre "a" est égal à 97 et celui de la lettre "A" est égal à 65.

1. Traduire l’algorithme Cryptage en un programme Pascal et ajouter les déclarations nécessaires.
2. Transformer la séquence n°1 en un module et apporter les modifications nécessaires dans le programme principal.
3. Développer le module Valide qui permet de vérifier si le message M est non vide et formé uniquement par des lettres et des espaces
4. Développer le module Nbmot qui permet de déterminer le nombre de mots dans le message M à crypter en prenant en considération la possibilité d’existence des espaces superflus (inutiles).
5. Développer le module Crypter qui permet de crypter un message M en utilisant le principe décrit précédemment.

program Cryptage;
uses wincrt;
var M:String;
p:integer ;
Function valide(M:string):boolean;
Var i:integer;
ok:boolean;
begin
ok:=true;
if m='' then ok:=false
Else
Begin
i:=0;

Repeat
 i:=i+1;
 if not (M[i] in [' ','A'..'Z','a'..'z']) then ok:=false;
until (ok=false) or (i=Length(M))
end;
valide:=ok;
end;
Procedure saisir(var M:string);
Begin
Repeat
write('Donner le message à crypter : ');
readln(M);
until valide(M);
end;
function nbmot(M:string):integer;
Var    i,nb:integer;
Begin
i:=0;  nb:=0;
Repeat
 i:=i+1;   
if  (upcase(M[i]) in ['A'..'Z']) then nb:=nb+1;
 
 while (i<=length(m)) and (upcase(M[i]) in ['A'..'Z']) do
 i:=i+1;
until (i>=length(M));

nbmot:=nb;
end;

function Crypter(M:string; p:integer):string;
Var     code,i:Integer;
Begin
 for i:=1 to Length(M) Do
	Begin
	code:= ord(M[i])+p;
 if M[i] in ['a'..'z'] then if code>ord('z') then   code:=code-26;
  if M[i] in ['A'..'Z'] then if code>ord('Z') then   code:=code-26;
 if M[i]<>' ' then M[i]:=chr(code);
 end;
crypter:=M;
end;

Begin
saisir(M);
p:=Nbmot(M);
writeln(p);
WriteLn(Crypter(M,p)); 
end.

Bac pratique 2017-Sujet 4:

Un IBAN ou numéro international de compte bancaire est une variété de caractères alphanumériques qui identifie de façon distincte, le compte d'un client tenu dans une institution bancaire partout dans le monde.
Exemple: TU3830004015870002601171 est un numéro IBAN où :
TU désigne les initiales du pays du client qui est la Tunisie,
38 est la clé IBAN
Le reste des chiffres représente le code RIB du client qui est de longueur constante relativement à un pays donné (20 pour la Tunisie). Sachant que RIB désigne le Relevé d’Identité Bancaire qui permet au titulaire d'un compte bancaire de transmettre ses coordonnées bancaires pour des virements ou des prélèvements.
La clé IBAN est obtenue en utilisant le procédé suivant :

• - Former une chaine ch composée par les deux premières lettres en majuscules du nom du pays du client auxquelles on ajoute "00" à droite.
• - Former un nombre à partir de la chaîne ch en remplaçant chaque lettre par le nombre qui lui correspond selon le tableau suivant :

• -Calculer le reste de la division du nombre obtenu par 97
• -Soustraire de 98 le reste obtenu. Si le résultat comporte un seul chiffre, insérer un zéro à gauche. Le nombre ainsi obtenu est la clé IBAN.
Exemple : Pour un client de la Tunisie, on obtient la chaîne suivante : TU00
En remplaçant T par 29 et U par 30, on obtient le nombre suivant 293000.
La clé IBAN correspondante à ce client est 38 obtenu comme suit : le reste de la division de 293000 par 97 donne 60 en la retranchant de 98 on obtient 98-60= 38 qui est la clé IBAN de la Tunisie.

1. Traduire l’algorithme Generation en un programme Pascal et ajouter les déclarations nécessaires.
2. Développer le module Saisir qui permet de saisir :
   • Deux lettres majuscules qui représentent les initiales du pays.
   • Le RIB qui doit être une suite de chiffres, correspondant au pays du client, de longueur L avec 10≤ L≤ 30.
3. Développer le module Cle_IBAN qui permet de générer la clé IBAN d’un client en utilisant le procédé décrit précédemment
4. Ajouter ce qui est nécessaire au programme de façon à ce qu’il puisse générer plusieurs codes IBAN relativement à un groupe de clients dont le nombre est inconnu à l’avance.

Program generation;
Uses Wincrt;
Var
   init,RIB,cle:  String;
   Q:char;

Function verif(ch:String):  Boolean;
Var
   i:  Integer;
   ok:  Boolean;
Begin
   ok := True;
   i := 0;
   Repeat
      i := i+1;
      If Not(ch[i]In ['0'..'9']) Then ok := False;
   Until (ok=False) Or (i=Length(ch));
   verif := ok;
End;

Procedure saisir(Var Init,RIB:String);
Begin
   Repeat
      write('Donner les initiales du pays:');
      Readln(Init);
   Until (Length(Init)=2) And (init[1] In ['A'..'Z']) And (init[2] In ['A'..'Z']);
   Repeat
      write('Donner le RIB : ');
      Readln(RIB);
   Until (verif(RIB)) And (Length(RIB) In [10..30]);
End;

Function cle_IBAN(init:String):  string;
Var
   ch:  string;
   nombre:  Longint;
Begin
   ch := init+'00';
   nombre := (Ord(ch[1])-55)*10000+(Ord(ch[2])-55)*100;
   nombre := 98- nombre Mod 97;
   Str(nombre,ch);
   If Length(ch)=1 Then ch := '0'+ch;
   cle_IBAN := ch;
End;
Begin
repeat
   saisir (Init,RIB);
   cle := Cle_IBAN(init);
   Writeln('L''IBAN correspondant est : ',Init+cle+RIB);
writeln('Calculer un autre IBAN (o/n):');
readln(Q);
until Q='n' ; 
End.

Bac pratique 2017-Sujet 5:

Afin de répondre aux besoins des écoles primaires d’une région de la Tunisie, le ministère de l’Éducation charge une commission de visiter ces écoles, de chercher leurs besoins en matériels (Tableaux à craie et tables) et de déterminer le(s) école(s) ayant le besoin le plus élevé.
Pour automatiser les tâches de cette commission, on se propose d’écrire un programme permettant:

• de remplir un premier tableau TE par les N codes des écoles primaires avec 2≤N≤250. Le code d’une école est une chaîne de 6 chiffres.
• de remplir un deuxième tableau TB par les besoins matériels des écoles en tableaux à craie et en tables sous le format suivant : Nombre_de_tableaux#Nombre_de_tables sachant que chaque besoin ne doit pas dépasser 999. Exemples : "852#999", "0#105", "52#0"
• de calculer dans un troisième tableau TBU, le budget nécessaire pour chaque école calculé comme suit : P1*Nombre_de_tableaux + P2* Nombre_de_tables sachant que P1 et P2 sont respectivement les prix d’un tableau à craie et d’une table et qui sont deux constantes dont les valeurs en dinars sont 80 et 160.
• d’afficher toutes les écoles ayant le besoin budgétaire le plus élevé en matériels.

1. Traduire l'algorithme Besoin en un programme Pascal et ajouter les déclarations nécessaires.
2. Développer le module Remplir qui permet de remplir deux tableaux TE et TB en respectant les contraintes décrites précédemment.
3. Développer le module Generer qui permet de générer un troisième tableau TBU le budget nécessaire pour chaque école.
4. Développer le module Afficher qui permet d’afficher le budget le plus élevé et le(s) école(s) concernée(s) par ce budget.

Program Besoin;
Uses Wincrt;

Const
   P1 =  80;
   P2 =  160;
Type
   tab =  Array[1..250] Of string;
   tab2 =  Array[1..250] Of Longint;
Var
   TE,TB:  tab;
   TBU:  tab2;
   n:  Integer;

Function verif(ch:String):  Boolean;
Var
   i:  Integer;
   ok:  Boolean;
Begin
   ok := True;
   i := 0;
   Repeat
      i := i+1;
      If Not(ch[i]In ['0'..'9']) Then ok := False;
   Until (ok=False) Or (i=Length(ch));
   verif := ok;
End;

Function verif2( ch:String):  Boolean;
Var
   p,L,nb1,nb2,e:  Integer;
   tableaux,tables:  string;
Begin
   p := Pos('#',ch);
   L := Length(ch);
   tableaux := Copy(ch,1,p-1);
   tables := Copy(ch,p+1,l-p);
   Val(tableaux,nb1,e);
   Val(tables,nb2,e);
   If (nb1<=999) And (nb2<=999)Then verif2 := True
   Else verif2 := False;
End;

Procedure remplir(Var TE,TB:tab;Var N:Integer);
Var
   i:  Integer;
Begin
   For i:=1 To n Do
      Begin
         Repeat
            write('Code école ',i,' =');
            Readln(TE[i]);
         Until (Length(TE[i])=6) And (verif(TE[i]));
         Repeat
            write('Besoins matériels ',i,' =');
            Readln(TB[i]);
         Until (Length(tb[i])<=7) And (verif2(TB[i]));
      End;
End;

Procedure generer (tb:tab;Var tbu :tab2;n:Integer);
Var
   i,p,l,e,nb1,nb2:  Integer;
   tableaux,tables:  string;
Begin
   For i:=1 To n Do
      Begin
         p := Pos('#',tb[i]);
         L := Length(tb[i]);
         tableaux := Copy(tb[i],1,p-1);
         tables := Copy(tb[i],p+1,l-p);
         Val(tableaux,nb1,e);
         Val(tables,nb2,e);
         tbu[i] := p1*nb1+p2*nb2;
      End;
End;

Procedure afficher (TE:tab;tbu:tab2;n:Integer);
Var
   i:  Integer;
   max:  Longint;
Begin
   Max := tbu[1];
   For i := 2 To n Do
      If tbu[i]>max Then max := tbu[i];
   For i:=1 To n Do
      If tbu[i]=max Then Writeln('code école: ',te[i],' Budget=',tbu[i]);
End;
Begin
   Repeat
      write('Donner le nombre d''écoles à visiter :');
      Readln(n);
   Until n In [2..250];
   Remplir(TE,TB,N);
   Generer(TB,TBU, N);
   Writeln('Le besoin budgétaire le plus élevé:');
   afficher(te,tbu,n);
End.

Bac pratique 2017-Sujet 6:

Sur les billets d’avion d’une Campanie aérienne, figure un code de 11 chiffres précédés d’une lettre majuscule. Exemple U19586900462.
Pour vérifier l’authenticité d’un billet, on remplace la lettre du code par son rang alphabétique pour obtenir un nombre de 12 ou de 13 chiffres.
Si le reste de la division par 9 de la somme des chiffres de ce nombre est égale à 8, ce billet est authentique, sinon c’est un faux billet
Exemple :
Le billet ayant pour code "U19586900462" est authentique. En effet,

• -La lettre "U" a pour rang alphabétique 21.
• - Le nombre formé sera : "2119586900462".
• - La somme des chiffres de ce nombre est 2+1+1+9+5+8+6+9+0+0+4+6+2 =53.
• - Le reste de la division de 53 par 9 est égale à 8.

1. Traduire l'algorithme Billet en un programme Pascal et ajouter les déclarations nécessaires.
2. Développer le module Verif qui permet de vérifier si le code proposé commence par une lettre majuscule suivie de 11 chiffres.
3. Développer le module Authentique qui permet de vérifier l’authenticité du code en utilisant le procédé décrit précédemment
4. Ajouter ce qui est nécessaire au programme de façon à ce qu’il puisse vérifier plusieurs billets dont le nombre est inconnu à l’avance.

Program Billet;
Uses Wincrt;
Var
   code:  string;
   q:  Char;

Function Verif(code :String):  Boolean;
Var
   ok:  Boolean;
   i:  Integer;
Begin
   ok := True;
   If Not(code[1] In ['A'..'Z']) Or (Length(code)<>12)
      Then ok := False;
   i := 1;
   While (i < Length(code)) And (ok) Do
      Begin
         i := i+1;
         If Not(code[i] In ['0'..'9']) Then ok := False;
      End;
   verif := ok;
End;

Function authentique(code:String):  Boolean;
Var
   ch:  string;
   rang,somme,i,d,e:  Integer;
Begin
   rang := Ord(code[1])-Ord('A')+1;
   Str(rang,ch);
   Delete(code,1,1);
   code := ch+code;
   somme := 0;
   For i:=1 To Length(code) Do
      Begin
         Val(code[i],d,e);
         somme := somme+d;
      End;
   authentique := (somme Mod 9 =8 );
End;
Begin
   Repeat
      Repeat
         write('Saisir le code à valider:');
         Readln(code);
      Until ( verif(code) );
      If (authentique(code) ) Then Writeln('C''est un billet authentique')
      Else Writeln('Attention ! Ce billet n''est pas authentique');
      Writeln('Voulez vous vérifier un autre code (o/n): ');
      Readln(Q);
   Until (upcase(Q)='N');
End.

Bac pratique 2017-Sujet 7:

Le jeu du pendu est un jeu à deux qui consiste à trouver un mot en devinant les lettres qui le composent. Pour ce faire, un premier joueur propose un mot à deviner ensuite, on affiche au deuxième joueur le mot à deviner d’une manière masquée en faisant apparaitre la première et la dernière lettre du mot et en remplaçant chacune des lettres restantes par un tiret ("-").
Pour deviner le mot, le deuxième joueur annonce une lettre. Si cette lettre fait partie du mot à deviner, on la dévoile en l’affichant à la place du tiret correspondant dans le mot masqué et ceci autant de fois que cette lettre apparait dans le mot.
Le jeu continue jusqu’à dévoiler toutes les lettres masquées ou atteindre un nombre d’essai égal à la longueur du mot à deviner.
Pour cela, on donne l’algorithme du programme principal suivant :
0) Début Jeu
1) Répéter
     Ecrire ("Saisir le mot à deviner :")
     Lire (mot)
  Jusqu’à (FN Verif (mot))
2) Efface_ecran ( )
3) masque←FN Masquer (mot)
4) PROC Deviner (mot, masque)
5) Fin Jeu
NB : Efface_ecran est une procédure prédéfinie qui permet d’effacer l’écran. Son équivalent en pascal est : CLRSCR;

Travail demandé :

1. Traduire l'algorithme jeux en un programme Pascal et ajouter les déclarations nécessaires.
2. Développer le module Verif qui permet de vérifier si le mot proposé est composé uniquement par des lettres et ayant une longueur comprise entre 5 et 20.
3. Développer le module Masquer qui permet de générer le mot à deviner d’une manière masquée et ceci en dévoilant la lettre de début et celle de la fin et en remplaçant le reste des lettres par des tirets "-".
4. Développer le module Deviner qui affiche au deuxième joueur le mot masqué et lui demande de proposer une lettre puis dévoile ses occurrences dans le mot masqué sans faire de distinction entre lettre majuscule et lettre minuscule.
5. Apporter les modifications nécessaires au programme afin qu’il puisse donner au deuxième joueur la possibilité de :
   • - répéter l’action de deviner jusqu’à trouver le mot à deviner ou atteindre un nombre d’essai égal à la longueur de ce mot et afficher à chaque fois le nombre d’essais restants.
   • - afficher le message " Bravo, vous avez gagné" si le joueur 2 réussit à deviner le mot et le message "Désolé, vous avez perdu " s’il ne le devine pas après un nombre d’essais égal à la longueur de ce mot.

Program jeu;
Uses Wincrt;
Var
   mot,masque:  String;

Function verif(ch:String):  Boolean;
Var
   ok:  Boolean;
   i:  Integer;
Begin
   ok := True;
   If Not(Length(ch) In [5..20]) Then ok := False
   Else
      Begin
         i := 0;
         Repeat
            i := i+1;
            If Not( Upcase (ch[i]) In ['A'..'Z']) Then ok := False;
         Until (i=Length(ch)) Or (ok=False);
      End;
   verif := ok;
End;

Function masquer(ch:String):  string;
Var
   i:  Integer;
Begin
   For i:=2 To Length(ch)-1 Do
      ch[i] := '-';
   masquer := ch;
End;

Procedure deviner(mot:String; Var masque:String);
Var
   nb,i:  Integer;
   c:  Char;
Begin
   nb := Length(mot);
   Repeat
      Writeln('Le mot à deviner est : ', masque);
      Writeln('il vous reste ',nb,' essai(s) ');
      Write('Proposer un carctère: ');
      Readln(c);
      For i:=1 To nb Do
         If Upcase(c)=Upcase(mot[i]) Then masque[i] := mot[i];
      nb := nb-1;
   Until ( nb=0) Or (masque=mot);
   If mot=masque Then Writeln('Bravo, vous avez gagné')
   Else Writeln('Désolé, vous avez perdu ');
   Writeln('Le mot masqué est :',mot);
End;
Begin
   Repeat
      write('Saisir le mot à déviner:');
      Readln(mot);
   Until verif(mot);
   Clrscr;
   masque := Masquer(mot);
   deviner(mot,masque);
End.

Bac pratique 2017-Sujet 8:

Dans le but de sécuriser les messages à envoyer, on peut faire appel à une méthode de cryptage. Une des méthodes utilisées, pour crypter un message M de longueur paire et formé uniquement de lettres majuscules et d’espaces, consiste à :
    Etape 1 : Découper le message à envoyer en blocs de deux lettres.
    Etape 2 : Déterminer pour chaque lettre d’un bloc l’entier correspondant selon le tableau suivant :

• On obtient ainsi pour chaque bloc un couple d’entiers (x1, x2), où x1 est l’entier qui correspond au premier caractère du bloc et x2 est l’entier qui correspond au deuxième caractère du bloc.

• y1 est égal au reste de la division entière de 11*x1 + 3 * x2 par 27.
• y2 est égal au reste de la division entière de 7*x1 + 4 * x2 par 27.

1. Traduire l'algorithme Cryptage en un programme Pascal et ajouter les déclarations nécessaires.
2. DTransformer la séquence n°1 en un module et apporter les modifications nécessaires dans le programme principal.
3. Développer le module Valide qui permet de vérifier si le message M est de longueur paire et constitué seulement par des lettres majuscules et d’espaces
4. Développer le module Crypter qui permet de crypter un message M en appliquant la méthode décrite précédemment.

Program cryptage;
Uses Wincrt;
Var
  M: String;
Function valide(ch:String): Boolean;
Var
  i: Integer;
  ok: Boolean;
Begin
  ok := True;
  If (Length(ch) Mod 2<>0) Then ok := False
  Else
    Begin
      i := 0;
      Repeat
        i := i+1;
        If Not(ch[i] In ['A'..'Z',' ']) Then ok := False;
      Until (i=Length(ch)) Or (ok=False);
    End;
  valide := ok;
End;

Procedure saisir(Var ch:String);
Begin
  Repeat
    Write('Donner une chaine à coder :');
    Readln(ch);
  Until valide(m);
End;
Function crypter(ch:String): String;
Var
  ch2: String;
  i,k,x1,x2,y1,y2: Integer;
Begin
  ch2 := '';
  For k:=1 To (Length(ch) Div 2) Do
    Begin
      i := k*2-1;
      If ch[i]=' ' Then x1 := 26
      Else x1 := Ord (ch[i])-ord('A');

      If ch[i+1]=' ' Then x2 := 26
      Else x2 := Ord(ch[i+1])-ord('A');

      y1 := (11*x1+3*x2) mod 27;
      y2 := (7*x1+4*x2) Mod 27;
//writeln('i=',i);
//writeln('x1=',x1,'   x2=',x2,'   y1=',y1,'   y2=',y2);
				if y1=26 then ch2:=ch2+' '
			else  ch2 := ch2+Chr(ord('A')+y1) ;
			if y2=26 then ch2:=ch2+' '
			else  ch2 := ch2+Chr(ord('A')+y2) ;
	 End;
  crypter := ch2;
End;
Begin
  saisir(M);
  Writeln(crypter(m));
End.

Bac pratique 2017-Sujet 9:

Le ministère de l’éducation organise une compétition nationale en informatique pour évaluer le niveau algorithmique des élèves. Chaque participant à cette compétition a un code composé de trois lettres majuscules représentant les trois premières lettres du nom de son gouvernorat suivi de trois chiffres. Suite au passage de l’épreuve, une note comprise entre 0 et 20 est accordée à chaque participant.
On se propose d’écrire un programme « Competition » qui permet :

• - de remplir un tableau TC par les codes des N participants en respectant les contraintes mentionnées ci-dessus avec N un entier de l’intervalle [5..100].
• - de remplir un tableau TN par les notes des N participants.
• - d’afficher le taux de réussite nationale (TRN) calculé comme suit :
  TRN = Npr / N avec Npr représente le nombre de participants qui ont réussi sachant qu’un participant est déclaré réussi si et seulement si il a une note ≥10.
• - d’afficher le taux de réussite relatif à un gouvernorat donné (TRG) connaissant son nom qui est une chaine d’au maximum 15 lettres alphabétiques :
  TRG = Nprg/ Ntpg avec Nprg et Ntpg représentent respectivement le nombre de participants d’un gouvernorat qui ont réussi et le nombre total de participant de ce gouvernorat.

1. Traduire l’algorithme Competition en un programme Pascal et ajouter les déclarations nécessaires
2. Transformer la séquence n°1 en un module et apporter les modifications nécessaires dans le programme principal.
3. Développer le module Remplir qui permet de remplir deux tableaux TC et TN respectivement par les codes et les notes des N participants (avec N est un entier de l’intervalle [5..100]) en respectant les contraintes décrites précédemment.
4. Développer le module Afficher qui permet d’afficher le taux de réussite national et le taux de réussite d’un gouvernorat donné qui est une chaîne d’au maximum 15 lettres alphabétiques en respectant le format d’affichage en pourcentage avec deux chiffres après la virgule.

Bac pratique 2017-Sujet 10:

Le terme Bigramme désigne la combinaison de deux lettres consécutives et distinctes dans un mot. On se propose d’écrire un programme qui permet d’afficher le nombre d’occurrences de chaque Bigramme d’une chaîne de caractères Ch non vide et formée uniquement de lettres minuscules.
Pour cela, on donne l’algorithme du programme principal suivant :
0) Début Bigramme
1) Répéter
     Ecrire ("Donner une chaîne:")
     Lire (Ch)
  Jusqu’à (FN Valide(Ch))
2) PROC Afficher(Ch)
3) Fin Bigramme

Travail demandé :

1. Traduire l’algorithme Bigramme en un programme Pascal et ajouter les déclarations nécessaires.
2. Transformer la séquence n°1 en un module et apporter les modifications nécessaires.
3. Développer le module Valide qui permet de vérifier si la chaîne Ch est non vide et formée uniquement de lettres minuscules.
4. Développer le module Afficher qui permet de déterminer et d’afficher le nombre d’occurrences de chaque Bigramme de la chaîne Ch.

• Pour Ch = "mamapappacma"
• Le programme affiche :
• Le nombre d’occurrences de ma est 3
• Le nombre d’occurrences de am est 1
• Le nombre d’occurrences de ap est 2
• Le nombre d’occurrences de pa est 2
• Le nombre d’occurrences de ac est 1
• Le nombre d’occurrences de cm est 1

Program bigramme;
Uses Wincrt;
Var
  ch: String;

Function verif(ch:String): Boolean;
Var
  test: Boolean;
  i: Integer;
Begin
  test := True;
  If Length(ch)=0 Then test := False
  Else
    Begin
      i := 0;
      Repeat
        i := i+1;
        If Not(ch[i] In ['a'..'z']) Then test := False;
      Until (i=Length(ch)) Or (test=False);
    End;
  verif := test;
End;

Procedure saisir (Var ch:String);
Begin
  Repeat
    Writeln('Donner une chaine: ');
    Readln(ch);
  Until verif(ch);
End;
{calcul du nombre d'occurence de la chaine ch1 dans ch}
Function occurence (ch1,ch:String): Integer;
Var
  nb,i: Integer;
Begin
  nb := 0;
  For i:=1 To Length(ch)-1 Do
    If ch1=ch[i]+ch[i+1] Then nb := nb+1;
  occurence := nb;
End;
{afficher le nombre d'occurence de chaque bigramme }
Procedure afficher(ch:String);
Var
  i: Integer;
  ch1,ch3: String;
Begin
  For i:=1 To Length(ch)-1 Do
    If ch[i] <> ch[i+1] Then
      Begin
        ch1 := ch[i]+ch[i+1];
        ch3 := Copy(ch,1,i-1);
        If occurence(ch1,ch3)=0 Then Writeln ('le nombre d''occurence de ',ch1,'est ', occurence(ch1 ,ch));
      End;
End;
Begin
  saisir(ch);
  afficher (ch);
End.

Bac pratique 2017-Sujet 11:

Une séquence nulle d’un tableau d’entiers T est un ensemble d’éléments consécutifs dont la somme de valeurs est égale à zéro.
On se propose d’écrire un programme intitulé « Sequence » qui permet de remplir un tableau T par N entiers non nuls (avec 3 ≤ N ≤ 15) et d’afficher le nombre de séquences nulles de ce tableau ainsi que les éléments de chacune.
Exemple :
Pour N=12 et le tableau T suivant:

• 5,12,-6,-11
• 15,-11,-4
• -4,4
• 4,-4
• 15,-11,-4,4,-4

1. Traduire l'algorithme Sequence en un programme Pascal et ajouter les déclarations nécessaires.
2. Transformer la séquence n°1 en un module et apporter les modifications nécessaires dans le programme principal.
3. Développer le module Remplir qui permet de remplir le tableau T par N entiers non nuls.
4. Développer le module Afficher qui permet d’afficher le nombre de séquences nulles du tableau T ainsi que les éléments de chacune.

Bac pratique 2017-Sujet 12:

Le club culturel d’un lycée organise un jeu de lettres entre les élèves de l’établissement. Le jeu se joue à deux sous forme de tours en appliquant le principe suivant :

• -On propose 10 lettres alphabétiques majuscules.
• - Chacun des deux joueurs est appelé à former un mot significatif dans la langue française composé par des lettres parmi les 10 proposées.
• - Le score du tour de chacun des joueurs sera égal au nombre de lettres du mot proposé une fois validé par l’enseignant.

1. Dans un fichier intitulé Version1, traduire l’algorithme Jeu en un programme Pascal et ajouter les déclarations nécessaires.
2. Dans un fichier intitulé Version2, copier le contenu du fichier Version1 et effectuer les modifications suivantes :
   • b.1 Développer le module Generer qui permet de générer aléatoirement une chaîne ch de 10 lettres majuscules.
   • b.2 Développer le module Verif qui permet de vérifier si le mot proposé est composé uniquement par des lettres de la chaîne ch et qu’il est un mot significatif dans la langue française selon l’avis d’un professeur au quel on se réfère.
   • NB : Le professeur au quel on se réfère valide le mot proposé en introduisant la lettre "O" dans le cas où le mot est significatif et introduit la lettre "N" dans le cas contraire.
   • b.3 Modifier le programme de façon à ce que le jeu dure plusieurs tours jusqu’à ce que le score total de l’un des joueurs dépasse 15 comme le montre l’exemple ci-dessous :
     • *Tour 1* Les lettres proposées sont : JKXRBOTNUM
       Proposition du premier joueur: Bonjour
       Le mot existe dans la langue française ou non ? o
       Proposition du deuxième joueur: jour
       Le mot existe dans la langue française ou non ? o
       Score du joueur 1 : 7 ******* Score du joueur 2: 4
       *Tour 2* Les lettres proposées sont : TCBNRUSOXJ
       Proposition du premier joueur: Concours
       Le mot existe dans la langue française ou non ? o
       Proposition du deuxième joueur: ron
       Le mot existe dans la langue française ou non ? n
       Score du joueur 1 : 15 ******* Score du joueur 2: 4
       C'est le premier joueur qui a gagné
       

Bac pratique 2017-Sujet 13:

Dans le but de sécuriser les messages à envoyer, on peut faire appel à une méthode de cryptage. Soit la méthode de cryptage suivante qui consiste à crypter par transposition de caractères, un message M de longueur L décrite comme suit:

• -Déterminer tous les diviseurs de L autres que 1 et lui même.
• -Pour chaque diviseur d de L et en commençant par le plus petit, on inverse symétriquement les caractères de chaque bloc de longueur d.

• Les diviseurs de 12 autres que 1 et 12 sont : 2, 3, 4 et 6.
• Les inversions des blocs de caractères seront effectuées comme suit :
  
  • Après inversion de chaque bloc de 2 caractères de la chaîne "INFORMATIQUE", on aura la chaîne "NIOFMRTAQIEU".
  • Après inversion de chaque bloc de 3 caractères de la chaîne " NIOFMRTAQIEU ", on aura la chaîne "OINRMFQATUEI".
  • Après inversion de chaque bloc de 4 caractères de la chaîne " OINRMFQATUEI ", on aura la chaîne "RNIOAQFMIEUT".
  • Après inversion de chaque bloc de 6 caractères de la chaîne " RNIOAQFMIEUT ", on aura la chaîne "QAOINRTUEIMF"

1. Traduire l’algorithme Cryptage en un programme Pascal et ajouter les déclarations nécessaires.
2. Transformer la séquence n°1 en un module et apporter les modifications nécessaires dans le programme principal
3. Développer le module Valide qui permet de vérifier si la longueur du message M est un nombre non premier et supérieur à 4.
4. Développer le module Crypter qui permet de crypter un message M en utilisant le principe décrit précédemment.

Bac pratique 2017-Sujet 14:

L’ISSN (International Standard Serial Number) est un code international normalisé qui permet d’identifier de manière univoque toute publication en série indépendamment du pays d’édition, de la langue de publication et du support (imprimé, ressource en ligne, CD, DVD...).
L’ISSN prend la forme suivante : ISSN Bloc1-Bloc2 où chaque bloc est formé de quatre chiffres.
Le dernier chiffre du deuxième bloc est un chiffre de contrôle d’authenticité qui doit être égal au reste de la division par 11 du nombre formé par les 7 autres chiffres ( les 4 chiffres du Bloc1 suivis des 3 premiers chiffres du Bloc2) ; il sera remplacé par "X" si ce reste est égal à 10.
Exemple :
ISSN 0317-8472 est un ISSN authentique.
En effet, 2 représente le reste de la division entière de 317847 par 11.
ISSN 1050-125X est un ISSN authentique.
En effet, X remplace 10 qui est égal au reste de la division entière de 1050125 par 11.
ISSN 0317-8473 n’est pas un ISSN authentique.
En effet, 3 ne représente pas le reste de la division entière de 317847 par 11.

On se propose d’écrire un programme Pascal qui permet de remplir un premier tableau Pub par N noms de publications avec 5≤ N≤10 et dans un deuxième tableau Code les N codes ISSN correspondants puis d’afficher uniquement les publications authentiques sachant qu’une publication est dite authentique si et seulement si son code ISSN est authentique.
Pour cela, on propose l’algorithme du programme principal suivant :
0) Début Verification
1) Répéter
    Ecrire (" Saisir le nombre de publications à vérifier :")
    Lire (N)
  Jusqu’à ( N dans [5..10])
2) PROC Remplir (Pub, code, N)
3) Pour i de 1 à N faire
    Si (FN authentique (Code[i]))
    Alors Ecrire (Pub[i])
    Fin Si
  Fin Pour
4) Fin Verification

Travail demandé :

1. Traduire l’algorithme Verification en un programme Pascal et ajouter les déclarations nécessaires.
2. Développer le module Remplir qui permet de saisir les noms des N publications dans un tableau nommé Pub ainsi que les N codes ISSN correspondants dans un tableau nommé Code sachant qu’un code ISSN doit être une chaine représentée comme suit : ISSN Bloc1-Bloc2 où Bloc1 et Bloc2 sont deux groupes de quatre chiffres chacun.
3. Développer le module Authentique qui permet de vérifier l’authenticité d’un code ISSN en utilisant le procédé décrit précédemment.

Bac pratique 2017-Sujet 15:

Le ministère de l’éducation organise une olympiade d’informatique à l’échelle nationale.
Pour générer un code pour chaque participant à cette olympiade, on se propose d’écrire un programme intitulé Olympiade qui permet de:

• remplir deux tableaux TN et TG respectivement par, les noms et les gouvernorats d’origine des N participants avec 5 ≤ N ≤ 26. Il est à noter que le nom d’un participant ne doit pas dépasser 15 lettres et celui du gouvernorat est d’au maximum 10 lettres.
• générer dans un troisième tableau TC, un code pour chaque participant. Ce code est formé de 5 caractères dont :
  • les trois premiers caractères représentent les trois premières lettres du gouvernorat du participant
  • et les deux derniers caractères est un nombre de 2 chiffres représentant le rang du participant par rapport aux autres participants du même gouvernorat
• afficher pour chaque participant, son nom et son code.

1. Traduire l’algorithme Olympiade en un programme Pascal et ajouter les déclarations nécessaires.
2. Développer le module Verif qui permet de vérifier si une chaine est composée uniquement par des lettres et de longueur L donnée
3. Développer le module Generer qui permet de générer le tableau TC comme décrit précédemment.
4. Développer le module Afficher qui permet d’afficher pour chaque participant, son nom et son code.