Algorithmes et structures de données 4ème cours

Algorithmes et structures de données 4ème cours
Patrick Reuter maître de conférences

Ingrédients d’algorithmes
Affectation (ex. mois := 6) Condition/Comparaison (ex. mois <= 12) Appel de fonction (ex. writeln(mois)) Structure de contrôle Branchements conditionnels (multiples) (si .. Alors .. Sinon) Boucles (tant que .. faire, pour .. faire) Bloc d’instructions (begin .. end)

Aujourd’hui Types de base Type « tableau »

Mémoire vive Proc 64bit 2,93 GHz : 2,93 Giga-Instructions par seconde

Organisation de la mémoire
Un octet peut prendre 28=256 valeurs différentes, entre et 1 kilo-octet (ko ou Ko) = 210 octets = 1 024 octets (et pas 1 000 octets comme on pourrait le supposer), soit 2 à la puissance 10. 1 méga-octet (Mo) = 220 octets = 1 024 ko = 1 048 576 octets. 1 giga-octet (Go) = 230 octets = 1 024 Mo = 1 073 741 824 octets. 1 téra-octet (To) = 240 octets = 1 024 Go = 1 099 511 627 776 octets.

Mémoire de 512 MegaOctets # # ... #1.000 ... #5 #4 #3 #2 #1 #0 # : adresse dans la mémoire vive

Déclaration de variables
Préparation : La veille, mettez les pois chiches dans un bol d'eau. Le jour même, roulez le couscous . Si vous utilisez du couscous roulé et séché, rincez-le à l'eau froide, égouttez-le et laissez-le gonfler pendant 30 mn. Coupez la viande en morceaux. Pelez les oignons et coupez-en 1 en morceaux. Lavez et passez les tomates à la moulinette. Mettez la viande dans une marmite et ajoutez les morceaux d'oignon, les tomates ou le concentré de tomate dilué dans 1 verre d'eau, l'huile, le poivre, le piment, la cannelle et du sel. Faites revenir ….. Comme dans un livre de recettes Ingrédients(pour 8-10 personnes) : - 1 kg de couscous roulé - 1 kg de mouton - 1 poignée de pois chiches - 2 oignons secs tomates fraîches ou 1 cuillère. à soupe de concentré de tomate pommes de terre navets carottes courgettes - 1 tranche de courge - 4 cuillères à soupe d'huile - 1/2 cuillère à café de cannelle - 1 pincée de poivre noir - 1/2 cuillère à soupe de piment rouge doux ou de paprika - 1/2 cuillère à soupe de ras-el-hanout - 1 piment rouge sec g de beurre ou 3 cuillères à soupe d'huile - sel

Déclaration de variables
var compteur : integer; var diviseur : float; var c : char; var precision : double; var nom : string; var masculin : boolean; diviseur := 1.1; compteur : = 1; Nom := ‘Gerhard’; Nombre entier Nombre à virgule flottante caractère Nombre à virgule flottante avec double précision Chaîne de caractères VRAI/FAUX

Types de base Type binaire :
Boolean (bool) 1 bit FALSE, TRUE (FAUX, VRAI) Nombre entiers : Unsigned char (byte) 1 Octet 0 à 255 Signed char (byte) 1 Octet à 127 Unsigned integer 4 Octets 0 à Signed Integer 4 Octets à Nombre à virgule flottante : Real (Single, float) 4 Octets -3.4* à 3.4*1038 (7 décimales) Double 8 Octets 1.8 * à 1.8 * (15 décim) Rappel : 1 Octet = 8 bits = 28 possibilités 4 Octets = 32 bits = 232 possibilités

Octet, byte (caractère)
var c : char; (byte) valeurs de Qu’est-ce qu’on peut faire avec un octet ?  Code ASCII (American Standard Code for Information Interchange) 95 caractères imprimables

Octet - Code ASCII

Un octet peut prendre 28=256 valeurs différentes, entre et Octets non- signés : Par exemple :

