Sommaire - نيابة الحسيمة · L’octal est le codage en base 8. Suivant le même...

Système de numération & Algorithme avec exercices d’application

Réaliser par: Mohammed Harrar 2004/2005 1

Sommaire

Chapitre 1 Système de numération

I. Introduction -------------------------------------- ------------------------------------ 2 a. Codage binaire --------------------------------------------------------- 2 b. Représentation des informations ------------------------------------ 4

1. Instructions ------------------------------------------------------ 4 2. Les données ----------------------------------------------------- 4 3. Données numériques ------------------------------------------- 5

c. Problème de logique -------------------------------------------------- 5 II. Algèbre de Boole --------------------------------------------------------------------- 6

a. Variables et fonctions booléennes ---------------------------------- 6 b. Tableau de vérité ------------------------------------------------------ 7 c. Opérateurs logiques --------------------------------------------------- 7 d. Théorie de Morgan ---------------------------------------------------- 8 e. Simplification d'une fonction logique ------------------------------ 9

Chapitre2 Algorithme

I. Définition ----------------------------------------------------------------------------- 10 a. Séquences d'instructions ----------------------------------------------- 10 b. L'affectation ------------------------------------------------------------- 10 c. Les opérations ----------------------------------------------------------- 10 d. Dialogue avec l'utilisateur --------------------------------------------- 11

II. Les structures alternatives -------------------------------------------------------- 12 III. Les structures répétitives --------------------------------------------------------- 13

i. Le tant que --------------------------------------------------------------- 13 ii. Faire jusqu'à ------------------------------------------------------------- 14 iii. Pour ----------------------------------------------------------------------- 14

IV. Les tris -------------------------------------------------------------------------------- 15 a. Tri par sélection ------------------------------------------- 15 b. Tri par boule ----------------------------------------------- 15 c. Tri par permutation --------------------------------------- 16 d. Recherche dichotomique--------------------------------- 16

V. Déclarations des variables -------------------------------------------------------- 16 a. Les types --------------------------------------------------- 16 b. Les tableaux ----------------------------------------------- 17 c. Procédure et fonction ------------------------------------- 18 d. Règles d'écritures ----------------------------------------- 19

VI. Exercice ------------------------------------------------------------------------------ 20



Chapitre1

SYSTEME DE NUMERATION I. Introduction:

Quelque soit les informations manipulées par l’ordinateur, celles-ci sont codés en binaire ç.à.d à base de 0 ou 1. Un chiffre de 0 ou 1 est appelé bit (binary digit) Les informations, manipulées par l’ordinateur, sont traduites en une partie de bit et dit qu’elles sont codées en binaire. 1. Codage en binaire : La base 2 : Pour coder un nombre en base 2 il faut le décomposer en une suite de multiple de 2 ç.à.d que l’on va l’écrire sous la forme : X = an * 2

n + a(n-1) * 2(n-1) + … + a1 * 2

1 + a0 * 20

=(an a(n-1) …a1 a0) Exemple : 13 = (1101) = 1 * 23 + 1 * 22 + 0 * 21 + 1 * 20 = 8 + 4 + 0 + 1 57 = (111001) 109 = (1101101) La base octale: L’octal est le codage en base 8. Suivant le même principe en va coder les nombres en une base composée des chiffres allant de 0 à 7. X = X = an * 8

n + a(n-1) * 8(n-1) + … + a1 * 8

1 + a0 * 80

Exemple : (13)10 = (15)8 = 1 * 81 + 5 * 80 = 8 + 5 (57)10 = (71)8

= 7 * 81 + 1 * 80 = 56 + 1 La base hexadécimale : L’hexadécimal est le codage en base 16 on utilise cette fois-ci les chiffres entre 0 et 9 puis les lettres entre A et F, avec : A(10), B(11), C(12), D(13), E(14), F(15). X = an * 16n + a(n-1) * 16(n-1) + … + a1 * 161 + a0 * 160 Exemple : (57)10 = (39)16 (125)10 = (7D)16

Bit de poids fort Bit de poids faible



(167)10 = (A7)8 = 10 * 161 + 7 * 160 Règle de passage de la base 2 ou base 16: B3 B2 B1 B0

0 0 0 0 0 1 0 0 0 1 2 0 0 1 0 3 0 0 1 1 4 0 1 0 0 5 0 1 0 1 6 0 1 1 0 7 0 1 1 1 8 1 0 0 0 9 1 0 0 1 10 1 0 1 0 11 1 0 1 1 12 1 1 0 0 13 1 1 0 1 14 1 1 1 0 15 1 1 1 1 (0001010111011011)2 = (15DB)16 c.a.d on convertit la série binaire on commençant par le bit de poids le plus faible : 1000 = B, 1101 = D, 0101 = 5, 0001 = 1 Opération en binaire : • Addition Règle: 0 + 0 = 0 0 + 1 = 1 1 + 0 = 1 1 + 1 = 0 report de 1 Exemple : 010 1011011 + 110 + 110011

