Vous êtes sur la page 1sur 13

OFPPT

Office de la Formation Professionnelle et de la Promotion du Travail

Direction Recherche et Ingénierie de la Formation


Examen de Passage (Correction)

Session Juillet 2014

Filière : Techniques de Développement Informatique Epreuve : Synthèse


Niveau: TS Variante :V2
Durée : 5 heures Barème : / 120

 Partie I : Théorie
 Dossier 1: Notions de mathématiques appliquées à l’informatique

 Exercice 1: Conversion numérique

Compléter le tableau suivant:

Décimal Binaire Octal Hexadécimal


6548 1100110010100 14624 1994
411 110011011 633 19B
2979 101110100011 5643 BA3
9148 10001110111100 21674 23BC

 Exercice 2: Algèbre de Boole

̅:
Soit la table de vérité de la fonction logique 𝑸

k l m n ̅ Q
𝑸
0 0 0 0 0 1
0 0 0 1 1 0
0 0 1 0 0 1
0 0 1 1 0 1
0 1 0 0 1 0
0 1 0 1 1 0
0 1 1 0 0 1
0 1 1 1 0 1
1 0 0 0 0 1
1 0 0 1 1 0
1 0 1 0 1 0
1 0 1 1 1 0
1 1 0 0 0 1
1 1 0 1 0 1
1 1 1 0 0 1
1 1 1 1 0 1

Filière Epreuve Session 1/13


TDI Synthèse V2(Correction) Juillet 2014
1- Donner la 1ère forme canonique de la fonction logique Q.

̅𝒍̅𝒎
𝑸(𝒌, 𝒍, 𝒎, 𝒏) = 𝒌 ̅𝒏 ̅𝒍̅𝒎𝒏
̅+𝒌 ̅𝒍̅𝒎𝒏 + 𝒌
̅+𝒌 ̅𝒍𝒎𝒏 ̅𝒍𝒎𝒏 + 𝒌𝒍̅𝒎
̅+ 𝒌 ̅𝒏 ̅𝒏
̅ + 𝒌𝒍𝒎 ̅ 𝒏 + 𝒌𝒍𝒎𝒏
̅ + 𝒌𝒍𝒎 ̅ + 𝒌𝒍𝒎𝒏

2- Simplifier analytiquement la fonction logique Q.

𝑸(𝒌, 𝒍, 𝒎, 𝒏) = 𝒍̅𝒎
̅𝒏 ̅𝒎
̅ + 𝒌𝒍 + 𝒌

3- Simplifier la fonction logique Q avec la méthode de Karnaugh.

Q
kl
mn 00 01 11 10
00 1 0 1 1
01 0 0 1 0
11 1 1 1 0
10 1 1 1 0

𝑸(𝒌, 𝒍, 𝒎, 𝒏) = 𝒍̅𝒎
̅𝒏 ̅𝒎
̅ + 𝒌𝒍 + 𝒌

 Dossier 2: Techniques de programmation structurée

 Exercice 1: Le sablier

Variable U : Caractère [ 20 , 20 ]
Variable M : Entier
Début
Répéter
Afficher ( "Donner la taille paire: " )
Saisir ( M )
Si Modulo ( M , 2 ) <> 0 Alors
Afficher ( "La taille doit être paire!" )
FinSi
Jusqu'à Modulo ( M , 2 ) = 0
sablier ( U , M )
Fin

Procédure sablier ( T : Caractère [ 20 , 20 ] ; N : Entier )


Variable i , j , k : Entier
Variable dessiner : Chaîne
Début
Pour i <- 1 à N + 2
Pour j <- 1 à N + 1
Si i = 1 Ou i = N + 2 Alors
T [ i , j ] <- "-"
Sinon
T [ i , j ] <- ""
FinSi
FinPour
FinPour

Pour i <- 2 à N + 1
j <- i - 1
k <- N + 3 - i
Si i > N / 2 + 1 Alors
j <- j + 1
k <- k - 1
FinSi
T [ i , j ] <- "\"
T [ i , k ] <- "/"
FinPour

Filière Epreuve Session 2/13


TDI Synthèse V2(Correction) Juillet 2014
Pour i <- 1 à N + 2
dessiner <- ""
Pour j <- 1 à N + 1
dessiner <- dessiner & T [ i , j ]
FinPour
Afficher ( dessiner )
FinPour
Fin

 Exercice 2: Elimination des répétitions