Octet signé de jusqu’à 127 Valeurs négatives : = -1 à = -128. Valeurs positives : = 0 à = 127 Calculer les valeurs négatives : Prendre le complément Ajouter 1 Exemple: - 65 Complément Ajouter

0, ,231*10^-3 ,866*10^3 1,45 1,45*10^1 … 1,4

mantisse m (entier, sans la ‘virgule’)
exposant e signe s {+1,-1} exposant e 0, ,231*10^-3 ,866*10^3 1,45 1,45*10^1 … 1,4 base b=10 mantisse m (entier, sans la ‘virgule’)

Nombre à virgule flottante
var c : real; (single, double, real, ..) Approximations rationnelles de nombres réels. Les nombres à virgule flottante possèdent un signe s (dans {-1, 1}) une mantisse entière m (parfois appelée significande) un exposant e. s * m * be - Avec b la base de représentation (parfois 2, 10, 16, ou autre) - En faisant varier e, on fait « flotter » la virgule décimale.

Float, single, double, real, .. Approximations rationnelles de nombres réels. Les nombres à virgule flottante possèdent un signe s (dans {-1, 1}) une mantisse entière m (parfois appelée significande) un exposant e. s * m * be Avec b la base de représentation (parfois 2, 16, ou autre) signe exposant mantisse Simple précision (float, 32 bits) 1 bit 8 bits 23 bits Double précision(double,64 bits) 1 bit 11 bits 52 bits Simple précision (b=2): (-1)S * (1 + M/223 ) * 2(E-127) Double précision (b=2): (-1)S * (1 + M/252 ) * 2(E-1023)

Conversion d’un nombre x
Nombre x = (-1)s * m * 2e (base b = 2) signe s : 0 pour positive, 1 pour négative Exposant e: e = └log2 (x)┘ Mantisse m: m = (x/2e – 1) * 223

Conversion d’un nombre x
Rappel : Nombre x = (-1)s * m * 2e (base b = 2) signe s : 0 pour positive, 1 pour négative Exposant e: e = └log2 (x)┘ Mantisse m: m = (x/2e – 1) * 223 Exemple : x = +11,25 Signe s = positive -> 0 binaire Exposant e = └log2 (11,25) ┘ = └3,49 ┘ = 3  = 130 -> binaire Mantisse m = (11,25/23 – 1) * 223 = ) = binaire Solution : pour chiffres négatifs

Float, single, double, real, .. Approximations rationnelles de nombres réels. Les nombres à virgule flottante possèdent un signe s (dans {-1, 1}) une mantisse entière m (parfois appelée significande) un exposant e. s * m * be Limitation : précision limitée qui se traduit par des arrondis qui peuvent s'accumuler de façon gênante.

var lettre : char; ( 1 octet (byte) ) # # ... #1.000 ... #5 #4 #3 #2 #1 #0

var lettre : signed char; lettre := -65; # # ... #1.000 ... #5 lettre #4 191 #3 #2 #1 #0

var lettre1,lettre2,lettre3,lettre4 : char; lettre1 := 60; lettre2 := 80; lettre3 := 50; lettre4 := 30; ... #1.000 ... lettre4 #3 30 lettre3 #2 50 lettre2 #1 80 lettre1 #0 60

var nombre : integer; ... #1.000 ... #5 #4 nombre nombre nombre nombre #0

var nombre : integer; ( 4 byte (octets) ) nombre := 125; # # ... #1.000 ... #5 #4 nombre nombre nombre nombre #0 125 125

var nombre : integer; ( 4 byte (octets) ) nombre := 260; # # ... #1.000 ... #5 #4 nombre nombre 1* *1 nombre 1 nombre #0 4 125

var resultat : REAL; # # ... #1.000 ... #5 #4 resultat resultat resultat resultat #0

Exercice Déclarer le nombre de jours dans chaque mois
Ecrire un algorithme qui compte le nombre de mois à 30 jours

var janvier : byte; var fevrier : byte; var mars : byte; … var decembre : byte; var compteur : integer; janvier := 31; fevrier := 28; mars := 31; avril := 30; decembre := 31; compteur := 0; si janvier = 30 alors compteur := compteur + 1; fin si si fevrier = 30 alors ... si decembre = 30 alors