1000 10001110



• Soustraction Règle: 0 – 0 = 0 1 – 0 = 1 1 – 1 = 0 0 – 1 = 1 retenue de 1 Exemple : 101 1010011 - 11 - 111101

010 0010110

2. Représentation des informations 1. instructions: Les instructions exécutables par la machine sont celles contenues dans le jeu d’instructions du processeur. Chacune des ces instructions possède un code opération qui permet de l’identifier, pour chaque instruction on indique également les opérandes. Code opération Opérande L’ensemble est codé sur un nombre de 16 ou 32 bits suivant la machine. 2. Les données: Les données non numériques correspond aux caractères alphanumériques (A….a et 1……9) et aux caractères spécieux (ponctuation et autres) Le codage est utilisé on utilisant une table de conversion : Code ASCII ( American Standard Code for information Interchange) Le code ASCII est celui le plus utilisé dans les ordinateurs d’aujourd’hui tout caractère est codé sur un octet (8 bit). Code EBCDIC (Extended Binary Coded Decimal Interchange Code) Ce code est essentiellement utilisé par IBM et également un code représentant les caractères sur un octet, celui est divisé en deux demi octet de signification différente. 4 bits 4 bits Zone Numérique Type de caractères Rang du caractère dans le type



3. Données numériques : Pour coder les informations numériques, il existe différent système de codage, suivant la nature des données, l’utilisation que l’on veut faire et la précision souhaitée. Entier positif ou nuls : Pour coder un entier positif ou nuls on utilise le codage binaire pure. La donnée est stockée dans un mot mémoire. Suivant la machine un mot mémoire à une taille variable de généralement 16 bits mais ça meut être aussi sur certains machines de 8 bits, 32 bits (Pentium) soit 64 bits (machine scientifique) Entier négatif Pour coder un entier négatif (signé), on procède de la même façon sauf que l’on n’utilise pas le premier bit de mot, celui est réservé pour le codage du signe. 1 Négatif 0 Positifs Exemple : +2 (00000010)2 -2 (10000010)2 3. Problème de logique: Problème1 : Condition d’atterrissage d’un avion : Le train d’atterrissage est sortie (A) et le terrain est dur (B) ou le terrain a mouillé et il ne pleut pas. Et l’avion moindre de 50 places (D) ou l’avion à plus de 50 places et sa vitesse est inférieur de à 150(E). Et sa vitesse inférieure 150 (E). Et peut être remplacer par * (produit logique) Ou peut être remplacer par + (somme logique) Problème2 : Une compagne d’assurance désire proposer à certains de ces clients une proposition qu’elle juge plus avantageuse. Mais pour recevoir la proposition et pour souscrire il faut remplir l’une des 6 conditions suivantes : Premier condition : avoir souscrire la police vie (cond V)

Être de sexe masculin (M) Etre marié (E) (épouse ou époux) Etre âgé de 25 ans au moins (non-j)

Deuxième condition : ne pas avoir la police vie Etre de sexe féminin et être marié Troisième condition : être célibataire, être de sexe masculin et être âgée de 25 ou moins



Quatrième condition : être marié et avoir souscrire la police vie Cinquième condition : ne peut avoir souscrire la police vie, être marié et être âgée de 25 ans ou moins Sixième condition : être marié et avoir moins de 25 ans Reformuler les conditions de la proposition. Problème 3 : Une erreur disque est un problème dû à une erreur de disque Un problème matériel est toujours signalé au revendeur Un problème mémoire n’est jamais dû à une erreur disque Un problème mémoire peut être un problème matériel Le micro à un problème mémoire. Répondre par oui, non ou on ne sait pas • Le micro à une erreur de disque • Le problème n’est pas dû à une erreur de disque • Le revendeur a été prévenu • On ne sait rien sur ce que c’est passé

II. ALGEBRE DE BOOLE a. Variables et fonctions booléennes.

On appelle variables booléennes toute quantité capable de prendre deux valeurs 0 et 1. Une fonction booléenne (logique) est une fonction qui dépend de variable logique et qui aussi ne peut avoir que deux valeurs 0 et 1.

b. Tableau de vérité : On appelle table de vérité la table qui permet de présenter la valeur d’une fonction logique en fonction des valeurs des variables logiques. Exemple: A B F(A,B) A B C F(A,B,C) 0 0 0 0 0 0 0 0 1 0 0 0 1 0 1 0 0 0 1 0 0 1 1 1 0 1 1 0 1 0 0 0

1 0 1 0 1 1 0 0 1 1 1 1

c. Opérateurs logiques :

Compliment: A F (A) 0 1 F(A) = A 1 0