Variable S : Caractère [ 100 ]


Variable M , i : Entier
Début
Afficher ( "Donner le nombre des lettres: " )
Saisir ( M )
Pour i <- 1 à M
Saisir ( S [ i ] )
FinPour
Afficher ( sans_répétition ( S , M ) )
Fin

Fonction sans_répétition ( T : Caractère [ 100 ] ; N : Entier ) : Chaîne


Variable j , k , l : Entier
Variable retour : Chaîne
Début
retour <- ""

Pour j <- 1 à N - 1
Pour k <- j + 1 à N
Si T [ j ] = T [ k ] Alors
Pour l <- k à N - 1
T [ l ] <- T [ l + 1 ]
FinPour
N <- N - 1
k <- k - 1
FinSi
FinPour
FinPour

Pour j <- 1 à N
retour <- retour & T [ j ]
FinPour

Retourner retour
Fin

 Dossier 3: Conception et modélisation d'un système d'information

Conception d’un système d’information pour une société informatique

Une grande société de fabrication de produits informatiques souhaite réaliser un site web, permettant de
présenter ses produits à la clientèle. La société fabrique plusieurs produits informatiques, notamment des
serveurs, des postes de travail, des ordinateurs portables, des imprimantes, … .

Certains produits de la société informatique nécessitent l’intégration de composants de constructeurs


tierces. Par exemple: pour fabriquer un ordinateur personnel, la société peut utiliser les microprocesseurs
et les mémoires vives fabriquées par des constructeurs spécialisés en microélectronique. D’autre part
certains produits (ordinateurs, tablettes, …) ont besoin de systèmes d’exploitation pour les utiliser; ces
systèmes sont développés par des sociétés de développement informatique. La société n’installe qu’un
système d’exploitation par machine.

Filière Epreuve Session 3/13


TDI Synthèse V2(Correction) Juillet 2014
Pour construire ses produits informatiques, la société informatique peut faire appel à des constructeurs de
composants informatiques. Par exemple: pour fabriquer un ordinateur personnel, la société peut introduire
des disques dur fabriquées par une société spécialisée dans ce domaine. Les constructeurs peuvent être
des filiales d’autres sociétés constructrices en conséquence des fusions qui se font entre les sociétés. Par
exemple: pour ses ordinateurs, la société informatique peut utiliser les microprocesseurs d’un
constructeur, et les cartes graphiques d’une filiale de ce même constructeur.

Pour faire fonctionner les composants de ses produits, la société informatique installe les pilotes de
chaque composant tiers, en tenant compte de la compatibilité avec le système d’exploitation utilisé avec
le produit.

Pour chaque constructeur ou société de développement informatique, on retient sa raison sociale, son
adresse postale, son numéro de téléphone, son e-mail et le lien vers son site web. Pour chaque composant,
produit, pilote ou système d’exploitation, on retient sa référence, sa désignation et son prix (sauf pour les
pilotes qui sont fournies gratuitement avec leurs composants).

1- Et 2- Etablir le modèle conceptuel de données.

3-Etablir le modèle logique de données.

Filière Epreuve Session 4/13


TDI Synthèse V2(Correction) Juillet 2014
 Partie II: Pratique
 Dossier 1: Langage de programmation structurée

 Exercice 1:

a. Pour ‘B’ l’expression « ((toupper(c) + 5 - 'A')%26) + 'A' » fourni ‘W’,


pour ‘H’ elle fournit ‘C’, pour ‘D’ elle fournit ‘Y’, et pour ‘A’ elle fournit ‘V’. Donc
l’expression réalise une translation d’un caractère de - 5 caractère dans l’ensemble des
caractères de ‘A’ a ‘Z’.
b. Contenu de fichiers « res.txt »

 Exercice 2:

Filière Epreuve Session 5/13


TDI Synthèse V2(Correction) Juillet 2014
 Dossier 2: Programmation orientée objet

 Classe "Développeur"

using System;

public class Développeur


