Algorithmes et structures de données 4ème cours Patrick Reuter maître de conférences http://www.labri.fr/~preuter

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 00000000 et 11111111. 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.

Organisation de la mémoire Mémoire de 512 MegaOctets #536.870.911 #536.870.910 ... #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 - 3-4 tomates fraîches ou 1 cuillère. à soupe de concentré de tomate - 3-4 pommes de terre - 3-4 navets - 3-4 carottes - 3-4 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 - 100 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 -128 à 127 Unsigned integer 4 Octets 0 à 4294967295 Signed Integer 4 Octets -2147483648 à +2147483647 Nombre à virgule flottante : Real (Single, float) 4 Octets -3.4*10-38 à 3.4*1038 (7 décimales) Double 8 Octets 1.8 * 10-308 à 1.8 * 10308 (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 0..255 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

Organisation de la mémoire Un octet peut prendre 28=256 valeurs différentes, entre 00000000 et 11111111. Octets non- signés : Par exemple : 1 1 0 0 0 1 0 0 128 64 32 16 8 4 2 1

Organisation de la mémoire Octet signé de -128 jusqu’à 127 Valeurs négatives : 1111 1111 = -1 à 1000 0000 = -128. Valeurs positives : 0000 0000 = 0 à 1111 1111 = 127 Calculer les valeurs négatives : Prendre le complément Ajouter 1 Exemple: - 65 01000001 Complément 10111110 Ajouter 1 10111111

0,001231 1,231*10^-3 -9866 -9,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,001231 1,231*10^-3 -9866 -9,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.

Nombre à virgule flottante 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  + 127 = 130 -> 10000010 binaire Mantisse m = (11,25/23 – 1) * 223 = 3407872 ) = 01101000000000000000000 binaire Solution : 0 10000010 01101000000000000000000 pour chiffres négatifs

Nombre à virgule flottante 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.

Organisation de la mémoire var lettre : char; ( 1 octet (byte) ) #536.870.911 #536.870.910 ... #1.000 ... #5 #4 #3 #2 #1 #0

Organisation de la mémoire var lettre : signed char; lettre := -65; #536.870.911 #536.870.910 ... #1.000 ... #5 lettre #4 191 #3 #2 #1 #0

Organisation de la mémoire 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

Organisation de la mémoire var nombre : integer; ... #1.000 ... #5 #4 nombre nombre nombre nombre #0

Organisation de la mémoire var nombre : integer; ( 4 byte (octets) ) nombre := 125; #536.870.911 #536.870.910 ... #1.000 ... #5 #4 nombre nombre nombre nombre #0 125 125

Organisation de la mémoire var nombre : integer; ( 4 byte (octets) ) nombre := 260; #536.870.911 #536.870.910 ... #1.000 ... #5 #4 nombre nombre 1*256 + 4*1 nombre 1 nombre #0 4 125

Organisation de la mémoire var resultat : REAL; #536.870.911 #536.870.910 ... #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

Type : tableaux (angl. ARRAY) 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 !!!

Type : tableaux (angl. ARRAY) 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;

Type : tableaux (angl. ARRAY) 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;

Type : tableaux (angl. ARRAY) 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;

Type : tableaux (angl. ARRAY) 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

Type : tableaux (angl. ARRAY) 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

Type : tableaux (angl. ARRAY) 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 »);

Type : tableaux (angl. ARRAY) 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

Type : tableaux (angl. ARRAY) 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

Type : tableaux (angl. ARRAY) 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

Type : tableaux (angl. ARRAY) 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

Type : tableaux (angl. ARRAY) 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

Type : tableaux (angl. ARRAY) 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

Type : tableaux (angl. ARRAY) 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 ….

Type : tableaux (angl. ARRAY) 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 ….

Type : tableaux (angl. ARRAY) 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 ….

Type : tableaux (angl. ARRAY) 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 ….

Type : tableaux (angl. ARRAY) 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 ….

Type : tableaux (angl. ARRAY) 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 ….

Type : tableaux (angl. ARRAY) 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 ….

Type : tableaux (angl. ARRAY) 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 ….

Type : tableaux (angl. ARRAY) 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 ….

Type : tableaux (angl. ARRAY) 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 ….

Type : tableaux (angl. ARRAY) 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 ….

Type : tableaux (angl. ARRAY) 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 ….

Organisation de la mémoire var jours : array[1..12] of byte; {12 octets} #536.870.911 #536.870.910 ... jours[12] #2011 ... ... jours[3] #2002 jours[2] #2001 jours[1] #2000 ... #0

Organisation de la mémoire Jours[1]:=31; jours[2]:=30; … #536.870.911 #536.870.910 ... jours[12] #2011 31 ... jours[3] #2002 31 jours[2] #2001 28 jours[1] #2000 31 ... #0

Organisation de la mémoire var jours : array[1..12] of byte; {12 octets} #536.870.911 #536.870.910 ... 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

Organisation de la mémoire var jours : array[1..12] of byte; {12 octets} #536.870.911 #536.870.910 ... 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)

Organisation de la mémoire var jours : array[1..12] of byte; {12 octets} #536.870.911 #536.870.910 ... jours[12] #2011 31 ... jours[3] #2002 31 jours[2] #2001 28 jours[1] #2000 31 ... i #0

Type : tableaux (angl. ARRAY) 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