Type : tableaux (angl. ARRAY)
Déclaration d’une variable de type tableau Définition : var nom_du_tableau : Array[MinDim..MaxDim] of type ; Exemples : var mot : array[0..10] of char; var jours : array[1..12] of char; … structure de données la plus connue structure homogène, chaque élément est du même type de base

Déclaration d’une variable de type tableau var jours : array[1..12] of byte; var mot : array[0..10] of char; Affectation : nom_du_tableau[index] := valeur ; Exemples : jours[1] := 31; jours[2] := 28; … jours[12] := 31; jours[13] Erreur !!! jours[14] Erreur !!!

Exemple d’un algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31;

Exemple d’un algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0;

Exemple d’un algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0;

Exemple d’un algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début Fin

Exemple d’un algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin

Exemple d’un algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »);

Exemple d’un algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1] Jours[2] ... Jours[12] i nombre

Exemple d’un algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1] Jours[2] ... Jours[12] i nombre 31

Exemple d’un algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1] Jours[2] ... Jours[12] i nombre 31 28

Exemple d’un algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1] Jours[2] ... Jours[12] i nombre 31 28 31

Exemple d’un algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1] Jours[2] ... Jours[12] i nombre 31 28 31 1

Exemple d’un algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1] Jours[2] ... Jours[12] i nombre 31 28 31 1 ….

Exemple d’un algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1] Jours[2] ... Jours[12] i nombre 31 28 31 1 2 ….

Exemple d’un algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1] Jours[2] ... Jours[12] i nombre 31 28 31 1 2 3 ….

Exemple d’un algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1] Jours[2] ... Jours[12] i nombre 31 28 31 1 2 3 4 ….

Exemple d’un algorithme sur les tableaux : - compter le nombre de mois avec 30 jours { Déclaration de variables} var jours : array[1..12] of byte; var i, nombre : integer; { Affectation des variables} jours[1] := 31; jours[2] := 28; … jours[12] := 31; {Initialisation} i:=1; nombre := 0; {boucle} Tant que i<=12 faire Début si (jours[i] = 30) alors nombre := nombre + 1; i := i +1; Fin Afficher(« Il y a », nombre, « de mois à 30 jours »); Jours[1] Jours[2] ... Jours[12] i nombre 31 28 31 1 2 3 4 1 ….

var jours : array[1..12] of byte; {12 octets} # # ... jours[12] #2011 ... ... jours[3] #2002 jours[2] #2001 jours[1] #2000 ... #0

Jours[1]:=31; jours[2]:=30; … # # ... jours[12] #2011 31 ... jours[3] #2002 31 jours[2] #2001 28 jours[1] #2000 31 ... #0

var jours : array[1..12] of byte; {12 octets} # # ... jours[12] #2011 31 ... Occupe de la place successive dans la mémoire jours[3] #2002 31 jours[2] #2001 28 jours[1] #2000 31 ... #0

var jours : array[1..12] of byte; {12 octets} # # ... jours[12] #2011 31 ... Occupe de la place successive dans la mémoire jours[3] #2002 31 jours[2] #2001 28 jours[1] #2000 31 ... #0  jours[index] #(2000+index-1)

var jours : array[1..12] of byte; {12 octets} # # ... jours[12] #2011 31 ... jours[3] #2002 31 jours[2] #2001 28 jours[1] #2000 31 ... i #0

structure de données la plus connue structure homogène, chaque élément est du même type de base occupe de la place successive dans la mémoire « random access » = l’accès aux différents éléments se fait à coût égal est donc à un coût constant

Algorithmes et structures de données 4ème cours

Présentations similaires

Présentation au sujet: "Algorithmes et structures de données 4ème cours"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back

Entrer

S'autoriser via un réseau social:

Algorithmes et structures de données 4ème cours

Présentations similaires

Présentation au sujet: "Algorithmes et structures de données 4ème cours"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back