{
private uint IdDéveloppeur;
private string RaisonSocialeDéveloppeur;
private string AdresseDéveloppeur;
private string TélDéveloppeur;
private string EMailDéveloppeur;
private string SiteWebDéveloppeur;

private static uint auto;

public Développeur(string RaisonSocialeDéveloppeur, string AdresseDéveloppeur, string TélDéveloppeur, string


EMailDéveloppeur, string SiteWebDéveloppeur)
{
this.RaisonSocialeDéveloppeur = RaisonSocialeDéveloppeur;
this.AdresseDéveloppeur = AdresseDéveloppeur;
this.TélDéveloppeur = TélDéveloppeur;
this.EMailDéveloppeur = EMailDéveloppeur;
this.SiteWebDéveloppeur = SiteWebDéveloppeur;

auto++;
IdDéveloppeur = auto;
}

public uint pIdDéveloppeur


{
get { return IdDéveloppeur; }
}

public string pRaisonSocialeDéveloppeur


{
get { return RaisonSocialeDéveloppeur; }
set { RaisonSocialeDéveloppeur = value; }
}

public string pAdresseDéveloppeur


{
get { return AdresseDéveloppeur; }
set { AdresseDéveloppeur = value; }
}

public string pTélDéveloppeur


{
get { return TélDéveloppeur; }
set { TélDéveloppeur = value; }
}

public string pEMailDéveloppeur


{
get { return EMailDéveloppeur; }
set { EMailDéveloppeur = value; }
}

public string pSiteWebDéveloppeur


{
get { return SiteWebDéveloppeur; }
set { SiteWebDéveloppeur = value; }
}

public new string ToString()


{
return RaisonSocialeDéveloppeur + " " + AdresseDéveloppeur + " " + TélDéveloppeur + " " + EMailDéveloppeur + "
" + SiteWebDéveloppeur +".";
}
}

 Classe "Constructeur"

Filière Epreuve Session 6/13


TDI Synthèse V2(Correction) Juillet 2014
using System;

public class Constructeur


{
private uint IdConstructeur;
private string RaisonSocialeConstructeur;
private string AdresseConstructeur;
private string TélConstructeur;
private string EMailConstructeur;
private string SiteWebConstructeur;
private Constructeur constructeur;

private static uint auto;

public Constructeur(string RaisonSocialeConstructeur, string AdresseConstructeur, string TélConstructeur, string


EMailConstructeur, string SiteWebConstructeur)
{
this.RaisonSocialeConstructeur = RaisonSocialeConstructeur;
this.AdresseConstructeur = AdresseConstructeur;
this.TélConstructeur = TélConstructeur;
this.EMailConstructeur = EMailConstructeur;
this.SiteWebConstructeur = SiteWebConstructeur;
auto++;
IdConstructeur = auto;
}

public Constructeur(string RaisonSocialeConstructeur, string AdresseConstructeur, string TélConstructeur, string


EMailConstructeur, string SiteWebConstructeur, Constructeur constructeur)
: this(RaisonSocialeConstructeur, AdresseConstructeur, TélConstructeur, EMailConstructeur,
SiteWebConstructeur)
{

this.constructeur = constructeur;
}

public uint pIdConstructeur


{
get { return IdConstructeur; }
}

public string pRaisonSocialeConstructeur


{
get { return RaisonSocialeConstructeur; }
set { RaisonSocialeConstructeur = value; }
}

public string pAdresseConstructeur


{
get { return AdresseConstructeur; }
set { AdresseConstructeur = value; }
}

public string pTélConstructeur


{
get { return TélConstructeur; }
set { TélConstructeur = value; }
}

public string pEMailConstructeur


{
get { return EMailConstructeur; }
set { EMailConstructeur = value; }
}

public string pSiteWebConstructeur


{
get { return SiteWebConstructeur; }
set { SiteWebConstructeur = value; }
}

public new string ToString()


{
string chaîne = RaisonSocialeConstructeur + " " + AdresseConstructeur + " " + TélConstructeur + " " +
EMailConstructeur + " " + SiteWebConstructeur + ".";
if (constructeur != null) return constructeur.pRaisonSocialeConstructeur + " - " + chaîne;
else return chaîne;
}

Filière Epreuve Session 7/13


TDI Synthèse V2(Correction) Juillet 2014
}

 Classe "Système"

using System;

public class Système