Et logique (produit logique): A B F(A,B) 0 0 0 1 0 0 F(A,B) = A et B = A * B = AB 0 1 0 1 1 1 Non (et) : A B F(A,B) 0 0 1 1 0 1 F(A,B) = Non (AB) = AB 0 1 1 1 1 0 Ou logique (somme logique) : A B F(A,B) 0 0 0 0 1 1 F(A,B) = A ou B = A + B 1 0 1 1 1 1 Non (ou) : A B F(A,B) 0 0 1 1 0 0 F(A,B) = Non (A ou B) = A + B 0 1 0 1 1 0 Ou exclusif : A B F (A, B) 0 0 0 1 0 1 F (A, B) = A B 0 1 1 1 1 0 Propriétés : A * B = B * A A + B = A +B A (B + C) = AB + AC A * 0 = 0 A + 0 = A A + AB = A * 1 + AB A * 1 = A A + 1 = 1 = A (1 + B) A * A = A A + A = A = A A * A = 0 A + A = 1 A = A A + AB = A + A + AB = A + B (A + A) = A + B * 1 = A + B

+



d. Théorème de Morgan : A * B = A + B A + B = A * B Forme canonique d’une fonction logique : (somme et produit) Example: A B F (A, B) 0 0 0 1 0 1 F (A, B) = A B = A * B + A * B 0 1 1 1 1 0 = AB + AB A B A B A B AB + AB 0 0 0 0 0 0 1 1 0 1 1 0 0 1 1 1 1 0 0 0 A B C F(A,B,C) 0 0 0 1 0 0 1 0 0 1 0 1 0 1 1 0 1 0 0 1 1 0 1 0 1 1 0 1 1 1 1 1 F (A,B,C) = A B C + A B C + AB C + A B C + A B C e. Simplification d’une fonction : Il s’agit de trouver l’expression la plus simple d’une fonction on faisant apparaître le minimum de variables logiques et d’opérateurs. Exemple: F (A, B, C) = C (A B + A B + A B + A B ) + A B C = C ( A ( B + B ) + ( A ( B + B ) + A B C

= C + A B C = C + A B C + A B C

= C + A B

+



Exercice : Dresser la table de vérité d’une fonction logique, comportant les variables A, B et C, dont la valeur n’est que s’il y a un nombre impair de variable égale à 1. Indiqué sa forme canonique et son expression on utilisant l’opérateur logique ou exclusif seulement



Chapitre2

ALGORITHME I. Définition :

Un algorithme est une suite d’action que devra effectuer un automate pour arriver, en un temps fini, à un résultat déterminer et à partir d’une situation donnée. Cette suite d’instruction (action) sera composée d’actions élémentaires nous allons utiliser un pseudo langage comportant toute les structures de base d’un langage de programmation. Un programme est une suite d’instruction exécuter par la machine, ces instructions peuvent s’enchaîner les unes après les autres. On peut parler alors d’une structure alternative, ou se répète plusieurs fois et on parle d’une structure répétitive.

a. Séquences d’instructions :

Une instruction est une action que l’ordinateur est capable d’exécuter. Chaque langage de programmation fourni une liste d’instructions, qu’on peut utiliser sans les réécrire dans notre pseudo langage. Nous n’avons que la liste minimum d’instructions nécessaires et suffisantes pour les programmes à écrire.

b. L’affectation :

Syntaxe : Variable Variable Variable Variable ValeurValeurValeurValeur Ce qui se lie variable reçoit valeur et qui signifier que l’on mémorise la valeur à un endroit nommé variable. Exemple : I 1 A " toto" C B/A test vrai

c. Les opérations:

Variable Variable Variable Variable Valeur 1 + Valeur 2Valeur 1 + Valeur 2Valeur 1 + Valeur 2Valeur 1 + Valeur 2 Variable Variable Variable Variable Valeur 1 * Valeur 2Valeur 1 * Valeur 2Valeur 1 * Valeur 2Valeur 1 * Valeur 2 Variable Variable Variable Variable Valeur 1 Valeur 1 Valeur 1 Valeur 1 ---- Valeur 2Valeur 2Valeur 2Valeur 2 Variable Variable Variable Variable Valeur 1 * Valeur 2Valeur 1 * Valeur 2Valeur 1 * Valeur 2Valeur 1 * Valeur 2 Remarque : On doit toujours affecter le résultat d'une opération dans une variable.



d. Dialogue avec l'utilisateur:

Pour permettre ou programme de dialoguer avec l'utilisateur, afficher un résultat et lire une entrée au clavier, il faut au moins deux instructions, une pour lire et l'autres pour afficher, dans le pseudo langage. S'écrit ainsi: Lire VariableLire VariableLire VariableLire Variable Affiche texte VariableAffiche texte VariableAffiche texte VariableAffiche texte Variable La première lie tous les caractères qui sont saisie au clavier, jusqu'à ce que l'utilisateur appui sur la touche entrée, et stock le résultat dans une variable. La seconde affiche sur l'écran le ou les textes et la valeur des variables. Exemple: Afficher " qu'il est ton nom"Afficher " qu'il est ton nom"Afficher " qu'il est ton nom"Afficher " qu'il est ton nom" Lire nom_utilisateurLire nom_utilisateurLire nom_utilisateurLire nom_utilisateur Afficher "ton nom est:" nom_utlisateurAfficher "ton nom est:" nom_utlisateurAfficher "ton nom est:" nom_utlisateurAfficher "ton nom est:" nom_utlisateur Exercice: Ecrire un algorithme qui permet de résoudre l'équation de premier degré: A * x + B = 0 Réponse: DébDébDébDébut ut ut ut Variable A, B, X.Variable A, B, X.Variable A, B, X.Variable A, B, X. Afficher " donner la valeur de A" Lire A Afficher " donner la valeur de B" Lire B X X X X ---- B/AB/AB/AB/A Afficher " X = ", XAfficher " X = ", XAfficher " X = ", XAfficher " X = ", X FinFinFinFin Exercice: Ecrire un algorithme qui lie deux réels a et b, différents de zéro, et affiche leur somme, leur produit, leur soustraction et leur division. DébutDébutDébutDébut Variable A, B, Som, Prod, Div, Sous.Variable A, B, Som, Prod, Div, Sous.Variable A, B, Som, Prod, Div, Sous.Variable A, B, Som, Prod, Div, Sous.



Afficher " donner un nombre A"Afficher " donner un nombre A"Afficher " donner un nombre A"Afficher " donner un nombre A" Lire ALire ALire ALire A Afficher " donner un nombre B"Afficher " donner un nombre B"Afficher " donner un nombre B"Afficher " donner un nombre B" Lire BLire BLire BLire B Som Som Som Som A + BA + BA + BA + B Prod Prod Prod Prod A * BA * BA * BA * B Div Div Div Div A / BA / BA / BA / B Sous Sous Sous Sous A A A A ---- BBBB Afficher " somme de A et B", SomAfficher " somme de A et B", SomAfficher " somme de A et B", SomAfficher " somme de A et B", Som Afficher "Afficher "Afficher "Afficher " produit de A et B", Prodproduit de A et B", Prodproduit de A et B", Prodproduit de A et B", Prod Afficher " division de A et B", DivAfficher " division de A et B", DivAfficher " division de A et B", DivAfficher " division de A et B", Div Afficher " soustraction de A et B", SousAfficher " soustraction de A et B", SousAfficher " soustraction de A et B", SousAfficher " soustraction de A et B", Sous FinFinFinFin II. La structure alternative:

Il souvent nécessaire, lorsqu'on écrit un programme, de distinguer plusieurs cas conditionnant l'exécution de tel ou tel instructions. Pour cela on utilise une structure alternative: si on est dans tel cas alors on fait cela sinon on fait ceci. Syntaxe: Si condition alorsSi condition alorsSi condition alorsSi condition alors ActionsActionsActionsActions [Sinon Actions][Sinon Actions][Sinon Actions][Sinon Actions] Fin siFin siFin siFin si Commentaire:

• L'accroché signifie que Sinon Actions Sinon Actions Sinon Actions Sinon Actions est facultative.

• Pour exprimer des conditions, on utilise les opérateurs conditionnels suivants: =, <>, <, >, >=, <= et <>.

• On peut combiner les conditions à l'aide des opérateurs logique: et, ou, non et ou exclusif. Exemple: A<2 et ((B = 0) ou (C <> A))

• Lorsqu'on écrit un tel condition, il commandé de mettre les parenthèses afin d'éviter les erreurs.

• Les actions, qui suivent le sinon ou le alors, peuvent être une simple instruction, une suite d'instructions, une structure alternative ou répétitive.

Exemple: DébutDébutDébutDébut Variable Variable Variable Variable A, Abs.A, Abs.A, Abs.A, Abs.



Afficher " donner un nombre A"Afficher " donner un nombre A"Afficher " donner un nombre A"Afficher " donner un nombre A" Lire ALire ALire ALire A Si A < 0 alorsSi A < 0 alorsSi A < 0 alorsSi A < 0 alors AbsAbsAbsAbs ((((----1) * A1) * A1) * A1) * A Sinon Sinon Sinon Sinon AbsAbsAbsAbs A A A A Fin siFin siFin siFin si Fin.Fin.Fin.Fin.

III. Structure répétitive:

Un programme à presque toujours un rôle de répéter la même action, un certain nombre de fois, pour ce faire on utilise une structure permettant de dire: exécuter tel action jusqu'à tel conditions soit remplis. Bien qu'une seule soit nécessaire la plus part des langages de programmation propose trois types de structure répétitive.

1. Le tant que:

Syntaxe: Tant que conditiTant que conditiTant que conditiTant que conditions faire ons faire ons faire ons faire InstructionsInstructionsInstructionsInstructions Fin tant queFin tant queFin tant queFin tant que Exercice: Ecrire l'algorithme qui affiche la somme des 10 entiers. Réponse: DébutDébutDébutDébut Variable Compteur, Somme.Variable Compteur, Somme.Variable Compteur, Somme.Variable Compteur, Somme. CompteurCompteurCompteurCompteur 1111



Somme Somme Somme Somme 0000 Tant que compteur <= 10 faireTant que compteur <= 10 faireTant que compteur <= 10 faireTant que compteur <= 10 faire Compteur Compteur Compteur Compteur Compteur + 1Compteur + 1Compteur + 1Compteur + 1 Somme Somme Somme Somme Somme + CompteSomme + CompteSomme + CompteSomme + Compteurururur Fin tant que Fin tant que Fin tant que Fin tant que Afficher " la somme est:", SommeAfficher " la somme est:", SommeAfficher " la somme est:", SommeAfficher " la somme est:", Somme FinFinFinFin Remarque: On peut regrouper plusieurs variables sous un même nom, chacune étant alors repérer par un numéro (indice), si ce qu'on appelle un tableau. On peut faire un tableau avec n'importe qu'il type de variable. Dans tous les cas le iéme élément d'un tableau T sera adressé par T[i]. Exercice: Ecrire un algorithme qui affiche la somme et la moyenne des 10 entiers. Réponse: DébutDébutDébutDébut VariableVariableVariableVariable Somme, i, T[i], moyenne.Somme, i, T[i], moyenne.Somme, i, T[i], moyenne.Somme, i, T[i], moyenne. SomSomSomSommemememe 0000 i i i i 1111 Tant quTant quTant quTant que i <= 10 fairee i <= 10 fairee i <= 10 fairee i <= 10 faire Afficher " donner T[i]"Afficher " donner T[i]"Afficher " donner T[i]"Afficher " donner T[i]" Lire T[i]Lire T[i]Lire T[i]Lire T[i] i i i i i + 1i + 1i + 1i + 1 Fin tant queFin tant queFin tant queFin tant que Tant que i <= 10 faireTant que i <= 10 faireTant que i <= 10 faireTant que i <= 10 faire Somme Somme Somme Somme SSSSomme + T[i]omme + T[i]omme + T[i]omme + T[i] i i i i i + 1i + 1i + 1i + 1 Fin tant queFin tant queFin tant queFin tant que



mmmmoyenneoyenneoyenneoyenne SomSomSomSommmmme / ie / ie / ie / i Afficher " Somme est:", somme; "moyenne est:", moyenneAfficher " Somme est:", somme; "moyenne est:", moyenneAfficher " Somme est:", somme; "moyenne est:", moyenneAfficher " Somme est:", somme; "moyenne est:", moyenne Fin tant queFin tant queFin tant queFin tant que 2. Le faire jusqu'à:

Syntaxe: Faire Faire Faire Faire ActionsActionsActionsActions Jusqu'à conditions.Jusqu'à conditions.Jusqu'à conditions.Jusqu'à conditions. Se qui signifier que les actions sont exécutées jusqu'à ce que la condition soit remplie (vraie). Exemple: i i i i 1111 Faire Faire Faire Faire Lire T[i]Lire T[i]Lire T[i]Lire T[i] i i i i i + 1i + 1i + 1i + 1 Jusqu'à i> 10Jusqu'à i> 10Jusqu'à i> 10Jusqu'à i> 10

3. le pour: Très souvent on utilise une structure répétitive, avec un compteur, et on s'arrête lorsque le compteur atteint sa valeur finale. C'est pourquoi la plus part des langage de programmation offre une structure permettent de décrire cette répétitive plus simplement.

La syntaxe: Pour Pour Pour Pour variable allant de allant de allant de allant de valeur initiale to to to to valeur finale [Pas [Pas [Pas [Pas valeur de pas]]]] ActionsActionsActionsActions Fin pourFin pourFin pourFin pour Exemple: Pour i allant de 1 à 10 Pour i allant de 1 à 10 Pour i allant de 1 à 10 Pour i allant de 1 à 10



Lire T[i]Lire T[i]Lire T[i]Lire T[i] Fin pourFin pourFin pourFin pour

IV. Les tris:

Dans les exemples qui suivent on étudie différent algorithme permettant de trier un tableau de 10 entiers. On prendra comme exemple le tableau suivant: T: 52 4 31 1 88 45 11 48 0 25

a. Le tri par sélection:

Principe:

Le premier algorithme auquel on pense pour effectuer ce tri est celui-ci: On cherche le plus petit élément du tableau, et on le place en premier, puis on cherche le plus petit élément de ce qui reste et le met en second, et continue jusqu'à ce que le tableau soit trie. Travail à faire: Ecrire un algorithme qui permet de réaliser ce tri.

b. Le tri par boule: Principe: Faire remonter petit à petit un élément trop grand vers le haut de tableau, on comparant les élément 2 à 2, si l'élément de gauche est supérieur à son voisin de droite on les inverses et continue avec le suivant. Lorsqu'on est haut du tableau on repart au début et on s'arrête lorsque tous les éléments sont bien placés. Travail à faire: Ecrire un algorithme qui permet de réaliser ce tri.

c. Le tri par permutation:

Principe: Le tri par permutation est le tri de jeu de carte. On parcours le tableau jusqu'à ce que l'on trouve un élément plus petit que le précédant, donc mal placé, on prend cette élément et le ronge à sa place dans le tableau, puis on continue la lecture. Et on s'arrête à la fin de tableau. Travail à faire:



Ecrire un algorithme qui permet de réaliser ce tri.

d. La recherche Dichotomique: Principe: Cet algorithme permet de ranger un élément à sa place, dans un tableau, ou de le trouver dans celui-ci de manière très rapide. On considère une liste de 10 entiers. On cherche, dans cette liste, la place d'un nombre x comme suivant: On compare x à l'élément du milieu de tableau, s'il est inférieur à celui on réduit le tableau à sa patrie gauche, sinon on le réduit à sa partie droite. On répète l'opération jusqu'à ce que le tableau et moins de deux éléments. Travail à faire: Ecrire un algorithme qui permet de réaliser ce tri.

V. Déclaration des variables:

Un programme exécutable est composé de deux parties données et instruction. La partie instruction contient les instructions a exécuté, la partie données contient toutes les variables utiliser par le programme. Un programme exécutable est chargé dans la mémoire centrale de l'ordinateur. Les valeurs, qu'on affecte aux variables, doivent être conservé tout le temps de déroulement du programme. Il faut que le programme soit capable de réserver la place nécessaire aux variables, pour ce faire les variables doivent être déclaré, afin que le langage sache quelles places elles vont occupées.

a. Les types:

Les variables, que l'on utilise dans le programme, ne sont pas tous de même nature. Il est nécessaire de donner un type aux variables, car cela permet, permet d'une part de contrôler leur utilisations (exemple on ne peut pas deviser un caractère par un entier), d'autre part il faut indiquer quelle place a réservé à la variable.

• Entiers: Il s'agit des variables destinées à contenir un nombre entier positif ou négatif, dans notre pseudo langage on écrira la déclaration des variables de type entiers :

Entier variable1, variable2,. . .Entier variable1, variable2,. . .Entier variable1, variable2,. . .Entier variable1, variable2,. . .

Remarque: Généralement un entier occupe deux octets. Certains langages distinguent les entiers courts (un octet), les entiers longs (4 octets) et les entiers simples (2 octets).

• Réel:



Il s'agit des variables numériques qui ne sont pas des entiers longs (qui comportent des décimales). Réel variaRéel variaRéel variaRéel variable1, variable2,. . .ble1, variable2,. . .ble1, variable2,. . .ble1, variable2,. . .

• Les caractères: Les variables de type caractères contiennent des caractères alphanumériques (alphabétiques ou numériques). On ne peut pas faire des opérations au dessus: CCCCar variable1, variable2,. . .ar variable1, variable2,. . .ar variable1, variable2,. . .ar variable1, variable2,. . .

• Les booléen: Il souvent nécessaire lorsqu'on écrit un programme d'introduire les variables, qui prennent les valeurs vrai ou faux. On écrira: Boolien variable1, variable2,. . .Boolien variable1, variable2,. . .Boolien variable1, variable2,. . .Boolien variable1, variable2,. . .

b. Les tableaux:

On peut regrouper plusieurs variables sous un même nom, chacune étant repérée par un numéro (indice), c'est ce qu'on appelle un tableau. On peut faire un tableau avec des variables de n'importe qu'il type, dans tous les cas le iéme élément d'un tableau appelé Tab, et sera

adressé par Tab[i]Tab[i]Tab[i]Tab[i]. Généralement on fait des tableaux à une dimension, mais il existe des

tableaux à deux dimensions dans ce cas on écrit: Tab[i,j]Tab[i,j]Tab[i,j]Tab[i,j] représente le iéme ligne et le jéme colonne. Tableau type variable [longueur]Tableau type variable [longueur]Tableau type variable [longueur]Tableau type variable [longueur] Exemple: Tableau Car mot [10] Tableau Entier liste [25] Tableau Car mots [10][15]

c. Procédure et Fonction: Lorsque l'algorithme devient trop compliqué, on aura envie de le décomposer de manière à ce que chaque partie soit plus simple et visible, de même lorsqu'une partie de code doit être exécuter plusieurs fois à des endroits différents ou réutiliser ultérieurement. On pourra l'écrire et lui donner un nom on faisant une fonction ou une procédure. • Procédure:

Une procédure est une suite d'instructions servant à réaliser une tâche précise en fonction d'un certains nombres de paramètres. Les paramètres sont de deux types, il y a des paramètres de



type ValValValVal (contient une valeur qui sera utilisé dans la procédure) et les paramètres de types VarVarVarVar (qui représente une variable de programme et qui pourra être lue et modifié s'il est nécessaire). Dans notre pseudo langage une procédure se déclare de la manière suivante: Procédure Procédure Procédure Procédure nom_de_la_nom_de_la_nom_de_la_nom_de_la_procédure (val type nom, type nom, var type nom, type nom,. procédure (val type nom, type nom, var type nom, type nom,. procédure (val type nom, type nom, var type nom, type nom,. procédure (val type nom, type nom, var type nom, type nom,. . .). .). .). .) Déclarations des variables localesDéclarations des variables localesDéclarations des variables localesDéclarations des variables locales DébutDébutDébutDébut Instructions ou actionsInstructions ou actionsInstructions ou actionsInstructions ou actions FinFinFinFin Les variables que l'on déclare localement à la procédure ne sont pas connues que dans cette procédure. L'utilisation de la procédure dans le programme se fait simplement par l'appelle de celle-ci on utilisant la syntaxe suivante: NomNomNomNom_de_la__de_la__de_la__de_la_procédure (valeur1, valeur2,. . .)procédure (valeur1, valeur2,. . .)procédure (valeur1, valeur2,. . .)procédure (valeur1, valeur2,. . .)

• Fonction:

Une fonction est une procédure dont le but est de déterminer une valeur, et de la retourner dans au programme appellent. Dans notre pseudo langage, elle se déclare de la manière suivante: FFFFonction nom_de_la_fonction (val type nom, type nom, var type nom, type nomonction nom_de_la_fonction (val type nom, type nom, var type nom, type nomonction nom_de_la_fonction (val type nom, type nom, var type nom, type nomonction nom_de_la_fonction (val type nom, type nom, var type nom, type nom,. . .),. . .),. . .),. . .) Déclarations des variables localesDéclarations des variables localesDéclarations des variables localesDéclarations des variables locales DébutDébutDébutDébut Instructions ou actionsInstructions ou actionsInstructions ou actionsInstructions ou actions Retourne valeurRetourne valeurRetourne valeurRetourne valeur FinFinFinFin Il faut noter que la fonction retourne une valeur, et que donc, à la déclaration, on doit indiquer son type (c'est-à-dire le type de cette valeur). L'appelle d'une fonction s'écrit: Variable Variable Variable Variable nom_de_la_fonction(valeur1, valeur2,. . .)nom_de_la_fonction(valeur1, valeur2,. . .)nom_de_la_fonction(valeur1, valeur2,. . .)nom_de_la_fonction(valeur1, valeur2,. . .)

d. règle d'écriture:



Un programme doit être le plus visible possible, de manière à ce que n'importe qui d'autre, que l'auteur, soit capable de comprendre facilement de quoi il s'agit. Il faut suivre quelques règles suivantes:

• le nom des variable doit être significatif (c'est-à-dire clairement à quoi il sert). • Un algorithme ne doit pas être long, s'il est long il faut le découper en

fonctions et procédures. • Les structures de contrôles doivent être claire. Par exemple les instructions, qui

suivrent le alors, doivent être toutes alignées et décaler d'une tabulation par rapport au si : Si condition alorsSi condition alorsSi condition alorsSi condition alors ActionsActionsActionsActions Fin siFin siFin siFin si

Il est de même en structure répétitive. • A chaque imbrication d'une structure de contrôle on décale d'une tabulation: Si condition alorsSi condition alorsSi condition alorsSi condition alors ActionsActionsActionsActions Sinon Sinon Sinon Sinon SiSiSiSi condition alorscondition alorscondition alorscondition alors ActionsActionsActionsActions SinonSinonSinonSinon ActionsActionsActionsActions Fin siFin siFin siFin si Fin si Fin si Fin si Fin si

En ce qui concerne les fonctions et les procédures, il y a aussi des règles à respecter, on donnant des noms significatifs à celles-ci.

• Le nombre de paramètres ne doit pas être trop grand (en générale inférieure à 5).

• Une fonction ou une procédure doit être la plus générale possible de manière à pouvoir la réutiliser dans d'autres circonstances.

• Si le but d'une procédure est de calculer une valeur simple, il est préférable d'en faire une fonction.

Algorithme : partie application Structure alternative

Exercice 1 Ecrire un algorithme qui permet de résoudre l’équation du premier degré a* x + b = 0 Exercice 2 Ecrire un algorithme qui permet de calculer le salaire net d’un employé sachant que



SB = salaire brut, SN = salaire net, CH = charge, TH = taux horaire, NBF= nombre d’enfants, PR = prime, TIGR = taux IGR et NBH = nombre d’heures. SN = SB – CH SB = NBH * TH + PR PR = 150 * NBF, si le nombre d’enfants est inférieur ou égal à 5, sinon 800DH CH = SB * TIGR TIGR = 17% si SB < 1600 DH 24% si 1600 DH <= SB < 3000 DH 30% si 3000 DH <= SB < 5000 DH 48% si 5000DH <= SB Exercice 3 Ecrire un algorithme qui permet de résoudre l’équation de deuxième degré A * x2 + B * x + c = 0 Exercice 4 Ecrire un algorithme qui permet de lire trois réels et affiche leur maximum, leur minimum et leur moyenne. Exercice 5 Un patron décide de calculer le montant de participation au prix du repas de ses employés de la façon suivante : S’il est célibataire participation 20% S’est marie participation 25% S’il a des enfants participation de 10% supplémentaire par enfants La participation est plafonnée à 50% Ecrire l’algorithme qui permet de lire les données au clavier et affiche pour un salarié, lé participation à laquelle il a le droit.

Structure répétitive et tableaux

Exercice 1 Ecrire un algorithme qui permet de lire 10 réels et affiche leurs : • Somme • Moyenne • Maximum • Minimum

Exercice 2 Ecrire un algorithme qui permet de lire un entier N et affiche son factoriel Rappel Pour calculer le factoriel de N, on admet la formule suivante : 0 ! = 1 N ! = N * ( N – 1) * ( N – 2 )* … * 2 * 1



Exercice 3 Ecrire un algorithme qui permet de : Lire un entier N la taille d’un tableau Charge les N réels dans le tableau Calcule et affiche le maximum, le minimum, et la moyenne des N réels du tableau

Exercice 3 Ecrire un algorithme qui permet de :

1. Lire un entier N (taille du tableau) et charge les N réels dans le tableau 2. Lire un entier X 3. Rechercher X d’une façon séquentielle dans le tableau, affiche son indice dans celui s’il

existe et affiche 0 sinon.

Exercice 5 Refaite l’exercice 4 en utilisant la recherche dichotomique Règle : il s’agit de comparer le nombre X à celui du milieu de tableau, s’il est inférieur à celui on réduit le tableau à sa moitié première, sinon on prend l’autre moitié et en continue la recherche.

Exercice 6 Ecrire un algorithme qui permet de lire un entier positif et le convertir en binaire (la représentation doit être chargé dans un tableau dans le bon ordre )

Exercice 7 Ecrire un algorithme qui permet de convertir une représentation en binaire (charger dans un tableau) en un nombre entier.

Exercice divers

Exercice 1 Ecrire un algorithme qui permet de lire une chaîne de caractères et afficher le nombre de : • De caractères en majuscules de la chaîne • De caractères minuscules de la chaîne • Le nombre de chiffres de la chaîne • Le nombre des autres caractères de la chaîne On dispose de deux fonctions suivantes : 1. Longueur (S) : donne la longueur de la chaîne c'est-à-dire nombre de

caractères. 2. Partie (S, Pos, Long) : donne une partie de la chaîne S dont la longueur est

Long et qui commence de la position numéro Pos.

Exercice 2 Ecrire un algorithme qui permet de lire une chaîne de caractères et afficher un message indiquant si la chaîne lue est un entier ou non.

Exercice 3 Ecrire un algorithme qui permet de lire une chaîne de caractères et d’afficher un message indiquant que si la chaîne lue est un réel ou non.



Exercice 4 Ecrire un algorithme qui permet de lire deux entiers positifs et affiche leur PGDC (le Plus Grand Commun de Division)

Exercice 5 Ecrire un algorithme qui lit deux matrices et affiche : • Leur somme • La somme des éléments diagonaux • Leur produit Exercice 6 : Crible d’ERATOSTENE Ecrire un programme qui lit un entier positif N et affiche tous les nombres premiers inférieurs à N. Exercice 7 : jeu du pendu Un joueur choisit un mot de moins de 10 caractères. L’algorithme affiche ------ avec – par lettre Le deuxième joueur propose des lettres jusqu’à ce qu’il ait trouvé le mot où qu’il soit pendu (11 erreurs commises) A chaque proposition, l’algorithme réaffirme le mot avec les lettres découvertes, les lettres déjà annoncées et le nombre d’erreurs.

Sommaire - نيابة الحسيمة · L’octal est le codage en base 8. Suivant le même...

Documents

Transcript of Sommaire - نيابة الحسيمة · L’octal est le codage en base 8. Suivant le même...