{
private string RéfSystème;
private string DésignationSystème;
private float PrixSystème;
private Développeur développeur;

public Système(string RéfSystème, string DésignationSystème, float PrixSystème, Développeur développeur)


{
this.RéfSystème = RéfSystème;
this.DésignationSystème = DésignationSystème;
this.PrixSystème = PrixSystème;
this.développeur = développeur;
}

public string pRéfSystème


{
get { return RéfSystème; }
set { RéfSystème = value; }
}

public string pDésignationSystème


{
get { return DésignationSystème; }
set { DésignationSystème = value; }
}

public float pPrixSystème


{
get { return PrixSystème; }
set { PrixSystème = value; }
}

public Développeur pdéveloppeur


{
get { return développeur; }
set { développeur = value; }
}

public new string ToString()


{
return développeur.pRaisonSocialeDéveloppeur + " " + RéfSystème + " " + DésignationSystème + " " + PrixSystème + ".";
}}

 Classe "Composant"

using System;

public class Composant


{
private string RéfComposant;
private string DésignationComposant;
private float PrixComposant;
private Constructeur constructeur;

public Composant(string RéfComposant, string DésignationComposant, float PrixComposant, Constructeur constructeur)


{
this.RéfComposant = RéfComposant;
this.DésignationComposant = DésignationComposant;
this.PrixComposant = PrixComposant;
this.constructeur = constructeur;
}

public string pRéfComposant


{
get { return RéfComposant; }
set { RéfComposant = value; }

Filière Epreuve Session 8/13


TDI Synthèse V2(Correction) Juillet 2014
}

public string pDésignationComposant


{
get { return DésignationComposant; }
set { DésignationComposant = value; }
}

public float pPrixComposant


{
get { return PrixComposant; }
set { PrixComposant = value; }
}

public Constructeur pconstructeur


{
get { return constructeur; }
set { constructeur = value; }
}

public new string ToString()


{
return constructeur.pRaisonSocialeConstructeur + " " + RéfComposant + " " + DésignationComposant + ".";
}
}

 Classe "Intégration"

using System;

public class Intégration


{
private Composant ComposantIntégré;
private uint QuantitéIntegrée;

public Intégration(Composant ComposantIntégré, uint QuantitéIntegrée)


{
this.ComposantIntégré = ComposantIntégré;
this.QuantitéIntegrée = QuantitéIntegrée;
}

public Composant pComposantIntégré


{
get { return ComposantIntégré; }
set { ComposantIntégré = value; }
}

public uint pQuantitéIntegrée


{
get { return QuantitéIntegrée; }
set { QuantitéIntegrée = value; }
}

public new string ToString()


{
return QuantitéIntegrée + "x " + ComposantIntégré.ToString();
}
}

 Classe "Produit"

using System;
using System.Collections.Generic;

public class Produit


{
private string RéfProduit;
private string DésignationProduit;
protected float PrixProduit;
private Système système;
private List<Intégration> Composants_intégrés;

public Produit(string RéfProduit, string DésignationProduit, Système système)

Filière Epreuve Session 9/13


TDI Synthèse V2(Correction) Juillet 2014
{
this.RéfProduit = RéfProduit;
this.DésignationProduit = DésignationProduit;
this.système = système;
Composants_intégrés = new List<Intégration>();
}

public string pRéfProduit


{
get { return RéfProduit; }
set { RéfProduit = value; }
}

public string pDésignationProduit


{
get { return DésignationProduit; }
set { DésignationProduit = value; }
}

public float pPrixProduit


{
get { return PrixProduit; }
}

public Système psystème


{
get { return système; }
set { système = value; }
}

public List<Intégration> pComposants_intégrés


{
get { return Composants_intégrés; }
set { Composants_intégrés = value; }
}

public void IntégrerComposant(Intégration composant_intégré)


{
bool existe = false;
foreach (Intégration ci in Composants_intégrés)
if (ci.pComposantIntégré.pRéfComposant == composant_intégré.pComposantIntégré.pRéfComposant) existe = true;
if (!existe) Composants_intégrés.Add(composant_intégré);
else throw new Exception("Composant déjà intégré !");

public void EnleverComposant(string référence_composant)


{
bool existe = false;
foreach (Intégration ci in Composants_intégrés)
if (ci.pComposantIntégré.pRéfComposant == référence_composant)
{ existe = true; Composants_intégrés.Remove(ci); break; }
if (!existe) throw new Exception("Référence Composant inexistante !");

public virtual void CalculerPrix()


{
foreach (Intégration ci in Composants_intégrés)
PrixProduit+=ci.pComposantIntégré.pPrixComposant * ci.pQuantitéIntegrée;
PrixProduit += système.pPrixSystème;
PrixProduit *= 1.2F;
}

public new virtual string ToString()


{
string chaîne = "";
foreach (Intégration ci in Composants_intégrés) chaîne += ci.ToString() + "\n";
return RéfProduit + " " + DésignationProduit + " " + PrixProduit + " DH.\n" + chaîne + système.ToString() + "\n" ;
}
}

 Classe "Pilote"

using System;

Filière Epreuve Session 10/13


TDI Synthèse V2(Correction) Juillet 2014
using System.Collections.Generic;

public class Pilote


{
private string RéfPilote;
private string DésignationPilote;
private List<Composant> Composants_compatibles;
private List<Système> Systèmes_compatibles;

public Pilote(string RéfPilote, string DésignationPilote)


{
this.RéfPilote = RéfPilote;
this.DésignationPilote = DésignationPilote;
Composants_compatibles = new List<Composant>();
Systèmes_compatibles = new List<Système>();
}

public string pRéfPilote


{
get { return RéfPilote; }
set { RéfPilote = value; }
}

public string pDésignationPilote


{
get { return DésignationPilote; }
set { DésignationPilote = value; }
}

public List<Composant> pComposants_compatibles


{
get { return Composants_compatibles; }
set { Composants_compatibles = value; }
}

public List<Système> pSystèmes_compatibles


{
get { return Systèmes_compatibles; }
set { Systèmes_compatibles = value; }
}

public void AjouterComposant(Composant composant)


{
bool existe = false;
foreach (Composant c in Composants_compatibles)
if (c.pRéfComposant == composant.pRéfComposant) existe = true;
if (!existe) Composants_compatibles.Add(composant);
else throw new Exception("Composant existant !");
}

public void AjouterSystème(Système système)


{
bool existe = false;
foreach (Système c in Systèmes_compatibles)
if (c.pRéfSystème == système.pRéfSystème) existe = true;
if (!existe) Systèmes_compatibles.Add(système);
else throw new Exception("Système existant !");
}

public new string ToString()


{
string chaîne = "Composants compatibles:\n";
foreach (Composant c in Composants_compatibles) chaîne += c.ToString() + "\n";
chaîne += "\nSysèmes compatibles:\n";
foreach (Système s in Systèmes_compatibles) chaîne += s.ToString() + "\n";
return RéfPilote + " " + DésignationPilote + ".\n\n" + chaîne ;
}
}

 Classe "Produit_Pro"

using System;
using System.Collections.Generic;

public class Produit_Pro : Produit

Filière Epreuve Session 11/13


TDI Synthèse V2(Correction) Juillet 2014
{
private sbyte garantie;
private DateTime date_début_garantie;

public Produit_Pro(string RéfProduit, string DésignationProduit, Système système, sbyte garantie, DateTime
date_début_garantie) : base(RéfProduit, DésignationProduit, système)
{
pgarantie = garantie;
this.date_début_garantie = date_début_garantie;
}

public sbyte pgarantie


{
get { return garantie; }
set
{
if (value > 1 && value <= 5) garantie = value;
else throw new Exception("Garantie invalide !");
}
}

public DateTime pdate_début_garantie


{
get { return date_début_garantie; }
set { date_début_garantie = value; }
}

public override void CalculerPrix()


{
base.CalculerPrix();
base.PrixProduit += 750F * garantie;
}

public DateTime Fin_garantie()


{
return date_début_garantie.AddYears(garantie);
}

public void Etendre_garantie(sbyte nombre_années)


{
pgarantie = (sbyte) (garantie + nombre_années);
}

public override string ToString()


{
return base.ToString() + "Garantie: " + garantie + " ans de " + date_début_garantie.ToShortDateString() + " à
" + Fin_garantie().ToShortDateString() + ".";
}
}

Filière Epreuve Session 12/13


TDI Synthèse V2(Correction) Juillet 2014
 Dossier 3: Programmation événementielle
 Indication 1: Dans ce dossier, on demande de donner uniquement le code à mettre à l’intérieur des
méthodes événementielles. La syntaxe des méthodes événementielles n’est pas demandée !

1- Code du titre du formulaire:

2- Code d’affichage de la liste des composants:

3- Code du bouton "Supprimer":

4-
BinaryFormatter f = new BinaryFormatter();
FileStream fs = new FileStream("ComposantPowerspeed.dat",
FileMode.OpenOrCreate, FileAccess.Write);
f.Serialize(fs, ci.pComposants_integres);
fs.Close();

Filière Epreuve Session 13/13


TDI Synthèse V2(Correction) Juillet 2014