100exercices en pascal & c

Ecole Normale Supérieure Département d’Informatique Rabat

Encadré par : Mr.Brahim Lamharchi Réalisé par : Benallou Imane

Lazrak Chaïmae

Razzoug Milouda

Année universitaire : 2003 / 2004

A l’occasion de la présentation de ce travail,

nous tenons à exprimer notre gratitude et notre reconnaissance à Mr .

Brahim Lamharchi, notre encadrant de projet de fin d’étude à l’Ecole Normale

Supérieure de Rabat pour les conseils qu’il nous a

prodigués tout au long de ce travail.

Nous adressons également nos sincères remerciements

Sommaire

Sommaire

Introduction..........................................................................................................................1

Éléments de base d’un programme en Pascal et en C.........................................................3

I- Structure d’un programme...............................................................................................3

I-1. En langage Pascal..................................................................................................3

I-2. En langage C.........................................................................................................4

II- Types de données............................................................................................................4

II-1. Variables et constantes........................................................................................4

II-1.1 Les variables..................................................................................................4

II-1.2 Les constantes................................................................................................6

II-2. Les types de base.................................................................................................7

II-2.1 En langage Pascal..........................................................................................7

II-2.2 En langage C..................................................................................................8

II-3. Créer un type de donnée......................................................................................8

II-3.1 En langage Pascal..........................................................................................8

II-3.2 En langage C..................................................................................................9

III- Opérateurs et expressions..............................................................................................9

III-1. En langage Pascal...............................................................................................9

III-2. En langage C....................................................................................................11

IV- Instructions simples.....................................................................................................14

IV-1. Instruction d’entrée..........................................................................................14

IV-2. Instructions de sortie........................................................................................16

IV-3. Instruction d’affectation...................................................................................17

V- Enoncé des exercices....................................................................................................18

Structures de traitement alternatives et itératives..............................................................19

I- Instructions conditionnelles...........................................................................................19

II- Instructions répétitives..................................................................................................21

III- Enoncé des exercices...................................................................................................22

Notion de sous-programmes..............................................................................................26

I. En langage Pascal...........................................................................................................26

I.1 Les procédures......................................................................................................26

ENS – Rabat – Département d’Informatique

Sommaire

I.2 Les fonctions........................................................................................................27

II- En langage C.................................................................................................................27

III- La récursivité...............................................................................................................29

IV- Enoncé des exercices...................................................................................................29

Les structures de données statiques..................................................................................33

I- Les structures de données homogènes...........................................................................33

II- Les structures de données hétérogènes.........................................................................38


Les structures de données dynamiques..............................................................................42

I- En langage Pascal...........................................................................................................42

I-1. Les pointeurs.......................................................................................................42

II- En langage C.................................................................................................................49


Les fichiers.........................................................................................................................55

I- En langage Pascal...........................................................................................................55

I.1 Opérations sur les fichiers....................................................................................56

I.2 Les fichiers textes.................................................................................................57

II- En langage C.................................................................................................................58

II.1 Ouverture et création d'un fichier........................................................................59

II.2 Ecriture dans un fichier.......................................................................................59

II.3 Lecture dans un fichier........................................................................................60

II.4 Déplacement dans un fichier...............................................................................61

II.5 Fermeture du fichier............................................................................................62


Solutions des exercices......................................................................................................63

Gestion de l’écran..............................................................................................................66

I- Notion de fenêtre............................................................................................................66

II- Gestion du curseur........................................................................................................66

III- Instructions de gestion de l’écran................................................................................66

IV Instructions de gestion des couleurs.............................................................................66

Conclusion.........................................................................................................................66

Références..........................................................................................................................66

ENS – Rabat – Département d’Informatique

Introduction

INTRODUCTION

Un programme informatique se compose d’une série d’instructions, qui sont exécutées successivement par l’ordinateur. Lors de la création d’un programme, il est nécessaire d’y inclure les instructions correspondant à la tâche qu’on souhaite voir accomplie par l’ordinateur. Le processus consistant à définir les instructions, devant être exécutées par l’ordinateur, se nomme programmation.

Beaucoup de langages de programmation sont apparus au fil des années en commençant par les langages intimement liés à la machine (langage machine et assembleur), viennent après les langages dits évolués : interprétés tels que Basic et compilés tels que Pascal et C.

Langage Pascal

Le langage Pascal est un langage de programmation de haut niveau. Il a été conçu par le professeur WIRTH à Zurich en 1970 comme une aide à l’enseignement de la programmation structurée.

Langage C

Le langage C a été créé en 1972 par Denis RITCHIE avec un objectif relativement limité : écrire un système d’exploitation (UNIX). Mais, ses qualités opérationnelles l’ont très vite fait adopté par une large communauté de programmeurs.

Une première version du langage est apparue en 1978 avec l’ouvrage de Kernighan et Ritchie « The C programming language ». Mais le langage a continué d’évoluer après cette date à travers les différents compilateurs qui ont vu le jour. Son succès internationnel a amené l’ANSI (American National Standard Institute) à définir un C standard (on le qualifie souvent par le C ANSI).

Choix du sujet

L’enseignement de l’informatique se répand de plus en plus dans les établissements scolaires et pour toutes les options, à l’université, aux écoles d’ingénieurs, plus récemment dans les lycées et collèges et même dans les écoles primaires privées.

ENS – Rabat – Département d’Informatique 1

Introduction

En particulier, l’enseignement de l’algorithmique et de la programmation est, et reste toujours un passage obligatoire pour la formation des futurs informaticiens. Malgré l’apparition d’autres systèmes de programmation très évolués et reposant sur la programmation orientée objets, ceux-ci restent liés aux langages de programmation de base tels que Pascal et C.

Objectif

Notre objectif c’est de palier aux difficultés que le programmeur (universitaire, élève ingénieur, analyste-programmeur, etc.) puisse rencontrer au moment de son apprentissage en lui proposant une série d’exercices diversifiés et couvrant la totalité des notions de base de la programmation. On lui propose aussi, à la fin du document, toutes les solutions des exercices proposés en Pascal et en C.


Eléments de base d’un programme en Pascal et en C

ÉLÉMENTS DE BASE D’UN PROGRAMME EN PASCAL ET EN C

I- Structure d’un programme

I-1. En langage Pascal

Un programme PASCAl se compose des éléments suivants :

1- En-tête qui se compose du mot réservé PROGRAM suivi d’un identificateur du nom du programme, suivi du point virgule ‘ ;’.

Exemple : PROGRAM Operations ;

2- Préambule déclaratif qui comporte :

La déclaration des bibliothèques utilisées, précédée par le mot réservé USES. Les identificateurs des bibliothèques sont séparés par des virgules et la liste est terminée par un point virgule ‘;’.

Exemple : USES Crt, Graph, Dos ;

La déclaration des identificateurs de types de données, définis par l’utilisateur, précédée par le mot réservé TYPE.

Exemple : TYPE Nombre = 0..99 ;

La déclaration des identificateurs de constantes, précédée par le mot réservé CONST.

Exemple : CONST Pi = 3.14 ;

La déclaration des identificateurs de variables, précédée par le mot réservé VAR.

Exemple : VAR A : INTEGER ;

3- Définition des différents sous-programmes (voir chapitre des sous-programmes).



4- Définition du bloc principal du programme : ce bloc commence par le mot réservé BEGIN suivi d’une séquence d’instructions (séparées par des points virgules ‘ ;’) et se termine par le mot réservé END suivi du point ‘.’.

I-2. En langage C

1- Préambule déclaratif qui comporte :

La déclaration des bibliothèques utilisées, précédée par le mot réservé ‘#include’

Exemple : #include <stdio.h>

La déclaration de l’identificateur de constante, précédée par le mot réservé define.

Exemple : Define Pi 3.14.

La déclaration des identificateurs de variables, précédée par le type des variables et suivie du point virgule ‘ ;’.

Exemple : int x ;

2- En-tête : précise le début du programme principal. Il se compose du mot réservé Main().

3- Définition du bloc principal du programme : ce bloc commence par une accolade ouvrante ’{‘ et se termine par une accolade fermante ‘}’.

II- Types de données

II-1. Variables et constantes

II-1.1 Les variables

On appelle variable, un emplacement mémoire dans lequel est codée une information que l’on peut modifier et utiliser grâce à un identificateur. Toute variable doit être déclarée avant d’être utilisée.

En langage Pascal



Syntaxe : Var <identificateur> : <type>;

Exemple : var x : integer ;

Variables globales et variables locales

Les variables déclarées dans la partie déclaration du programme sont dites globales.Les variables déclarées dans la partie déclaration d’un sous-programme sont dites locales.Les variables globales sont connues par tous les sous-programmes, tandis que les variables locales sont connues seulement par le sous-programme dans lequel elles sont déclarées.



En langage C

Syntaxe : <type> <identificateur> ;

Le de l’identificateur peut être composé de chiffres, de lettres et du caractère ‘_’. Le premier caractère doit être nécessairement une lettre.

Exemple : int ident_1

Variables globales et variables locales

Selon l'endroit où on déclare une variable, celle-ci pourra être accessible (visible) de partout dans le code ou bien dans une portion confinée de celui-ci (à l'intérieur d'une fonction par exemple), on parle de portée (ou visibilité) d'une variable. Lorsqu'une variable est déclarée à l'extérieur de toute fonction ou de tout bloc d'instructions, elle est accessible de partout dans le code (n'importe quelle fonction du programme peut faire appel à cette variable). On parle alors de variable globale.Lorsque l'on déclare une variable à l'intérieur d'un bloc d'instructions (entre des accolades), sa portée se confine à l'intérieur du bloc dans lequel elle est déclarée.

II-1.2 Les constantes

Contrairement à une variable, une constante ne peut être modifiée (théoriquement).

En langage Pascal

Syntaxe : const <identificateur> = valeur ;

Exemple :

Remarque

Contrairement aux variables, il n'est nullement besoin de spécifier le type de la constante. On peut tout de même le faire, en utilisant le double point, comme pour les variables.

Exemple : const Gravite : Real = 9.81;

En langage C

Syntaxe : const <type> <identificateur> = valeur ;



II-2. Les types de base

II-2.1 En langage Pascal

Type Description Intervalle ExemplesMémoire requise

Shortint Entiers courts -128 à 127 -125; 0; 32 1 octetInteger Entiers "relatifs" -32 768 à 32 767 -30 000; 421; 2 octets

Longint Entiers longs-2147483648 à 2147483647

-12 545 454; 3 257

4 octets

ByteEntiers sur 1 Bit (Byte ou Octet)

0 à 255 12; 157 1 octet

WordEntiers sur 2 Bits (Word ou Mot)

0 à 65 535 27; 4 589 2 octets

Real Nombres réels 2.9E-39 à 1.7E38 3.1415; 789.457851

6 octets

SingleNombres décimaux (simple précision)

1.5E-45 à 3.4E38 3.1415926; 178 925.455678

4 octets

DoubleNombres décimaux (double précision)

5E-324 à 1.7E30854.5899; 9 897 669 651.45568959

8 octets

Extended Nombres réels 3.4E-4932 à 1.1E4932 3.14159265458; 9.81

10 octets

Comp Entier -9.2E18 à 9.2E18 -271; 6 548 8 octetsBoolean logique sur 1 octet false ou true false; true 1 octet

StringChaîne de caractères

256 caractères au maximum (0 à 255)

'Hello!'; 'Allez-vous bien ?'

256 octets

String[n]Chaîne de n caractères

n caractères maximum

String[6]->'Hello!'

n octets

Char 1 caractère1 caractère maximum

'R' 1 octet



II-2.2 En langage C

Type de données SignificationTaille (en

octets)Plage de valeurs acceptée

Char Caractère 1 -128 à 127

unsigned charCaractère non signé

1 0 à 255

short int Entier court 2 -32768 à 32767

unsigned short intEntier court non signé

2 0 à 65535

int Entier 2 -32768 à 32767unsigned int Entier non signé 2 0 à 65535

long int Entier long 4-2 147 483 648 à 2 147 483 647

unsigned long intEntier long non signé

2 0 à 4 294 967 295

float flottant (réel) 4 3.4*10-38 à 3.4*1038

double flottant double 8 1.7*10-308 à 1.7*10308

long doubleflottant double long

10 3.4*10-4932 à 3.4*104932

II-3. Créer un type de données

II-3.1 En langage Pascal

Il est possible au programmeur de créer ses propres types. Les types doivent être déclarés avec le mot-clef Type à fortiori avant la déclaration des variables.

Exemple

Type matrice = Array[1..10,1..10] of integer;Définit un type nommé matrice pour représenter une matrice carrée d’ordre 10.

Type énuméré

Dans la déclaration d’un type énuméré, il faut énumérer toutes les valeurs de ce type.

Syntaxe : type nom_du_type = (identificateur_1, identificateur_2,.., identificateur_n)



Exemple : type jour = (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche) ;

Type intervalle

Syntaxe : type nom_du_type = début_de_l_intervalle..fin_de_l_intervalle

Exemple : Type age = 1..150 ;Déclare un type nommé age dont les valeurs sont des entiers compris entre 1 et 150.

II-3.2 En langage C

Syntaxe : typedef Caracteristiques_du_type Nom_du_typeOù :Caracteristiques_du_type : représente un type de données existant (par exemple float, short int, etc.) Nom_du_type : définit le nom qu’on donne au nouveau type de données.

Exemple : typedef short int entier

Le type énuméré

Le type énuméré donne une liste de constantes par énumération. Le premier identificateur a, par défaut, la valeur 0, le second a la valeur 1, etc. Une variable de type énuméré est une variable entière.

Exemple :

typedef enum = {JAUNE = -2, ROUGE, VERT, VIOLET, BLEU} COULEUR;main(){

COULEUR coul1, coul2;coul1 = VERT; // coul1 = 0coul2 = coul1+2; // coul2 = 2

}

III- Opérateurs et expressions

III-1. En langage Pascal

Les expressions sont composées d’opérateurs et d’opérandes. La plupart des opérateurs sont binaires, c’est à dire qu’ils mettent en œuvre deux opérandes (exemple A+B). Les opérateurs à un opérande sont dits unaires (exemple –A).



Dans les expressions plus complexes, l’existence de règles de priorité permet d’éliminer toute ambiguïté dans l’ordre de réalisation des opérations.

Table de priorité des opérateurs

Ordre Opérateurs Ordre Opérateurs

0 ( , [ 5 + , -

1 OR 6 *, /, DIV, MOD

2 AND 7 ( + ) , ( - )

3 NOT 8

4 < , >, <= , >= , <> , = 9

Remarque : (+) et (-) deux opérateurs unaires.

Les trois règles fondamentales de priorité des opérateurs sont les suivantes :

1- Un opérande placé entre deux opérateurs de priorités différentes sera lié à celui possédant la priorité la plus élevée.

2- Un opérande placé entre deux opérateurs de même priorité sera lié à celui qui se trouve à gauche.

3- Les expressions contenues entre parenthèses sont évaluées d’abord afin de traiter leur résultat comme un seul opérande.

Dans une expression arithmétique, les opérateurs sont les opérateurs arithmétiques (+,-,*, /, DIV, MOD).

Un opérande peut être :

- Un nom de variable ou de constante numérique.

- Une constante numérique.

- Un nom de fonction de type numérique tel que COS, SIN, etc.

Une expression logique simple est une comparaison entre deux expressions arithmétiques. Les opérateurs de comparaison sont =, <>, <, >, <=, >=.

Une expression logique est la composée d’expressions logiques simples par les opérateurs logiques :

- OR et AND opérateurs logiques binaires, OR pour la disjonction et AND pour la conjonction.



- NOT opérateur unaire, NOT opérateur de négation.

III-2. En langage C

Opérateurs arithmétiques

Une expression peut comporter des opérations. Les objets d’une opération sont les opérandes, qui sont manipulés par les opérateurs.

Opérateur Fonction Nbre d'opérandes

- Opposé 1* Multiplicati

on2

/ Division 2% Modulo

(reste)2

+ Addition 2- Soustraction 2

Remarque : L'opérateur modulo ne peut s'appliquer qu'à deux entiers, le résultat est le reste de la division entière.

Opérateurs d’égalité, relationnels et logiques

Ces opérateurs travaillent sur des opérandes ayant deux valeurs : nul (faux) et non-nul (vrai). Le résultat est soit nul (faux), soit non-nul (vrai). L'opérateur && (ET logique) a pour résultat vrai si les deux opérandes ont une valeur vraie. L'opérateur || (OU logique) a pour résultat vrai si l'un au moins des deux opérandes a une valeur vraie. Les évaluations des opérations logiques sont effectuées de la gauche vers la droite. On peut imposer un ordre en utilisant des parenthèses. L'évaluation cesse dès que la valeur de l'expression est établie.


! NON logique 1< Inférieur 2

<= Inférieur ou égal

2

> Supérieur 2




>= Supérieur ou égal

2

== Égalité 2!= Inégalité 2

&& ET logique 2|| OU logique 2

Remarque : Les opérateurs d'égalité et logiques ne doivent pas s'appliquer sur des flottants à cause des erreurs d'arrondi. Pour tester l'égalité à 0 d'un réel, il est préférable de tester que sa valeur absolue est inférieure à un très petit.

Opérateurs de décrémentation et d'incrémentation

Syntaxe : <variable> OP ou OP <variable>

Où OP est l’un des opérateurs ++ ou --.

L’expression le_nombre = le_nombre +1 peut être remplacé par le_nombre++ ou ++le_nombre. Mais, ces expressions ne sont pas équivalentes ; la valeur de l’expression le_nombre++ est égale à la valeur de le_nombre avant l’incrémentation alors que ++le_nombre a pour valeur le_nombre après l’incrémentation.

L’opérateur de décrémentation a le même comportement que le précédent. Ainsi l’instruction le_reel-- diminue de 1 le contenu de le_reel.

Exemple : i++

Opérateur conditionnel

Cet opérateur nécessite trois opérandes et s'apparente à un "si".

Syntaxe : expr1?expr2:expr3;

expr1 est évaluée. Si elle est vraie, le résultat est la valeur de expr2, sinon le résultat est la valeur de expr3.

Exemple : a==b?a=2:b=3;

Opérateurs sur les bits



Les opérandes de ces opérateurs doivent être de type entier (char, int, long, short), mais ils sont traités comme une suite de bits (donc de 0 et de 1).

L'opérateur ~ remplace chaque 0 par 1 et vice-versa.

Les opérateurs &, ^ et ! opèrent sur chaque bit indépendamment. Ils sont associatifs.

expr1 << expr2 décale tous les bits de expr1 de expr2 positions vers la gauche ; les bits vacant sont remplis par des 0.

expr1 >> expr2 décale tous les bits de expr1 de expr2 positions vers la droite ; il ne remplit les bits vacants par des 0 que si expr1 est de type unsigned, sinon, selon les implémentations, il insère des copies du bit de signe ou des 0.


~ Complémentation à 1

1

<< Décalage à gauche

2

>> Décalage à droite

2

& ET logique 2^ OU exclusif 2| OU logique 2

Exemple:unsigned char val = 1; // 00000001val = val << 3; // 00001000val = val >> 2; // 00000010

Remarque: Ne pas confondre les opérateurs sur les bits & et | et les opérateurs sur les expressions && et ||.

Oprérateur sizeof

L’opérateur sizeof fournit la taille en octets. Par exemple, dans une implémentation où le type int est représenté sur 2 octets, si l’on suppose que l’on a affaire à la déclaration int n ; l’expresion sizeof(n) vaudra 2.



Priorité entre opérateurs

Les priorités entre opérateurs définissent l'ordre dans lequel ils sont exécutés. Le tableau suivant récapitule tous les opérateurs avec leur priorité.

En langage C, un certain nombre de notations servant à référencer des objets sont considérées comme des opérateurs et, en tant que tels, soumises à des règles de priorité.

Ce sont essentiellement :

- les références à des éléments d’un tableau réalisées par [ ] ;

- des références à des champs d’une structure opérateur -> ;

- des opérateurs d’adressage * et &.

Ces opérateurs seront étudiés ultérieurement dans les chapitres correspondant aux tableaux, structures et pointeurs.

Catégorie Opérateursréférence () [ ] -> .unaire + - ++ -- | ~ * &arithmétique * / %arithmétique + -décalage << >>relationnels < <= > >=relationnels == !=manip. de bits &manip. de bits ^manip. de bits |logique &&logique ||conditionnel ?:affectation = += -= /= %= &= ^= |= <<= >>=

IV- Instructions simples

IV-1. Instructions d’entrée

Une instruction d’entrée permet de lire une donnée à partir du clavier.

En langage Pascal:



Syntaxe :

Read (V1, V2,…., Vn) Où Vi est une variable de tout type simple (sauf énuméré) ou de type chaîne de caractères.

ReadLn (V1,V2,...Vn) même effet que Read, mais il faut taper la touche Entrée après l’entrée de la donnée. L’instruction ReadLn (sans argument) attend la frappe de la touche Entrée au clavier.

Exemple : read(x) ;

En langage C:

La fonction scanf

Syntaxe : scanf (format, liste_d’adresses)

Format : constante chaîne (entre ""),

Pointeur sur une "chaîne de caractères"

Scanf("%d",&x) ;

Le tableau suivant présente les différents formats existants :

FormatType de la Ivalue

correspondantc chard int hd short inthu unsigned shortld long intlu unsigned longf Floatlf doubles chaîne de caractèresu unsigned int

Liste_d’adresses : liste de "lvalue", séparées par des virgules, d’un type en accord avec le code de format correspondant.

La macro getchar()



Elle permet la lecture d’un caractère. L’expression : c=getchar(), joue le même rôle que : scanf("%c",&c).

IV-2. Instructions de sortie

Une instruction de sortie permet l’affichage sur l’écran des valeurs correspondantes aux arguments considérés.

En Pascal

Syntaxe

Write (val1,val2,…,valn) Où vali est une valeur d’une donnée constante ou variable (sauf type énuméré), une constante chaîne de caractères, ou une valeur d’une expression.

WriteLn(val1,val2,…valn) même effet que Write, mais le curseur passe à la ligne suivante après l’affichage.

Exemple : write(‘salut ’,nom) ;

Remarque :

Une constante chaîne de caractères est mise entre apostrophe. Une apostrophe comprise dans une chaîne doit être dédoublée.

L’instruction WriteLn (sans arguments) permet un saut de ligne.

En langage C :

La fonction printf

Syntaxe : printf (format, liste_d’expressions)

Format : constante chaîne (entre ""),Pointeur sur une "chaîne de caractères"

Liste_d’expressions : suite d’expressions séparées par des virgules d’un type en accord avec le code format correspondant.

Exemple : printf("salut %s",nom) ;

La macro putchar

Permet l’écriture d’un caractère. L’expression putchar(c), joue le même rôle que : printf("%c",c).



IV-3. Instruction d’affectation

En langage Pascal :

Cette instruction permet de transcrire une valeur dans une variable. Le symbole d’affectation est ‘ := ’

Syntaxe : <Var> := <Val> ;

Où la variable <Var> peut être de tout type et la valeur <Val> peut être une valeur constante, la valeur d’une donnée constante ou variable, la valeur d’une fonction, ou le résultat d’une expression.

Exemple : x :=2 ;

En langage C :

Affectation ordinaire

Syntaxe : <variable> = <expression> ;

Exemple : x=2 ;

Remarque :

La valeur affectée à une variable doit être de même type ou de type compatible à celui de la variable.

Notion de Ivalue

On constate que l’opérateur d’affectation impose des restrictions sur son premier opérande. En effet, ce dernier doit être une référence à un emplacement mémoire dont on pourra effectivement modifier la valeur.

Dans les autres langages, on désigne souvent une telle référence par le nom d’une variable. Cependant, en langage C, la syntaxe est telle que cette notion de variable n‘est pas assez précise. Il faut introduire un mot nouveau : la « Ivalue » ; ce terme désigne une valeur à gauche, c’est-à-dire tout ce qui peut apparaître à gauche d’un opérateur d’affectation.

Affectation élargie

Le langage C permet de condenser les affectations de la forme :

Ivalue = Ivalue opérateur expression



En : Ivalue opérateur= expression

Cette possibilité concerne tous les opérateurs binaires arithmétiques et de manipulation de bits (voir chapitre suivant). La liste complète de tous ces nouveaux opérateurs d’affectation élargie est : +=, -=, *=, /=, %=, |=, ^=, &=, <<= et >>=.

Remarque

Ne confondez pas l’opérateur de comparaison <= avec un opérateur d’affectation élargie. Notez bien que les opérateurs de comparaison ne sont pas concernés par cette possibilité.

V-Enoncé des exercices

Exercice 1 Ecrire un programme qui permet d’afficher le message suivant : mon premier programme.

Exercice 2Ecrire un programme qui demande à l'utilisateur les valeurs de 2 entiers x et y, qui permute leurs valeurs et qui les affiche.

Exercice 3Ecrire un programme qui échange 3 entiers.Exercice 4Ecrire un programme qui demande à l'utilisateur les coordonnées de 2 points distincts du plan et qui affiche les coordonnées du point milieu.

Exercice 5Ecrire un programme qui demande à l'utilisateur une valeur pour U0, r et n et qui affiche la nième valeur de la suite arithmétique définie par U0 et Un+1 = Un + r. (On rappelle la propriété : Un = U0 + n.r ).


Structures de traitement alternatives et itératives

STRUCTURES DE TRAITEMENT ALTERNATIVES ET ITÉRATIVES

Les instructions structurées sont des instructions composées d’autres instructions devant être exécutées sous certaines conditions (instructions conditionnelles) ou répétées plusieurs fois (instructions répétitives).

I- Instructions conditionnelles

En langage Pascal :

Instruction IF…Then

Syntaxe : IF <Cond> THEN <Bloc> ;

Si <Cond> est vraie, le bloc d’instructions <Bloc> sera exécuté, sinon il sera ignoré.

Cette instruction représente l’alternative simple (instruction de choix unaire).

Exemple : if a=b then a :=a+b ;

Instruction IF…THEN…ELSE

Syntaxe : IF <Cond> THEN <Bloc1> ELSE <Bloc2>;

Si <Cond> est vraie, le bloc d’instructions <Bloc1> sera exécuté et le bloc d’instructions <Bloc2> sera ignoré, sinon c’est le bloc d’instructions <bloc2> qui sera exécuté et le bloc d’instructions <Bloc1> sera ignoré.

Cette instruction représente l’alternative complète (instruction de choix binaire).

Exemple : if a>b then a:=a-b

Else a:=b-a;

Remarque : la clause ELSE ne doit pas être précédée par un point virgule ‘ ;’.

Instruction CASE

L’instruction CASE est constituée d’une expression de type scalaire,



représentant le sélecteur, et d’une liste de blocs d’instructions ; chacun étant précédé par une étiquette de cas de même type que le sélecteur. Le bloc d’instructions exécuté est celui dont l’étiquette de cas correspond à la valeur courante du sélecteur.

Une étiquette de cas est constituée de tous nombres de constantes ou d’intervalles, séparés par des virgules et terminés par le symbole ’ :’.

Syntaxe :

CASE <Sélecteur> OF Val1 : <Bloc1> ; Val2 : <Bloc2> ; ..........................Valn : <Blocn> ; ELSE <Bloc>;

END;

En langage C :

Instruction IF :

Syntaxe : if (expression) instruction

Expression : expression quelconque.Instruction : instruction simple terminée par un point virgule, bloc d’instructions placées entre { et }, ou instruction structurée.

Instruction IF…Else :

Syntaxe : IF (expression) instruction1 ELSE instrucion2

Instruction SWITCH:

Syntaxe:

Switch(expression){ case constante1: [suite_d’instruction1] case constante2: [suite_d’instruction2] .......................................................... case constante n: [suite_d’instruction n] [default : suite_d’instruction ]}

Expression : expression entière quelconque,



Constante : expression constante d’un type entier quelconque (char est accepté car il sera convertit en int),Suite_d’instructions : séquence d’instructions quelconques.

N.B : les crochets ([et]) signifient que ce qu’ils renferment est facultatif.

L’exécution de l’instruction switch commence par évaluer l’expression figurant après le mot switch, ensuite, chercher l’étiquette de la forme case x correspondant à la valeur obtenue et exécuter, enfin, l’instruction figurant après cette étiquette. Dans le cas où l’étiquette ne figure pas dans la liste, c’est le bloc par défaut qui est exécuté.

Remarque :

On peut ajouter l’instruction break qui permet de sortir de l’instruction switch juste après l’exécution du bloc de l’étiquette choisie.

Switch(expression){ case constante1: [suite_d’instruction1]

break ; case constante2: [suite_d’instruction2]

break ; .......................................................... case constante n: [suite_d’instruction n]

break ; [default : suite_d’instruction ]}

les “case” peuvent apparaître dans n’importe quel ordre.

II- Instructions répétitives

Structures En langage Pascal En langage C

Tant queWhile <expression> Do <bloc>

While (<expression>) <instruction>

Répéter - jusqu’àRepeat<instruction> Until <expression>

Do <instruction> While(<expression>)

Pour For comp :=Vint To Valf Do <bloc>For comp :=Vint DownTo Valf

For (<initialisation> ;<condition de continuation ;<modification>)



Do <bloc> <instruction>

III- Enoncé des exercices

Exercice 6Ecrire un programme qui échange les contenus de 2 données si elles sont de signes contraires.

Exercice 7Ecrire un programme qui échange les contenus de 2 données si elles sont de signes contraires, sinon, il met leur produit dans la première donnée et leur somme dans la deuxième

Exercice 8Ecrire un programme qui, étant donné un mois et son premier jour, affiche le premier jour du mois suivant.

Exercice 9Ecrire un programme qui calcule la somme des N premiers termes positifs.

Exercice 10Ecrire un programme qui calcule la somme des N premiers termes positifs impairs.



Exercice 11Ecrire un programme qui calcule la somme des N premiers termes positifs pairs non multiples de 3.

Exercice 12Ecrire un programme qui calcule la somme 1/2 + 1/4 + 1/8 +…+1/2n (n Є N*).

Exercice 13Ecrire un programme qui calcule la somme 1+1/2-1/4+ 1/8-1/16+…±1/2n (n Є N*).

Exercice 14Ecrire un programme qui donne le nombre N tel que la série 1+1/2-1/3+1/4- 1/5+…±1/N donne un résultat égal (à 1/100 près) à 1,33.

Exercice 15Ecrire un programme qui donne la plus grande valeur inférieure à 1000 de la somme 1+2+4+8+…+2N.

Exercice 16Ecrire un programme qui calcule la somme 1+x+x2+…+xn (x réel et n entier).

Exercice 17Calcul approché de Soient les deux suites: An+1= (An+Gn)/2 et Gn+1=2AnGn/(An+Gn) avec A0=x et G0=1, on montre que lim An=lim Gn=

n∞ n∞Ecrire un programme qui donne la valeur de avec une précision relative Є=10-6, c’est à dire |An-Gn|/|Gn|<Є

Exercice 18Sachant que la somme 1-1/3+1/5-1/7+1/9-…, tend vers П/4. Écrire un programme qui calcule le nombre П à 10-6 près

Exercice 19Le développement limité de la fonction sinus au voisinage de zéro est sin x= x - x3/3! + x5/5! -…+(-1)p x2p+1/(2p+1)!+… Ecrire un programme qui calcule sin x à 10-6 près.

Exercice 20Ecrire un programme qui calcule la somme, le produit et la différence de deux données numériques.

Exercice 21Ecrire un programme qui retourne le code d’une donnée de type Caractere.

Exercice 22



Ecrire un programme qui calcule le salaire net d’un employé, sachant que celui-ci a assuré un certain nombres d’heures de travail à un prix fixe par heure, et que l’employeur doit réduire de son salaire des charges qui sont calculées avec un coefficient donné.

Exercice 23Ecrire un programme qui permet de reprendre l’exercice précédant en considérant que l’employé a assuré des heures normales, des heures à 25% et des heures à 50%.

Exercice 24Ecrire un programme qui retourne si une donnée numérique est paire ou impaire (utiliser le reste de la division par 2).

Exercice 25Ecrire un programme qui permet de lire trois données numériques et retourne si la troisième donnée est la somme des deux autres ou pas.

Exercice 26Ecrire un programme qui, à partir du salaire brut d’un employé, détermine l’impôt à payer sachant que les règles de calcul des impôts sont comme suit :

salaire brut(SB) l’impôt à payerSB<1500 0%1500<=SB<3000 10% du SB3000<=SB<5000 450+30%(SB-3000)SB>=5000 750+40%(SB-5000)

Exercice 27Ecrire un programme qui fournit les racines de l’équation Ax2+Bx+C=0.

Exercice 28Ecrire un programme qui, étant donnée une date (jour, mois, année), affiche la date du jour suivant.

Exercice 29Ecrire un programme qui, étant donnée une date (jour, mois, année), affiche la date du jour précédent.

Exercice 30Ecrire un programme qui calcule la somme 5+6+7+….+N (N>=5).

Exercice 31Ecrire un programme qui calcule le produit des N (N>0) premiers entiers positifs.

Exercice 32



Ecrire un programme qui calcule la somme 1+1/2+1/4+1/6+…+1/2N (N>0).

Exercice 33Ecrire un programme qui échange les contenus de trois données numériques si leur somme est paire, sinon il met la somme des trois dans la première donnée, leur produit dans la seconde et la valeur zéro dans la troisième.

Exercice 34Ecrire un programme qui calcule la somme 1-1/2+1/3-1/4+…±1/N.


Notion de sous-programmes

NOTION DE SOUS-PROGRAMMES

Un sous-programme permet :

d’éviter d’appliquer à plusieurs endroits d’un programme le même traitement, même s’il porte sur des objets différents.

d’appliquer sous forme transportable un traitement dont on prévoit que d’autres programmes peuvent aussi en avoir besoin.

de dégager d’un programme des tâches de moindre importance ne laissant dans son corps que la partie importante de l’algorithme d’où le gain de lisibilité et de sécurité.

I. En langage Pascal

Les sous-programmes en Pascal sont des procédures et des fonctions.

I.1 Les procédures

Une procédure doit être déclarée dans un programme, ou dans une procédure, avant le corps du programme (de la procédure) et après les déclarations des variables.

Le nom de la procédure est un identificateur qui, comme les autres déclarations environnantes, sera local au programme ou à la procédure l’environnant.

La structure d’une procédure est à peu près celle d’un programme, l’en-tête diffère, la procédure se termine par un point virgule au lieu d’un point.

Syntaxe : procedure <Ident> ;<Déclarations> ;

Begin<Instructions> ;

End ;

Paramètres formels

La déclaration des procédures peut être suivie d’une liste de paramètres entre parenthèses. Un paramètre formel est destiné à être remplacé, chaque fois que la



procédure est activée, par un autre objet dit paramètre effectif, le plus souvent une variable, ou le résultat d’une expression, de la procédure appelante.

Syntaxe : Procedure <Nom> ( <mode> <Ident>.., <Ident> : <Type> ;.. ; <mode> <Ident>,.., <Ident> : <Type>) ;

Où <mode> = rien ou var.

Paramètres par valeurs et paramètres par adresse

Les objets sont transmis comme données dont la valeur doit être inchangée par la procédure appelée (on dit qu’on a une lecture pure).

Les objets sont transmis comme résultat dont la valeur doit être calculée par la procédure appelée et transmise à la procédure appelante (on dit qu’on a une écriture pure).

Les objets sont transmis comme données qui doivent être modifiées par la procédure appelée (on dit qu’on a une lecture-écriture).

En Pascal, la transmission des paramètres se fait de deux manières :

Transmission par valeur (lecture pure).

Transmission par adresse (écriture pure, lecture-écriture).

On indique les paramètres transmis par adresse, précédés par le mot réservé Var, les autres ne sont précédés par aucune chose.

I.2 Les fonctions

Une fonction en Pascal se comporte comme une procédure sauf que la fonction doit fournir un résultat, elle a donc un type.

Syntaxe : Function <Ident> : <Type> ;Function <Ident> (<liste_paramètres> ) : <Type> ;

Dans le corps de la fonction, on doit trouver quelque part l’affectation d’une valeur à l’identificateur de la fonction.

Exemple :Function Minimum (x, y : Integer ) : Integer ;

BeginIf x<y then Minimum :=xElse Minimum:=y

End;

II. En langage C



Les fonctions sont les seuls sous-programmes en C; elles permettent de regrouper des instructions et de lancer leur exécution grâce à un identificateur. La fonction peut admettre des paramètres.

La fonction peut retourner une valeur. La définition d’une fonction est composée de deux éléments :

son prototype :

Permet de préciser la classe de mémorisation, le type, l’identificateur et les paramètres de la fonction ; c’est l’entête de la fonction.

Syntaxe :

[classe][type]<identificateur>([liste des paramètres formels]). La liste est composée de la déclaration des paramètres formels : <type><arg1>,<type><arg2>,…,<type><argn>.

Si la liste est vide alors elle peut être remplacée par le mot void.

Son corps : c’est un bloc d’instructions

[classe][type]<identificateur>([liste des paramètres formels]){…<corps de la fonction>…}/*fin de la fonction*/

Dès qu’une instruction de retour est rencontrée, l’exécution de la fonction s’interrompt. Cette instruction permet de transmettre éventuellement une valeur au programme appelant.

Syntaxe :

return ; /*pas de valeur retournée*/ return <expression> ; return(<expression>) ;

Si la fonction ne contient pas l’instruction return, elle s’achève automatiquement à la fin de son bloc.

Passage des paramètres par valeur



En langage C, le passage des paramètres se fait toujours par valeur, c.-à-d. les fonctions travaillent sur les valeurs de leurs paramètres et n'ont pas d'accès aux variables elles-mêmes. Les paramètres d'une fonction sont à considérer comme des variables locales qui sont initialisées automatiquement par les valeurs indiquées lors d'un appel. A l'intérieur de la fonction, nous pouvons donc changer les valeurs des paramètres sans influencer les données originales dans les fonctions appelantes.

Passage par adresse

Pour changer la valeur d'une variable de la fonction appelante, il faut que la fonction appelante fournisse l'adresse de la variable et la fonction appelée déclare le paramètre comme pointeur.

On peut alors atteindre la variable à l'aide du pointeur (voir chapitre structure de données).

III. La récursivité

Un sous-programme est dit récursif s’il s’appelle lui-même. Il doit contenir une condition d’arrêt. Considérons l’exemple de la fonction pgcd(a, b) qui retourne le plus grand diviseur commun des deux entiers a et b :

En langage C En langage Pascal

int pgcd(int a, int b){ if (a = = b) return a;else if (a>b) return pgcd(a-b,b);else pgcd(a,b-a);}

Funtion pgcd (a,b : integer): integer;Begin If (a=b) then pgcd:=a Else if (a>b) then pgcd:=pgcd(a-b,b) Else pgcd:=pgcd(a,b-a)End;

IV- Enoncé des exercices

Exercice 35Ecrire une fonction paramétrée qui retourne si un nombre donné est premier ou non.

Exercice 36Ecrire une fonction paramétrée qui retourne si un nombre donné est parfait ou non.



Exercice 37Ecrire une fonction paramétrée qui retourne si deux nombres donnés sont amis ou non.

Exercice 38Ecrire une fonction paramétrée qui retourne l’inverse d’un nombre entier donné.

Exercice 39Ecrire une fonction récursive permettant de calculer le PGDC de deux nombres entiers positifs A et B.

Exercice 40Ecrire une fonction récursive permettant de calculer le PPMC de deux nombres entiers positifs A et B.

Exercice 41Ecrire une fonction récursive qui permet de calculer le factoriel d’un nombre donné.

Exercice 42Ecrire une fonction récursive qui permet de calculer la puissance d’un entier donné.

Exercice 43Ecrire une fonction récursive qui calcule la valeur de la fonction d’Ackermann « A » définie pour m>0 et n>0 par : A(m, n)=A((m-1),A(m,n-1)) pour n>0, m>0 ; A(0,n)=n+1 pour n>0; A(m,0)=A(m-1,1) pour m>0 ;

Exercice 44Ecrire une fonction qui fournit le nombre de chiffres d’un entier donné.

Exercice 45Ecrire une procédure qui permet de dessiner la lettre X, à l'aide d'espaces et d'une "lettre" fournie par l'utilisateur, auquel on demande aussi la "hauteur" du dessin qu'il désire obtenir.



Par exemple : avec les réponses a et 5, elle donnera : a a a a a a a a a

Exercice 46Soit un programme qui visualise un menu composé de trois rubriques : Hors d’œuvre, plat chaud et dessert.Ecrire une procédure qui permet d’effectuer, à chaque fois, un choix exclusif.

Exercice 47Ecrire une procedure paramétrée, qui permet l’échange des contenus de deux paramètres formels par valeur A et B. Appeler cette procédure dans un programme principal.On écrira les résultats dans le corps de la procédure, et dans le programme principal.

Exercice 48Ecrire une procedure paramétrée, qui permet l’échange des contenus de deux paramètres formels par adresse A et B. Appeler cette procédure dans un programme principal.On écrira les résultats dans le corps de la procédure, et dans le programme principal.

Exercice 49Ecrire une procédure qui affiche tous les nombres premiers qui sont compris entre 1 et 200.

Exercice 50Ecrire une procédure qui affiche tous les nombres parfaits qui sont compris entre 1 et 200.

Exercice 51Ecrire une procédure qui permet d’afficher tous les diviseurs d’un entier N ainsi que leur nombre.

Exercice 52Affichez un triangle isocèle formé d'étoiles sur N lignes (N est fourni au clavier).



Exemple : N=8*

********

****************

************************

***************

Exercice 53Calculer pour une valeur X donnée du type réel la valeur numérique d'un polynôme de degré n:

P(X) = AnXn + An-1Xn-1 + ... + A1X + A0

Les valeurs de n, des coefficients An, ..., A0 et de X seront entrées au clavier. Utiliser le schéma de Horner qui évite les opérations d'exponentiation lors du calcul:

Exercice 54Ecrire une procédure qui affiche la table des produits pour N variant de 1 à 10 : X*Y I 0 1 2 3 4 5 6 7 8 9 10--------------------------------------------------0 I 0 0 0 0 0 0 0 0 0 0 01 I 0 1 2 3 4 5 6 7 8 9 102 I 0 2 4 6 8 10 12 14 16 18 203 I 0 3 6 9 12 15 18 21 24 27 304 I 0 4 8 12 16 20 24 28 32 36 405 I 0 5 10 15 20 25 30 35 40 45 506 I 0 6 12 18 24 30 36 42 48 54 607 I 0 7 14 21 28 35 42 49 56 63 708 I 0 8 16 24 32 40 48 56 64 72 809 I 0 9 18 27 36 45 54 63 72 81 9010 I 0 10 20 30 40 50 60 70 80 90 100


Les structures de données statiques

LES STRUCTURES DE DONNÉES STATIQUES

Une structure de données est un ensemble organisé d’informations reliées logiquement, ces informations peuvent être traitées collectivement ou individuellement.

Une structure de données est caractérisée par ses composantes et leur organisation, mais surtout par ses méthodes d’accès.

I. Les structures de données homogènes

En langage Pascal:

Tableau

Un tableau est une suite d’éléments de même type. En Pascal, la déclaration des tableaux se fait comme suit :

Syntaxe : Var NomTab : Array[Min..Max] Of Type;

On accède à un élément du tableau en utilisant un index : Exemple NomTab[4]. Chaînes de caractères

En Pascal, la définition du type chaîne est constituée du mot réservé STRING suivi de la longueur maximale entre crochets. La longueur est une constante entière dans l’intervalle [0,255]. Si la longueur maximale n’est pas précisée, elle est égale à 255 par défaut.Les variables chaînes occupent en mémoire la longueur maximale définie +1 octet. Le premier octet contient la longueur courante de la chaîne. Les caractères individuels sont indexés de 1 à la longueur maximale de la chaîne.

Expressions chaînes

Le signe ‘ + ’ est utilisé pour concaténer des chaînes.Exemple : ‘123’ + ‘456’ = ‘123456’.

On peut comparer deux chaînes, le résultat est une valeur booléenne.



Exemple : ‘12’ < ‘2’ est vraie

Affectation de chaînes

L’opérateur d’affectation est utilisé pour affecter la valeur d’une expression à une variable chaîne. Exemple : p :=’Programmation’ ;

Procédures sur les chaînes

Procédure Commentaires

DELETE (st,pos,num)supprime dans la chaîne st une sous-chaîne contenant num caractères à partir du caractère de position pos.

INSERT(obj,target,pos)permet l’insertion de la chaîne obj dans la chaîne target à la position pos.

STR(value,st)convertit la valeur numérique de value en une chaîne, et range le résultat dans st.

VAL(st,var,code)

convertit l’expression chaîne st en une valeur entière ou réelle (en fonction de type de var) et range la valeur dans var. code doit être une variable entière. Si aucune erreur n’est détectée, code est mise à zéro, sinon code a la valeur de la position du premier caractère en erreur et la valeur de var est indéfinie.

Fonctions sur les chaînes

Fonctions Commentaires

COPY(st,pos,num)retourne une sous-chaîne contenant num caractères de st en commençant par le caractère de position pos.

CONCAT(st1,st2,…,stn)retourne une chaîne qui est la concaténation de ces arguments dans l’ordre où ils sont déclarés.

LENGTH(st) retourne la longueur effective de la chaîne st.

POS(obj,target)si obj est contenu dans target alors pos retourne la position du premier caractère de obj dans target sinon pos retourne zéro.

Ensembles



La structure de données Ensemble permet de représenter l’objet mathématique ensemble sur lequel on peut effectuer les opérations d’appartenance, de réunion, etc.

Bien qu’en mathématiques il n’y ait pas de restriction sur les objets qui pourront être membre d’un ensemble, Pascal ne procure qu’une forme restreinte d’ensemble. Les membres d’un ensemble doivent être tous de même type appelé type de base.

Déclaration : <ident> : SET of <type>

Exemple: ens: set of char

Remarques

Le nombre maximum d’un ensemble est 256. On note par [ ] l’ensemble vide compatible avec tout type ensemble.

Opérateurs sur les ensembles

Le symbole d’appartenance est INLe symbole d’intersection est *Le symbole de réunion est +Le symbole de différence est -= test d’égalité<> test d’inégalité>= vrai si tous les membres du second opérande sont inclus dans le premier.<= vrai si tous les membres du premier opérande sont inclus dans le second.

En langage C

Tableau

En langage C, la syntaxe de la définition d'un tableau est la suivante :

Syntaxe : type Nom_du_tableau [Nombre d'éléments]

Type : définit le type d'éléments que contient le tableau (un tableau en langage C est composé uniquement d'éléments de même type).

Nombre d'éléments : est un nombre entier qui détermine le nombre de cases du tableau.

Exemple : int T[]20 ;



Chaîne de caractères

En langage C, une chaîne de caractères est un tableau de type char, dont le dernier élément est le caractère nul '\0', c'est-à-dire le premier caractère du code ASCII (dont la valeur est 0).

Ce caractère est un caractère de contrôle (non affichable) qui permet d'indiquer la fin de la chaîne de caractères. Ainsi, une chaine composée de n éléments sera en fait un tableau de n+1 éléments de type char.

On peut par exemple représenter la chaîne "Bonjour" de la manière suivante:

B o n j o u r \0

Pour définir une chaîne de caractères en langage C, il suffit de définir un tableau de caractères. Le nombre maximum de caractères que comportera la chaîne sera égal au nombre d'éléments du tableau moins un (réservé au caractère de fin de chaîne).

Syntaxe : char Nom_du_tableau[Nombre_d_elements]

Lecture et écriture des chaînes

Le langage C offre plusieurs possibilités de lecture ou d’écriture de chaînes :- L’utilisation du code de format %s dans les fonctions printf et scanf.- Les fonctions spécifiques de lecture (gets) ou d’affichage (puts) d’une

chaîne.

Exemple : char ville[25] ;gets(ville) ; puts(ville) ;

Remarque : Avec le code %s de scanf, on utilise les délimiteurs habituels (espace ou la fin de ligne). Cela interdit donc la lecture d’une chaîne contenant des espaces. Avec gets seule la fin de ligne sert de délimiteur.

Les fonctions de manipulation de chaînes de caractères

De nombreuses fonctions de manipulation de chaînes se trouvent dans le fichier d'en-tête <string.h>, c'est la raison pour laquelle il faut ajouter la ligne suivante au début du programme : #include <string.h>




strcat(but,source)recopie la seconde chaîne (source) à la suite de la première (but).

strncat(but,source,lgmax)

travaille de façon semblable à strcat en offrant en outre un contrôle sur le nombre de caractères qui seront concaténés à la chaîne d’arrivée (but).

strcmp(chaîne1,chaîne2)

compare deux chaînes dont on lui fournit l’adresse et elle fournit une valeur entière définie comme étant :

Positive si chaîne1 > chaîne2 Nulle si chaîne1 = chaîne2 Négative si chaîne1 < chaîne2

strncmp(chaîne1,chaîne2,lgmax)travaille comme strcmp mais elle limite la comparaison au nombre maximal de caractères indiqués par l’entier lgmax.

stricmp(chaîne1,chaîne2) et strnicmp(chaîne1,chaîne2,lgmax)

travaillent respectivement comme strcmp et strncmp, mais sans tenir compte de la différence entre majuscules et minuscules.

strcpy(destin,source)recopie la chaîne située à l’adresse source dans l’emplacement d’adresse destin.

strncpy(destin,source,lgmax)

procède de manière analogue à strcpy, en limitant la copie au nombre de caractères précisés par l’expression entière lgmax.

strchr(chaîne,caractère)recherche dans chaîne la première position où apparaît le caractère mentionné.

strrchr(chaîne,caractère)réalise le même traitement que strchr, mais en explorant la chaîne concernée à partir de la fin.

strstr(chaîne,sous-chaîne)recherche dans chaîne la première occurrence de la sous-chaîne mentionnée.



II. Les structures de données hétérogènes

En langage Pascal

Les enregistements

Un enregistrement est un ensemble d’informations de types différents accessibles individuellement ou collectivement. C’est une structure constituée d’un nombre fixe de composantes appelées champs.

Syntaxe : TYPE nom_type = RECORD champ1:type ; champ2:type ;.... END;

Exemple : TYPE date = RECORDJour : 1..31 ;Mois : (jan,fev,mars,avr,mai,jui,juil,aout,sep,oct,nov,dec) ;An : 1900..2000 ;END ;

VAR date_nais : date ;

L’accès au champ jour dans date_nais par exemple se fait par date_nais.jour.

L’affectation entre deux variables enregistrements de même type est autorisée.

Exemple : with date do jour:=2;

Instruction with

Syntaxe: WITH nom_enregistrement DO instruction

Elle permet d'omettre le nom_enregistrement dans l'instruction.

En langage C

Les structures

Dans un tableau, tous les constituants doivent être semblables. Ce n'est pas le cas des structures, qui sont des variables composées de plusieurs variables (ou CHAMPS) de types différents.

Syntaxe : struct Nom_Structure {type_champ1 Nom_Champ1;type_champ2 Nom_Champ2;...

};



Exemple : struct date{ Int jour;

Int mois ;Int annee ;

} ;

Définition d’une variable structurée

C’est une variable ayant comme type celui d'une structure que l'on a précédemment déclarée.

Syntaxe : struct Nom_Structure Nom_Variable_Structuree;

- Nom_Structure représente le nom d'une structure que l'on aura préalablement déclarée.

- Nom_Variable_Structuree est le nom de la variable de type Nom_Structure.

Pour accéder aux champs d'une structure, on utilise un point placé entre le nom de la variable structurée que l'on a définie et le nom du champ.

Exemple : date_naiss.jour;


Exercice 55Ecrire une procédure qui affiche les nombres négatifs d’une liste réelle.

Exercice 56Ecrire une procédure qui met à zéro la diagonale d’une matrice carrée.

Exercice 57Ecrire une procédure qui affiche l’occurrence d’existence d’un nombre réel dans une liste de nombres réels.

Exercice 58Ecrire une procédure qui met le plus petit élément d’une liste au début de celle-ci.

Exercice 59Ecrire une procédure qui met les éléments négatifs d’une liste à gauche et les éléments positifs à droite de la liste.



Exercice 60Ecrire une procédure qui classe une liste de notes de la plus petite à la plus grande.

Exercice 61Etant donné N étudiants, leurs notes correspondantes à M matières et leur moyenne. Ecrire une procédure qui affiche à côté de chaque étudiant son classement.

Exercice 62Le tri à bulles est un tri par échange. Le principe de base est de réordonner les couples non classés tant qu’ils existent. La méthode de tri à bulles consiste à parcourir la liste en comparant deux éléments successifs et en les permutant s’il y a lieu. Ecrire une procédure qui réalise ce tri.

Exercice 63Un palindrome est un mot, ou une phrase, lisible indifféremment de la gauche vers la droite ou inversement. Ecrire une fonction qui retourne si une chaîne de caractères est un palindrome ou non.

Exercice 64Ecrire une fonction qui retourne la fréquence d’occurenced’un mot dans une phrase.

Exercice 65Ecrire une procédure qui enlève tous les blancs au début d’une phrase et qui laisse un seul blanc entre les différents mots de la phrase.

Exercice 66Soit un nombre entier positif N. Ecrire une fonction qui donne son équivalent dans une base donnée B (2B16).

Exercice 67Soit N un nombre donné en base B (B 10). Ecrire une fonction qui donne son équivalent en base 10.

Exercice 68Soit N un nombre donné en base B1. Ecrire une fonction qui donne son équivalent en base B2.



Exercice 69Si on est amené à réaliser des opérations sur des nombres entiers très grands, on peut utiliser les chaînes de caractères pour représenter ces nombres et ensuite faire l’opération par bloc.Ecrire une procédure pour réaliser l’opération d’addition sur de tels nombres.

Exercice 70Ecrire une procédure qui permet de passer de la représentation d’un nombre en chiffres romains à sa représentation décimale.

Exercice 71Ecrire une procédure qui permet de passer de la représentation décimale d’un nombre à sa représentation en chiffres romains.

Exercice 72Ecrire une fonction qui retourne le déterminant d’une matrice carrée.

Exercice 73Ecrire une procédure qui calcule l’inverse d’une matrice carrée.

Exercice 74Un carré magique est un carré divisé en cellules dans lesquelles les nombres entiers, à partir de 1 sont disposés de telle sorte que les sommes de chaque ligne, de chaque colonne et de chaque diagonale soient égales.Exemple :

6 1 87 5 32 6 4

Ecrire une procédure qui permet de réaliser le carré magique d’ordre n (n impair).Exercice 75Ecrire un programme qui permet de saisir et d’afficher les informations d’une liste d’étudiants.

Exercice 76Ecrire les procédures qui donnent le calcul sur les nombres complexes au moyen d’un type enregistrement.


Les structures de données dynamiques

LES STRUCTURES DE DONNÉES DYNAMIQUES

Dans la pratique, très souvent, on veut représenter des objets, soit dont on ne connaît pas à priori la taille, soit dont la taille est variable, selon les cas ou au cours du traitement. On est alors amené à utiliser des structures qui peuvent évoluer, pour bien s’adapter à ces objets. Ce sont les structures de données dynamiques.

I- En langage Pascal

I-1. Les pointeurs

Un pointeur est une variable contenant l'adresse d'une autre variable d'un type donné.

Syntaxe : type type_pointeur = ^type_base ;type_base = ident_type ;

Si le type de base type_base est un identificateur non encore déclaré, il doit l’être dans la même partie de la déclaration que le type pointeur type_pointeur.

Exemple : type ref = ^integer ;

Remarques :

ref est une variable pointeur et ref^ la variable pointée.

La constante NIL peut être affectée à n’importe quelle variable pointeur (NIL ne fait référence à aucun élément du type associé).

Le type prédéfini Pointer indique un pointeur non typé, c’est-à-dire un pointeur qui ne pointe pas sur un type particulier.

L’opérateur @ fait pointer la variable pointeur sur une zone mémoire contenant une variable.

Procédures et fonctions d’allocation dynamique de mémoire



Ces procédures et fonctions permettent de manipuler le tas (zone de mémoire qui correspond à tout ou partie de l’espace mémoire laissé vacant après chargement du programme).

Procédures ou fonctions Commentaires

New (var p:pointeur)crée un espace mémoire de la taille de la variable pointée et affecte l’adresse de celui-ci au pointeur

GetMem (var p:pointeur; taille:word)

crée une nouvelle variable dynamique de la taille indiquée et place son adresse dans une variable pointeur.

Ptr (seg,dep:word)

fait pointer la variable pointeur sur une adresse mémoire spécifique sans faire intervenir de notion de variable occupant cet espace. Ptr convertit une adresse format segment:déplacement en une valeur de type pointeur.

Dipose (var p:pointeur)libère la mémoire d’une variable dynamique.

FreeMem (var p:pointeur;taille:word)

libère la mémoire d’une variable dynamique d’une certaine taille

Mark (var p:pointeur)mémorise la valeur du pointeur de tas dans une variable de type pointeur.

Release (var p:pointeur)restaure le tas dans une configuration donnée. Le pointeur p doit être initialisé par la procédure Mark.

Les listes chaînées

Une liste chaînée est une suite de données (liste) liées entre elles. Le lien est réalisé par des pointeurs. Chaque élément de la liste est un enregistrement dont l’un des champs est un pointeur qui pointe vers l’élément suivant.



Exemple : type nbrpoint = ^nombre ; nombre = record

nbr : integer ;suivant : nbrpoint ;

end ;

L’insertion d’un élément x dans une liste chaînée se fait en deux étapes :

1. allocation de l’espace mémoire qu’occuperait x. 2. création des liens avec l’élément de gauche puis de droite.

L’élimination d’un élément x d’une liste chaînée se fait en deux étapes :

1. création des liens entre l’élément de gauche et de droite.2. libération de l’espace mémoire qu’occupait x.

Les arbres

Lorsqu’on généralise la notion de listes chaînées en associant à chaque élément de la liste 2 ou plusieurs successeurs, tout en gardant une structure à une seule tête, on obtient ce qu’on peut appeler un arbre.


A

B C

D E F G

HI

L a1

a2 a3e1 e2 en NIL

Queue de la liste

Tête de la liste

J


Définitions :

Nœud : chaque élément d’un arbre est appelé nœud.

Racine d’arbre : le premier nœud d’arbre est appelé racine (ici A).

Feuille : un nœud sans successeur est appelé feuille (comme D, E, F, H, I,J).

Arc : un lien entre 2 nœuds successifs est appelé arc.

Chemin : un chemin est une séquence d’arcs reliant deux nœuds d’un même arbre (A B E).

Père / Fils / Ancêtre / Descendant :

- Un successeur B d’un nœud A est appelé fils de A, A est alors père de B ;

- Si A dispose d’un autre fils C alors B et C sont frères ;

- B et C sont aussi appelés des descendants immédiats ;

- Les fils de B et C sont aussi des descendants de A ;

- A est alors l’ancêtre des fils de B et C ainsi que de leurs fils.

Arbre évalué : c’est un arbre dont les arcs portent des étiquettes permettant de définir ce qu’on appelle un coût pour se rendre d’un nœud à l’autre. Il est possible de calculer le coût relativement à un chemin.

Arbre binaire : les arbres binaires sont le type d’arbre le plus utilisé car il est plus simple à gérer et à implémenter, il dispose au maximum de 2 fils. Le premier est appelé fils gauche, le deuxième fils droit. Par contre, un arbre multiple est un arbre dont chaque nœud peut disposer de plus de 2 fils. Il s’agit donc d’une structure plus complexe que celle des arbres binaires. Pour faciliter leur gestion, il existe plusieurs méthodes pour transformer un arbre en son équivalent binaire. Parmi ces méthodes, on peut citer la suivante :

Le 1er fils d’un nœud est marqué comme fils gauche de l’arbre binaire correspondant.

Les autres fils sont rangés successivement comme fils droit du 1er fils c'est-à-dire pour chaque nœud de l’arbre binaire obtenu, son 1er fils se trouve à gauche et son 1er frère se trouve à droite.

Parcours d’arbres binaires



On appelle parcours d’un arbre tout algorithme permettant d’accéder une et une seule fois à tous les nœuds de l’arbre. On distingue six parcours généraux, symétriques deux à deux, valides pour les arbres binaires quelconques et répartis en trois catégories qui sont :

Les parcours en préordre (préfixés)

Parcourir un arbre binaire en préordre c’est d’abord inspecter la racine, puis parcourir en préordre le sous-arbre gauche (respectivement le sous-arbre droit) et enfin parcourir en préordre le sous- arbre droit (respectivement le sous-arbre gauche).

Exemple :

Parcours en préordre racine, sous-arbre gauche, sous-arbre droit 2, 5, 1, 7, 4, 8, 10, 12.Parcours en préordre racine, sous-arbre droit, sous-arbre gauche 2, 8, 10, 12, 5, 4, 1, 7.

Les parcours en postordre (postfixés)

Parcourir un arbre binaire en postordre c’est d’abord parcourir en postordre le sous-arbre gauche (respectivement le sous-arbre droit), puis parcourir en postordre le sous-arbre droit (respectivement le sous-arbre gauche) et enfin inspecter la racine.

Exemple : même exemple que précédemment.

Parcours en postordre sous-arbre gauche, sous-arbre droit 7, 1, 4, 5, 12, 10, 8, 2.Parcours en postordre sous-arbre droit, sous-arbre gauche 12, 10, 8, 7, 1, 4, 5, 2.

Les parcours en ordre (infixés)


510

7

1 4

2

8

12


Parcourir un arbre binaire en ordre c’est d’abord parcourir en ordre le sous-arbre gauche (respectivement le sous-arbre droit), puis inspecter la racine et enfin parcourir en ordre le sous-arbre droit (respectivement le sous-arbre gauche).

Exemple : même exemple que précédemment.

Parcours en ordre sous-arbre gauche, racine, sous-arbre droit 1, 7, 5, 4, 2, 8, 12, 10.Parcours en ordre sous-arbre droit, racine, sous-arbre gauche 10, 12, 8, 2, 4, 5, 7, 1.

Arbres ordonnés

Arbre binaire ordonné horizontalement

Un arbre binaire est ordonné horizontalement (de gauche à droite) si la clé de tout nœud non feuille est supérieure à toutes celles de son sous-arbre gauche et est inférieure à toutes celles de son sous-arbre droit.

Exemple :

Recherche d’un élément dans un arbre ordonné horizontalement

La recherche d’un élément dans un arbre ordonné horizontalement qui tient compte de l’ordre est dichotomique et donc très supérieure à une recherche systématique à l’aide d’un parcours général.

Insertion d’un élément

Le principe de l’insertion d’un élément dans un arbre binaire ordonné horizontalement est le suivant : on recherche de façon récursive la place de l’élément, ce qui conduit nécessairement à une feuille si l’élément ne figure pas déjà dans l’arbre, puis on accroche l’élément à cette feuille.

Exemple : insertion de l’élément 6 dans l’arbre suivant


5

4

8

10

13

9


Suppression d’un élément

Le principe de la suppression d’un élément d’un arbre binaire ordonné horizontalement est le suivant :

- si l’élément est une feuille alors on le supprime simplement.- si l’élément n’a qu’un descendant alors on le remplace par ce

descendant.- si l’élément a deux descendants, on le remplace au choix, soit par

l’élément le plus à droite du sous-arbre gauche, soit par l’élément le plus à gauche du sous-arbre droit, afin de conserver la propriété d’ordre horizontal.

Exemple : Suppression de l’élément 7

Représentation d’un arbre en Pascal


5

4

8

10

13

9

8

6

5

4

13

10

9

Insertion

18

16

7

4 9

10

862

24

18

16

6

4 9

10

82

24

Suppression


Une manière possible de représenter un arbre est la suivante : l’ensemble des fils du même père forme une liste, donc chaque fils a un pointeur vers son frère qui le suit. Le dernier frère a 0. Chaque père a un pointeur vers son premier fils.

Les fils de la dernière génération (feuilles) ont 0. Chaque fils à un pointeur vers son père. L’ancêtre (racine) a 0.

Cela va être contenu dans un array of record :

type gene = Record nom : string;pere : integer ;frere : integer ;fils : integer;

end ;

arbre = array [1..max] of gene ;var mafamille : arbre;

Exemple : (entre parenthèse figure l’indice dans le tableau)

Pierre (1)

Paul (2) Jacques (3)

Marcel (4) George (5) Jean (6)

Gérard (7) Alain (8) Louis (9)

1 2 3

II. En langage C

Les pointeurs

Un pointeur est une variable qui doit être définie en précisant le type de la variable pointée, de la façon suivante :

Syntaxe : type * Nom_du_pointeur

Le type de la variable pointée peut-être aussi bien un type primaire (tel que int, char, etc.) qu'un type complexe (tel que struct, etc .).


Pierre 0 0 2 1 3 4 1 0 6Paul Jacques


Après avoir déclaré, un pointeur il faut l'initialiser en utilisant l'opérateur d'affectation '=' suivi de l'opérateur d'adresse '&' auquel est accollé un nom de variable (celle-ci doit bien sûr avoir été définie auparavant).

Syntaxe : Nom_du_pointeur = &nom_de_la_variable_pointee;

Après (et seulement après) avoir déclaré et initialisé un pointeur, il est possible d'accéder au contenu de l'adresse mémoire pointée par le pointeur grâce à l'opérateur '*'.

Fonctions d’allocation dynamique de mémoire

Le prototype de ces fonctions figure à la fois dans stdlib.h et dans alloc.h.


void * malloc(size_t taille)

alloue un emplacement de taille octets, sans l’initialiser et fournit l’adresse correspondante lorsque l’allocation a réussi ou un pointeur nul dans le cas contraire.

void * calloc(size_t nb_blocs,size_t taille)

alloue l’emplacement nécessaire à nb_blocs consécutifs, ayant chacun une taille de taille octets.

void * realloc(void * pointeur, size_t taille)

permet de modifier la taille d’une zone préalablement allouée (par malloc, calloc ou realloc).

void free(void* adr)

libère la mémoire d’adresse adr. Ce pointeur doit obligatoirement désigner une zone préalablement allouée par malloc, calloc, realloc. Si adr est nul, cette fonction ne fait rien.

Les tableaux dynamiques

Syntaxe : Type *T ;T = (type*) malloc (sizeof(type)*N) ; Avec N étant le nombre

d’éléments du tableau.

Les listes chaînées



Une liste chaînée est une structure comportant des champs contenant des données et un pointeur vers une structure de même type. Ainsi, la structure correspondant à une liste chaînée contenant une chaîne de 15 caractères et un entier ressemble à ceci:

struct Nom_de_la_liste {char Chaine[16];int Entier;struct Nom_de_la_liste * pSuivant;

};

Les arbres

La représentation dynamique non contiguë consiste à créer des nœuds séparément les uns des autres et les relier par le chaînage adéquat pour préciser qu’un nœud donné est fils gauche ou fils droit d’un autre nœud. Ainsi, chaque nœud est constitué de 3 parties : l’information, un pointeur sur le nœud gauche et un pointeur sur le nœud droit.

Exemple :

Pour le cas d’un arbre de caractères, la structure est la suivante :

Typedef struct str{ char info ;str *g, *d ;

} *Arbre p;


d

info

g d

infoinfo

info

gg

g

d

d



Exercice 77Ecrire une procédure qui permet la création en file d’une liste chaînée.

Exercice 78Ecrire une procédure qui permet la création en pile d’une liste chaînée.

Exercice 79Ecrire une procédure qui recherche un élément dans une liste chaînée.

Exercice 80Ecrire une procédure qui insert un élément dans une liste chaînée.

Exercice 81Ecrire une procédure qui élimine un élément d’une liste chaînée.

Exercice 82Ecrire une procédure qui empile un élément dans une pile représentée par une liste chaînée.

Exercice 83Ecrire une procédure qui désempile un élément dans une pile représentée par une liste chaînée.

Exercice 84Ecrire une procédure qui permet la création d’une liste doublement chaînée.

Exercice 85Ecrire une procédure qui recherche un élément dans une liste doublement chaînée.

Exercice 86Ecrire une procédure qui insert un élément dans une liste doublement chaînée.

Exercice 87Ecrire une procédure qui élimine un élément d’une liste doublement chaînée.

Exercice 89Ecrire une fonction qui recherche un élément dans une liste chaînée circulaire.



Exercice 90Ecrire une procédure qui insert un élément dans une liste chaînée circulaire.

Exercice 91Ecrire une procédure qui élimine un élément d’une liste chaînée circulaire.

Exercice 92Un paragraphe est une suite de phrases. Une phrase est une suite de mots qui se termine par un point (‘.’). Deux mots sont séparés par un blanc (‘ ’).Dans cet exercice on représentera un paragraphe par une liste chaînée, et aussi une phrase par une liste chaînée.

1- Ecrire une procédure qui permet la création d’une telle représentation.2- Ecrire une procédure qui permet la recherche de la première occurrence

d’un mot dans le paragraphe. Le résultat de la recherche donne la position de ce mot.

3- Ecrire une procédure qui permet l’insertion d’un mot M1 après un mot M2 donné. Si le mot M2 ne se trouve pas dans le paragraphe, on ne fait pas d’insertion.

4- Ecrire une procédure qui permet l’élimination d’un mot M1 du paragraphe.

5- Ecrire une fonction qui permet la recherche d’une phrase, donnée par son premier mot, dans le paragraphe. Le résultat de la recherche donne la position de cette phrase dans le paragraphe.

6- Ecrire une procédure qui permet l’insertion d’une phrase ph1 après une phrase ph2 donnée. Si la phrase ph2 ne se trouve pas dans le paragraphe, on insert ph1 à la fin du paragraphe.

7- Ecrire une procédure qui permet l’élimination d’une phrase ph1 du paragraphe.

Exercice 93Ecrire la procédure du parcours d’un arbre binaire en préordre.

Exercice 94Ecrire la procédure du parcours d’un arbre binaire en postordre.

Exercice 95Ecrire la procédure du parcours d’un arbre binaire en ordre.

Exercice 96



Ecrire une fonction qui recherche un élément dans un arbre ordonné horizontalement.

Exercice 97Ecrire une procédure qui insert un élément dans un arbre ordonné horizontalement.

Exercice 98Ecrire une procédure qui supprime un élément dans un arbre ordonné horizontalement.


Les fichiers

LES FICHIERS

Dans tous les langages de programmation, on utilise la notion de fichier. Il s'agit d'enregistrer des données sur un support plus durable (disquette, disque dur, etc.).

Les principales manipulations sur un fichier sont :- L'ouverture du fichier - La lecture ou l’écriture d'un élément du fichier - Le déplacement sur le fichier.- La fermeture du fichier.

Des erreurs de manipulation d'un fichier peuvent survenir. En particulier, on a comme erreurs classiques :

- La tentative d'ouvrir en lecture un fichier qui n'existe pas.- La tentative de lire au delà de la fin d'un fichier.- La tentative d'écrire sur une disquette déjà pleine ou sur un fichier protégé

en écriture.

Dans la majorité des langages de programmation, on distingue deux types de fichiers: les fichiers textes et les fichiers binaires.

Fichier texte

La tête de lecture et d'écriture se trouve sur un octet et cet octet est interprété comme un caractère en code ASCII. On a alors ce qu'on appelle un fichier texte. Un texte est en général divisé en lignes, marquées par des caractères de fin de ligne et terminé par un code de fin de fichier. Un fichier texte peut se lire caractère par caractère ou ligne par ligne.

Fichier binaire

La tête de lecture et d'écriture recouvre une variable, d'un type quelconque (réel, double, structure, tableau, etc.) codée sur n octets comme en mémoire centrale. On parle alors de fichier binaire. Une opération de lecture lit en bloc tous les octets constituant cette variable.

I. En langage Pascal

En Pascal, un type fichier est défini par le mot réservé "File Of" suivi du type des composantes de ce fichier.


Les fichiers

Exemple :Type Fic_mess = File Of string[80] ; Fic_pers = File Of Record

Nom, prn:string[14];Doti:string[6];

End;

I.1 Opérations sur les fichiers

Soit filvar un identificateur de variable de type fichier.

Expression Commentaires

Assign(filval,str)

str est une expression chaîne résultant en tout nom légal de fichier. Le nom du fichier est affecté à la variable filval et toutes les opérations suivantes sur filval affecteront le fichier disque (externe) str. Assign ne doit jamais être utilisée sur un fichier en cours d’utilisation.

Rewrite(filval)

un nouveau fichier disque dont le nom est assigné à la variable filval est crée et préparé pour le traitement. Le pointeur de fichier est placé au début de celui-ci (c’est-à-dire : sur l’enregistrement numéro 0). Un fichier disque crée par Rewrite est vide.

Reset(filval)

le fichier disque affecté à la variable filval est préparé pour le traitement. Le pointeur de ce fichier est positionné sur le composant numéro 0. filval doit référencer un fichier existant, sinon il se produira une erreur d’entrée/sortie.

Read(filval,var)

var représente une ou plusieurs variables de même type que les éléments de filval. Chaque variable est lue sur le fichier disque. Après chaque opération de lecture le pointeur de fichier est avancé sur le composant suivant.

Write(filval,var)

var représente une ou plusieurs variables de même type que les éléments de filval. Chaque variable est écrite sur le fichier disque. Après chaque opération d’écriture le pointeur de fichier est avancé sur le composant suivant.

Seek(filval,n)déplace le pointeur de fichier sur le nième composant du fichier référencé par filval. N est une expression entière.

Filesize(filval) retourne le nombre de composants d’un fichier.Close(filval) le fichier disque associé à filval est fermé et le répertoire du

disque est mis à jour. Pour tenir compte des modifications apportées au fichier, il est nécessaire de fermer un fichier


Les fichiers

Expression Commentairesaprès traitement.

Eof(filval)fonction booléenne qui retourne vraie si le pointeur de fichier est positionné à la fin du fichier disque.

Filepos(filval)fonction entière retournant la position courante du pointeur de fichier.

Remarque : un paramètre formel de type fichier doit être toujours donné par adresse.

I.2 Les fichiers textes

Déclaration

La déclaration d’un fichier texte se fait par le mot réservé Text. Exemple : var fich_text : Text ;

Opérations sur les fichiers textes

Toute opération sur les fichiers textes doit être précédée par un appel à la procédure Assign, Un appel à Reset ou Rewrite doit précéder toute opération de lecture ou d’ecriture.

Rewrite permet de créer un nouveau fichier texte et la seule opération autorisée est l’ajout de nouveaux éléments à la fin de ce fichier.

Reset est utilisée pour ouvrir un fichier existant en lecture, la seule opération permise sur ce fichier est la lecture séquentielle. Lorsqu’un nouveau fichier texte est fermé, une marque de fin de fichier est mise à la fin du fichier.

L’entrée et la sortie des caractères dans les fichiers textes s’effectuent par les procédures Read(filvar,c) et Write(filval,c). Les procédures Readln, Writeln et la fonction EoLn permettent le traitement des lignes d’un fichier texte.

Expressions Commentaires

Readln(filvar) ou va au début de la ligne suivante, c’est-à-dire


Les fichiers

Expressions Commentaires

readln(filvar,st1,st2,..,stn) écarte tous les caractères jusque et y compris la séquence CR/LF (la marque de la fin de ligne).

Writeln(filvar) ou writeln(filvar,st1,..,stn)

écrit une marque de fin de ligne, c’est-à-dire une séquence CR/LF dans le fichier texte.

EoLn(filvar)

fonction booléenne retournant vrai si la fin de ligne a été atteinte, c’est-à-dire si le pointeur de fichier est positionné sur le caractère CR de la séquence CR/LF. Si Eof(filvar) est vrai alors EoLn(filvar) est également vrai.

seekEoLn(filvar)similaire à EoLn, mais écarte les espaces et les Tabs avant de faire le test.

Eof(filvar) retourne vrai si le pointeur de fichier est positionné sur la fin de fichier (Ctrl-Z).

SeekEof(filvar) similaire à Eof, mais écarte les espaces, les Tabs et les marques de fin de ligne avant de faire le test.

Append(var filvar :Text) ouvre un fichier texte existant en mode ajout. Après un appel à Append, seule l’écriture est autorisée.

Flush(var filvar :Text)vide la mémoire tampon associée à un fichier texte ouvert en mode écriture.

SetTextBuf(var filvar:Text;var tampon[ ;taille :Word])

assigne un tampon d’entrée/sortie à un fichier texte. Toute variable fichier de type texte dispose d’un tampon mémoire, dont la taille est de 128 octets par défaut. Le tampon est utilisé lors des opérations de lecture et d’écriture. La taille est suffisante pour la plupart des applications. SetTextBuf doit être utilisée juste après Assign.


Les fichiers

Remarques :

Les procédures et fonctions Seek, FilePos et FileSize ne s’appliquent pas aux fichiers textes.

Ctrl-Z a pour code ASCCI 26, CR 13 et LF 10.

II. En langage C

Pour pouvoir manipuler les fichiers en C, on doit déclarer un pointeur sur la structure FILE. Exemple : FILE *sortie ;

II.1 Ouverture et création d'un fichier

La fonction fopen a pour argument deux chaînes de caractères, le nom du fichier et le mode d'ouverture. Elle donne comme résultat un pointeur qui est NULL si l'ouverture a échoué, sinon le pointeur renvoyé est utilisé dans les écritures, les lectures et les déplacements ultérieurs.

Exemple:

#include <stdio.h>FILE *Pointeur_sur_fichier;Pointeur_sur_fichier = fopen("C:\IUT\essai.txt", "wt");

Ouvre (ou crée s'il n'existe pas) un fichier texte nommé essai.txt dans le répertoire IUT du disque C. Les modes de base sont :

"r" (read : lecture) : lecture seulement ; le fichier doit exister. "w" (write : écriture) : écriture seulement. Si le fichier n’existe pas, il est

créé. S’il existe, son ancien contenu est perdu. "a" (append : ajout) : si le fichier existe déjà, il sera étendu. S’il n’existe

pas, il sera créé. "r+" : mise à jour (lecture et écriture). Le fichier doit exister. "t" ou "b" : lorsque l’implémentation distingue les fichiers de texte des

autres, il est possible d’ajouter l’une de ces deux lettres à chacun des modes précédents. La lettre t précise que l’on a affaire à un fichier texte ; la lettre b précise que l’on a affaire à un fichier binaire.

II.2 Ecriture dans un fichier


Les fichiers

fprintf : écriture formatée dans un fichier. Cette fonction est l'équivalent pour un fichier de printf pour les sorties à l'écran. Les formats (précédés du symbole %) sont les mêmes.

Exemple :char erreur;erreur = fprintf(Pointeur_sur_fichier, "Le chiffre %d s'écrit quatre", 4);

Dans un fichier texte

fputc : ce qui signifie "met un caractère dans un fichier". Comme son nom l'indique, cette fonction écrit un octet dans un fichier.

Exemple: char erreur;

erreur = fputc('x', Pointeur_sur_fichier);

fputs : ce qui signifie "met une chaîne dans un fichier". Comme son nom l'indique également, cette fonction écrit une chaîne de caractères dans un fichier.

Exemple :char erreur;erreur = fputs("chaîne de caractère", Pointeur_sur_fichier);

Remarque :

Dans ces deux cas, la variable erreur de type char contient le dernier caractère écrit et EOF si une erreur se présente (fin de fichier, disque plein, etc.).

Dans un fichier binaire

fwrite : écrit dans un fichier des objets d'un type quelconque. Il faut préciser la taille d'un objet (par exemple avec sizeof(objet)), le nombre d'objets à écrire et le pointeur du fichier destination. Cette fois, la fonction renvoie le nombre d'éléments effectivement écrits. Pour tester que tout va bien, il faut comparer le nombre d'éléments écrits avec le nombre d'objets à écrire.

Syntaxe : nombre_d_elements_ecrits = fwrite(ptr_sur_tableau, taille_element, nb_elements, fichier)


Les fichiers

II.3 Lecture dans un fichier

Les opérations de lecture sont les symétriques de celles d'écriture. On retrouve la même classification et à peu près la même syntaxe.

fscanf : lecture formatée analogue à scanf.

Syntaxe : Nb_lu = fscanf(Pointeur_sur_fichier, format, liste de pointeurs); Où : Nb_lu est le nombre d'arguments lus et acceptés. Par exemple : Nb_lu = fscanf(Pointeur_sur_fichier, "%s", Chaîne);

Met dans Chaîne les caractères situés entre le début et la fin de fichier ou le prochain espace blanc. Les espaces blancs initiaux sont automatiquement sautés. Les formats de fscanf sont les mêmes que ceux de scanf.

Dans un fichier texte

fgetc : ce qui signifie "prend un caractère dans un fichier".

Exemple :int caractere;caractere = fgetc(Pointeur_sur_fichier);

fgets : ce qui signifie "prend une chaîne dans un fichier". Lit un certain nombre de caractères dans un fichier et les met dans une chaîne en ajoutant le caractère nul à la fin.

Exemple :fgets(Chaine, 10, Pointeur_sur_fichier);

Lit 10 caractères dans le fichier et les écrits dans Chaine. Un dernier caractère nul est ajouté. Mais, si une fin de ligne (EOL) est rencontrée avant le dixième caractère lu, seuls les caractères avant la fin de ligne seront lus et ils seront suivis dans la chaîne par EOL et NULL.

Dans un fichier binaire

Syntaxe : Nb_lu = fread(pointeur_sur_tableau, taille_element, nb_elements, fichier);

Nb_lu est égal à nb_elements si l'écriture s'est passée sans incident.

Exemple:#include <stdio.h>


Les fichiers

FILE *Pointeur_sur_fichier;fopen("C:\IUT\essai.dta", "wb");int tableau[5];nb = fread(tableau, sizeof(int), 3, Pointeur_sur_fichier);

Lit dans le fichier binaire "essai.dta" des nombres entiers et les range dans les trois premières cellules du tableau ; nb a pour valeur le nombre d'éléments écrits, 3 si tout s'est bien passé.

II.4 Déplacement dans un fichier

int fseek(FILE *flux,long noct,int org): place le pointeur du flux indiqué à un endroit défini comme étant situé à noct octets de l’origine spécifiée par org :org = SEEK_SET correspond au début du fichier.org = SEEK_CUR correspond à la position actuelle du pointeur.org = SEEK_END correspond à la fin du fichier.

long ftell (FILE *flux) : fournit la position courante du pointeur du flux indiqué (exprimée en octets par rapport au début du fichier).

II.5 Fermeture du fichier

int fclose(FILE *flux) : désalloue l’espace mémoire associé au flux concerné et ferme le fichier correspondant. Fournit la valeur EOF en cas d’erreur et la valeur 0 dans le cas contraire.


Exercice 99Ecrire un programme qui permet de créer un fichier d’étudiants.

Exercice 100Ecrire une procédure qui permet de modifier les informations d’un étudiant.


Solutions des exercices

SOLUTIONS DES EXERCICES

Pascal CExercice 1Ecrire un programme qui permet d’afficher le message suivant : mon premier programme.Program afficher ;BeginWriteln(‘mon premier programme’) ;Readln ;End .

#include<stdio.h>#include<conio.h>void main(){ printf("mon premier programme") ; getch() ;}

Exercice 2Ecrire un programme qui demande à l'utilisateur les valeurs de 2 entiers x et y, qui permute leurs valeurs et qui les affiche.Program Echange;var x,y,tmp:integer;begin write('donner deux entiers differents:'); readln(x,y); writeln('x=',x,' et y=' ,y); tmp:=x; x:=y;

#include<stdio.h>#include<conio.h>void main(){ clrscr(); int x,y,tmp; printf("entrez deux nombres: "); scanf("%d %d",&x,&y);



y:=tmp; writeln('x=',x,' et y=',y); readln;end.

printf("avant echange x=%d et y=%d\n",x,y); tmp=x; x=y; y=tmp; printf("apres echange x=%d et y=%d",x,y); getch();}

Exercice 3Ecrire un programme qui échange 3 entiers.Program Echange;var x,y,tmp,z:integer;begin write('donner trois entiers differents:'); readln(x,y,z); writeln('x=',x,' et y=' ,y,’et z=’,z); tmp:=x; x:=y;y :=z ; z:=tmp; writeln('x=',x,' et y=',y,’ et z=’,z); readln;end.

#include<stdio.h>#include<conio.h>void main(){

int x,y,z,tmp;printf("entrez trois nombres: ");scanf("%d %d %d",&x,&y,&z);printf("avant echange x=%d , y=%d et z=%d \

n",x,y,z);tmp=x;x=y;y=z ;z=tmp;printf("apres echange x=%d , y=%d et z=%d

",x,y,z);getch();

}



Exercice 4Ecrire un programme qui demande à l'utilisateur les coordonnées de 2 points distincts du plan et qui affiche les coordonnées du point milieu.

program milieu ;var x1, y1, x2, y2, xm, ym : real ;begin

writeln ('Entrez les coordonnées du premier point') ; readln ( x1 ) ; readln ( y1 );

writeln ('Entrez les coordonnées du deuxième point') ; readln ( x2 ) ; readln ( y2 );

xm := (x1 + x2) / 2 ; ym := (y1 + y2) / 2 ; writeln ('Les coordonnées du point milieu

sont :', xm :5:2, ym:5:2) ;end.

#include<conio.h>void main(){float x1, y1, x2, y2, xm, ym ;printf ("Entrez les coordonnées du premier point") ;scanf("%f %f ",&x1,&y1) ;printf ("Entrez les coordonnées du second point") ;scanf("%f %f ",&x2,&y2) ;xm =(float) (x1 + x2) / 2 ; ym = (float)(y1 + y2) / 2 ; printf("Les coordonnées du point milieu sont : (%5.2f,%5.2f) ", xm, ym);getch() ;}

Exercice 5Ecrire un programme qui demande à l'utilisateur une valeur pour U0, r et n et qui affiche la nième valeur de la suite arithmétique définie par U0 et Un+1 = Un + r. (On rappelle la propriété : Un = U0 + n.r ).program suite ;var U0, Un, r : real ; n : integer ;begin

writeln ('Entrez les valeurs de U0, r et n') ; readln ( U0,r, n );

Un := U0 + n*r;

#include<conio.h>void main(){float U0,Un,r ;int n ;printf("Entrez les valeurs de U0, r et n") ;



writeln ('La ',n:3,'ième valeur de la suite est :', Un :5:2) ;end.

scanf("%f %f %d",&Uo,&r,&n) ;Un = U0 + n*r;printf ("La %d ième valeur de la suite est :%5.2f"', Un) ;getch() ;}

Exercice 6Ecrire un programme qui échange les contenus de 2 données si elles sont de signes contraires.program signe_contraire;var tmp,x,y:integer;begin write('donner deux entiers differents:'); readln(x,y); writeln('x=',x,' et y=' ,y); if x*y <0 then begin tmp:=x; x:=y; y:=tmp; writeln('les deux entiers sont de signes contraires donc apres echange'); writeln('x=',x,' et y=',y); end else writeln('les deux entiers sont de meme signes donc pas d''echange');

#include<stdio.h>#include<conio.h>void main(){clrscr();int x,y,tmp;printf("entrez deux nombres: ");scanf("%d %d",&x,&y);printf("avant echange x=%d et y=%d\n",x,y);if(x*y<0){

tmp=x;x=y;y=tmp;printf("les 2 nombres sont de signes contraires

donc apres echange x=%d et y=%d",x,y);}else

printf("les 2 nombres sont de meme signes donc



readln;end.

pas de changement");getch();}

Exercice 7Ecrire un programme qui échange les contenus de 2 données si elle sont de signes contraires, sinon, il met leur produit dans le premier et la somme dans le deuxième program somme_produit;var tmp,x,y:integer;beginwrite('donner deux entiers:'); readln(x,y); writeln('x=',x,' et y=' ,y); if x*y<0 then begin tmp:=x; x:=y; y:=tmp; end else begin tmp:=x; x:=y*x; y:=y+tmp; end; writeln('apres operation'); writeln('x=',x,' et y=',y);

#include<stdio.h>#include<conio.h>void main(){clrscr();int x,y,tmp;printf("entrez deux nombres: ");scanf("%d %d",&x,&y);printf("avant echange x=%d et y=%d\n",x,y);if(x*y<0){

tmp=x;x=y;y=tmp;printf("les 2 nombres sont de signes contraires

donc apres echange x=%d et y=%d",x,y);}else{

tmp=x;x=x*y;y=y+tmp;



readln;end.

printf("les 2 nombres sont de meme signes donc leur produit est x=%d \net leur somme est y=%d",x,y);}getch();}

Exercice 8Ecrire un programme qui étant donnée un mois et son premier jour, affiche le premier jour du mois suivantprogram premier_jour;var nbj,annee,mois,premj:integer;begin write('entrer une annee de votre choix:'); readln(annee); write('entrer un mois et son premier jour:'); readln(mois,premj); case mois of 1,3,5,7,8,10,12: nbj:=31; 4,6,9,11: nbj:=30; 2: begin if annee mod 100 = 0 then annee:=annee div 100; if annee mod 4 = 0 then nbj:=29 else nbj :=28; end; end; premj:=(premj+nbj) mod 7; writeln('le premier jour du mois suivant

#include<stdio.h>#include<conio.h>void main(){clrscr();int biss,nbj,premj,M,A;printf("donnez une annee de votre choix:");scanf("%d",&A);printf("donnez un mois et son premier jours:");scanf("%d %d",&M,&premj);

if (A % 100==0) A=A/100;if (A % 4==0) biss=0;else biss=1;

switch (M){case 1 :case 3 :case 5 :case 7 :case 8 :



est:',premj);

readln;end.

case 10:case 12: nbj=31;

break;case 4 :case 6 :case 9 :case 11: nbj=30;

break;case 2 :

if (bissextile(A)) nbj=28;else nbj=29;break;

}

premj=(premj+nbj)%7; printf("\nle premier jour du mois suivant est:

%d",premj) ; getch();

}Exercice 9Ecrire un programme qui calcule la somme des N premiers termes positifsprogram somme;var N,i,s:integer;begin write('entrer un nombre positif:'); readln(N);


clrscr();



s:=0; if N>0 then for i:=1 to N do s:=s+i; writeln('la somme de N premiers termes positifs:',N);; readlnend.

int N,i,S;printf("donnez un entier positif:

");scanf("%d",&N);S=0;if(N>0) {

for(i=1 ;i<=N;i++)S=S+i;

}printf("la somme des %d premiers termes

positifs est:%d ",N,S);

getch();}

Exercice 10Ecrire un programme qui calcule la somme des N premiers termes positifs impairesprogram som_impaire;var N,i,s:integer;begin write('entrer un entier positif:'); readln(N); i:=1;s:=0; while(i<2*N) do begin s:=s+i; i:=i+2; end;

include<stdio.h>#include<conio.h>void main(){

clrscr();int N,i,S;printf("donnez un entier positif:

");scanf("%d",&N);S=0;i=1;while(i<=2*N-1){



writeln('somme de ',N,' premiers termes positifs impaires est: ',s); readln;end.

S=S+i;i=i+2;

}printf("la somme des %d premiers termes

positifs impaires est:%d ",N,S);getch();}

Exercice 11Ecrire un programme qui calcule la somme des N premiers termes positifs pairs nom multiple de 3program som_paires;var N,i,s,cp:integer;begin write('entrer un entier positif:'); readln(N); i:=0;s:=0;cp:=0; while(cp<N) do begin i:=i+2; if (i mod 3 <> 0) then begin s:=s+i; cp:=cp+1; end; end; writeln('somme de ',N,' premiers termes positifs non multiples de 3 est: ',s); readln;


clrscr();int N,i,S,cp;printf("donnez un entier positif:

");scanf("%d",&N);S=0;i=0;cp=0;while(cp<N){

i=i+2;if(i%3!=0){

S=S+i;cp=cp+1;

}}



end. printf("la somme des %d premiers termes positifs impaires non multiple de 3 est:%d ",N,S);

getch();}

Exercice 12Ecrire un programme qui calcule la somme 1/2 + 1/4 + 1/8 +…+1/2n (n Є N*)program calcul;var n,i:integer; s,u:real;begins:=0;u:=1/2;i:=1;write('donner un entier non nul: ');readln(n);while i<=n do begin s:=s+u; u:=u/2; i:=i+1; end;writeln('la somme est: ',s:10:5);readln;end.

#include<stdio.h>#include<conio.h>#include<math.h>#include<stdlib.h>void main(){

clrscr();float s,u;int i,n;s=0;u=(float)1/2;i=1;printf("donnez un entier positif non

nul:");scanf("%d",&n);while(i<=n){

s=s+u;u=u/2;i=i+1;

}printf("la somme est: %f",s);



getch();}

Exercice 13Ecrire un programme qui calcule la somme 1+1/2-1/4+ 1/8-1/16+…±1/2n (n Є N*)program calcul;var n,i:integer; s,u:real;beginwrite('donner un entier non nul: ');readln(n);i:=1;S:=1;u:=1/2;while i<=n do begin if i mod 2=0 then s:=s-u else s:=s+u; u:=u/2; i:=i+1;

end;writeln('la somme est: ',s:10:5);readln;end.


clrscr();float s,u;int i,n;s=1;u=(float)1/2;i=1;printf("donnez un entier positif non

nul:");scanf("%d",&n);while(i<=n){

if(i%2==0) s=s-u;else s=s+u;u=u/2;i=i+1;

}printf("la somme est: %f",s);getch();

}Exercice 14



Ecrire un programme qui donne le nombre N tel que la série 1+1/2-1/3+1/4- 1/5+…±1/N donne un résultat égal (à 1/100 près) à 1,33program calcul;var S:real; i:longint;begin S:=1; i:=1; while abs(S - 1.33) > 0.001 do begin if (i mod 2=0) then S:=S-(1/(i+1)) else S:=S+(1/(i+1)); i:=i+1; end; write('le nombre tel que la serie donne un resultat = 1,33 est:',s:10:5) ; readln;end.

#include<stdio.h>#include<conio.h>#include<math.h>void main(){clrscr();float s,n;long int i;s=1;i=1;

while( fabs(s-1.33)>0.001){

n=(float)1/(i+1);if (i%2==0) s=s-n;else s=s+n;i=i+1;

}printf("la valeur approche de 1,33 est : %f",s);getch();

}Exercice 15Ecrire un programme qui donne la plus grande valeur inférieure à 1000 de la somme 1+2+4+8+…+2N program calcul;var u,s:integer;

#include<stdio.h>#include<conio.h>



beginu:=2;s:=1;while s<1000 do begin s:=s+u; u:=u*2; end; s:=s-(u div 2);writeln('la plus grande valeur inferieur a 1000 de la somme est: ',s);readln;end.

void main(){

clrscr();int s,u;s=1;u=2;while(s<1000){

s=s+u;u=2*u;

}s=s-u/2;printf("la plus grande valeur inferieur a 1000 est:

%d",s);getch();

}Exercice 16Ecrire un programme qui calcule la somme 1+x+x2+…+xn (x réel et n entier).program calcul;var x,s,u:real; n,i:integer;beginwrite('donner un reel et un entier:');readln(x,n);i:=1;s:=1;u:=x;

#include<stdio.h>#include<conio.h>#include<math.h>void main(){

clrscr();float s,x,u;int n,i;

printf("donnez un reel et un entier :");



while i<=n do begin s:=s+u; u:=u*x; i:=i+1; end;writeln('la somme est: ',s:10:5);readln;end.

scanf("%f %d",&x,&n);s=1;u=x;for(i=1;i<=n;i++){

s=s+u;u=u*x;

}printf("la Somme est:%f",s);getch();

}Exercice 17Calcul approché de Soient les deux suites: An+1= (An+Gn)/2 et Gn+1=2AnGn/(An+Gn) avec A0=x et G0=1, on montre que lim An=lim Gn=

n∞ n∞Ecrire un programme qui donne la valeur de avec une précision relative Є=10-6, c’est à dire |An-Gn|/|Gn|<Є

program racine_carre;var x,A,G,B:real;begin write('donner un nombre non nul: '); readln(x); A:=x; G:=1; while abs((A-G)/G)>0.000001 do begin

#include<stdio.h>#include<conio.h>#include<math.h>void main(){

clrscr();float x,A,B,G;printf("donner un nombre non nul:");scanf("%f",&x);



B:=A; A:=(A+G)/2; G:=2*B*G/(B+G); end; writeln('la racine de ',x:10:5,' est: ',A:10:5); readln;end.

A=x;G=1;while(fabs((A-G)/G)>0.000001){

B=A;A=(A+G)/2;G=2*B*G/(B+G);

}printf("la racine de %f est : %f",x,A);getch();

}Exercice 18Sachant que la somme 1-1/3+1/5-1/7+1/9... tend vers ∏/4. écrire un programme donnant le nombre ∏ à 10-6 près program pi;var s,t:real; i:integer;begin s:=4; i:=1; t:=1/3; while t>0.000001 do begin t:=4/(2*i+1); if i mod 2=0 then s:=s+t else s:=s-t;


clrscr();float s,t;int i;s=4;t=(float)1/3;i=1;while(t>0.000001){

t=(float)4/(2*i+1);if (i%2==0) s=s+t;



i:=i+1; end; writeln('pi =',s:10:5); readln;end.

else s=s-t;i=i+1;

}printf("la valeur de pi est:%f",s);getch();

}Exercice 19Le développement limité de la fonction sinus au voisinage de zéro est : sin x= x - x3/3! + x5/5! -…+(-1)p x2p+1/(2p+1)!+… Ecrire un programme qui calcule sin x à 10-6 près.program sinx;var s,x,u,t:real; v,i:integer;beginwrite('donner un nombre:');readln(x);s:=0;u:=x;v:=1;i:=1;t:=u/v;while t>0.000001 do begin if i mod 2=0 then s:=s-(u/v) else s:=s+(u/v); u:=u*x*x; v:=(2*i+1)*2*i*v;


clrscr();float s,u,x,v,t;int i,n;printf("donner un nombre:");scanf("%f",&x);s=0;u=x;v=1;i=1;t=(float)u/v;while (t>0.000001 ){

if (i%2==0) s=s+u/v;else s=s-u/v;



i:=i+1; t:=u/v; end; writeln('le sinus de ',x:10:5,'est: ',s:10:5); readln;end.

u=u*x*x;v=(2*i+1)*2*i*v;i++;t=(float)u/v;

}printf("sinus de %f=%f",x,s);getch();

}

Exercice 20 Ecrire un programme qui calcule la somme, le produit et la différence de deux données numériques.program operation;var x,y:integer; op:char;beginwriteln('donner deux nombres x et y');readln(x,y);writeln('donner un op‚rateur');readln(op);case(op) of'/': begin if y<>0 then writeln('la division de x par y est ‚gale …:',x/y) else writeln(' division par z‚ro'); end;'*':writeln('x*y=',x*y);

#include <stdio.h>#include<conio.h>void main(){int x,y;char op;printf("donner le premier operande\n");scanf("%d",&x);printf("donner le deusieme operande\n");scanf("%d",&y);printf("donner l'operateur\n");op=getch();switch(op){case '+': printf("x+y=%d\n",x+y); break;



'+':writeln('x+y=',x+y);'-':writeln('x-y=',x-y);end;readln; end.

case '-': printf("x-y=%d\n",x-y); break;case '*': printf("x*y=%d\n",x*y); break;case '/': if( y!=0) printf("x/y=%f\n",x/y);

else printf(" division par zero\n"); break;}getch();}

Exercice 21écrire un programme qui retourne le code d’une donnée de type CARACTERE.program code_ASCII;var c:char;asci:integer;beginwriteln('donner un caractère:');readln(c);asci:=ord(c);writeln('le code ASCII de ce caractère est:',asci);readln;end.

#include <stdio.h>#include<conio.h>void main(){int asci;char c;printf("donner un caractere\n");scanf("%c",&c);asci='A';printf("%d\n",asci);

getch();}

Exercice 22 Ecrire un programme qui calcule le salaire net d’un employé, sachant que celui-ci a assuré un certain nombres d’heures de travail à un prix fixe par heure, et que l’employeur doit réduire de son salaire des charges qui sont



calculées avec un coefficient donné.program salaire_net_employe;var charges,sb,sn,coef,ph:real; nh:integer;beginwriteln('donner le nombre d''heures de travail de cet employ‚:');readln(nh);writeln('donner le prix d''une heure:');readln(ph);writeln('donner le coefficient:');readln(coef);sb:=nh*ph;charges:=sb*coef;sn:=sb-charges;writeln('le salaire net de cet employ‚ est:',sn);readln;end.

#include <stdio.h>#include<conio.h>void main(){int NH;float NB,SN,SB,coef,PH,charges;

printf("donner le nombre d'heures de travail:\n");scanf("%d",&NH);printf("donner le prix de chaque heure:\n");scanf("%f",&PH);printf("donner le coefficient de reduction:\n");scanf("%f",&coef);SB=NH*PH;charges=SB*coef;SN=SB-charges;printf("la salaire net de cet employe est egal a %f",SN);getch();}

Exercice 23 Ecrire un programme qui permet de reprendre l’exercice précédant en considérant que l’employé a assuré des heures normales, des heures à 25% et des heures à 50%. program salaire_net_supplements;var charges,sb,sn,coef,ph:real; nh25,nh50,nhn:integer;

include<stdio.h>#include<conio.h>void main()



beginwriteln('donner le nombre d''heures … 25% et celui … 50% ainsi que le nombre d''heure normales :');readln(nh25,nh50,nhn);writeln('donner le prix d''une heure:');readln(ph);writeln('donner le coefficient:');readln(coef);sb:=nhn*ph+nh25*ph*125/100+nh50*150/100*ph;charges:=sb*coef;sn:=sb-charges;writeln('le salaire net de cet employ‚ est:',sn);readln;end.

{int NHN,NH25,NH50;float NB,SN,SB,coef,PH,charges;

printf("donner le nombre d'heures normales:\n");scanf("%d",&NHN);printf("donner le nombre d'heures a 25%:\n");scanf("%d",&NH25);printf("donner le nombre d'heures a 50%:\n");scanf("%d",&NH50);printf("donner le prix d'une heure:\n");scanf("%f",&PH);printf("donner le coefficient de reduction:\n");scanf("%f",&coef);SB=(NHN+NH25*(125/100)+NH50+(150/100))*PH;charges=SB*coef;SN=SB-charges;printf("la salaire net de cet employe est egal a %f",SN);getch();}

Exercice 24Ecrire un programme qui retourne si une donnée numérique est paire ou impaire (utiliser le reste de la division par 2).program est_pair;var n:integer;bp:boolean;

#include<stdio.h>#include<conio.h>void main()



beginwriteln('donner un entier positif:');readln(n);bp:=(n mod 2)=0;if bp then writeln('cet entier est pair')else writeln('cet entier n''est pas pair');readln;end.

{int n;printf("donner un entier positif :\n");scanf("%d",&n);if( n % 2 == 0)printf("cet entier est pair.\n");elseprintf("cet entier n'est pas pair.\n");getch();}

Exercice 25 Ecrire un programme qui permet de lire trois données numériques et retourne si la troisième donnée est la somme des deux autres ou pas.program est_somme;var x,y,z:integer; bs:boolean;beginwriteln('donner trois nombres:');readln(x,y,z);bs:=(x+y)=z;if bs then writeln('la trosième donnée est égale à la somme des autres ')else writeln('la trosième donnée n'' est pas égale à la somme des autres ');readln;

#include<stdio.h>#include<conio.h>void main(){int x,y,z;printf("donner trois nombres:\n");scanf("%d%d%d",&x,&y,&z);if(z==x+y)printf("la trosieme donnée est egale a la somme des autres.\n");else printf("la trosieme donnée n'est pas egalea la somme des autres.\n");getch();}



end.Exercice 26Ecrire un programme qui, à partir du salaire brut d’un employé, détermine l’impôt à payer sachant que les règles de calcul des impôts sont comme suit :

salaire brut(SB) l’impôt à payerSB<1500 0%1500<=SB<3000 10% du SB3000<=SB<5000 450+30%(SB-3000)SB>=5000 750+40%(SB-5000)

program impots;var sb,impot:real;begin writeln('donner le salaire brut de cet employé:'); readln(sb);if sb<1500 then writeln('l''impot à payer est de 0%')else begin if sb<3000 then writeln('l''impot à payer est de:',sb*0,1) else begin if sb<5000 then writeln('l''impot à payer est de:',450+30/100*(sb-3000)) else writeln('l''impot à payer est de:',750+40/100*(sb-5000));

#include<stdio.h>#include<conio.h>void main(){float sb;printf("donner le salaire brut de cet employe:\n");scanf("%f",&sb);if (sb<1500)printf("l'impot a payer est de 0%.\n");else{ if (sb<3000) printf("l'impot a payer est de:%f\n",sb*0.1);else{ if (sb<5000) printf("l'impot a payer est de:%f\n",450+0.3*(sb-3000)); else printf("l'impot a payer est de:%f\n",750+0.4*(sb-5000));



end; end;readln end.

} }getch();}

Exercice 27 Ecrire un programme qui fournit les racines de l’équation Ax2+Bx+C=0.program eqation ;var a,b,c:integer; delta:real;beginwriteln('donner a, b et c');readln(a,b,c);if a=0 then begin if b=0 then begin if c=0 then writeln('S=R') else writeln('S=VIDE'); end else writeln('la solution est:',-c/b); endelse begin delta:=b*b-4*a*c; if delta>=0 then writeln('les racines de cette équation sont: x1=',(-b-sqrt(delta))/(2*a),'x2=', (-b+sqrt(delta))/(2*a)) else writeln('pas de solution');

#include<stdio.h>#include<conio.h>#include<math.h>void main(){ int a,b,c; float delta;printf("donner a, b et c:\n");scanf("%d%d%d",&a,&b,&c);if (a==0){ if(b=0) { if (c=0) printf("S=R"); else printf("S=VIDE"); } else printf("la solution est:%f",-c/b);}else{ delta=b*b-4*a*c; if (delta>=0)printf("les racines de cette équation sont: x1=%f et x2=



end;readln;end.

%f",(-b-sqrt(delta))/(2*a),(-b+sqrt(delta))/(2*a));else printf("pas de solution");getch();}}

Exercice 28Ecrire un programme qui, étant donnée une date (jour, mois, année), affiche la date du jour suivant.program jour_suivant;var j,m,a,ms,js,as:integer; biss,dj:boolean;beginwriteln('donner la date d''aujourd''hui:');readln(j,m,a);if( a mod 100)=0 then biss:=(a mod 400)=0else biss:=(a mod 4)=0;case m of 1,3,7,8,10,12:dj:=(j=31); 4,6,9,11:dj:=(j=30); 2:if biss then dj:=(j=29) else dj:=(j=28); end; if dj then begin js:=1; if m=12 then begin ms:=1; as:=a+1;

#include<stdio.h>#include<conio.h>void main(){clrscr();int j,m,a,js,ms,as,dj,biss;printf("donnez la date d'aujourd'hui: ");scanf("%d %d %d",&j,&m,&a);if (a % 100==0) a=a/100;

if (a % 4==0) biss=0;else biss=1;

switch (m){case 1 :case 3 :case 5 :case 7 :case 8 :case 10:case 12: dj=(j==31);



end else begin ms:=m+1; as:=a; end; end else begin js:=j+1; ms:=m; as:=a; end;writeln('le jour suivant est :',js,'/',ms,'/',as);readln;end.

break;case 4 :case 6 :case 9 :case 11: dj=(j==30);

break;case 2 :

if(biss) dj=(j==28);else dj=(j==29);break;

} if (dj) { js=1; if(m==12){ ms=1; as=a+1; } else{ ms=m+1; as=a; } } else{ js=j+1; ms=m; as=a;



} printf("\nle jour suivant

est:%d/%d/%d",js,ms,as) ; getch();

}Exercice 29Ecrire un programme qui, étant donnée une date (jour, mois, année), affiche la date du jour précédant.program jour_precedant;var nj,j,m,a,mp,jp,ap:integer; biss:boolean;beginwriteln('donner la date d''aujourd''hui:');readln(j,m,a);if( a mod 100)=0 then biss:=(a mod 400)=0else biss:=(a mod 4)=0;if m=1 then m:=13;case m-1 of 1,3,7,8,10,12:nj:=31; 4,6,9,11:nj:=30; 2:if biss then nj:=29 else nj:=28; end; if j=1 then begin if m=1 then begin ap:=a-1; jp:=nj;

#include<stdio.h>#include<conio.h>void main(){ int nj,j,m,a,mp,jp,biss,a,p;printf("donner la date d'aujourd'hui:\n");scanf("%d%d%d",j,m,a); if(( a % 100)==0)) biss=(a % 400)==0; else biss=(a % 4)==0; if m==1 m=13; switch(m-1) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: nj=31; case 4:



mp:=12;

end else begin mp:=m-1; ap:=a; jp:=nj; end; end else begin jp:=j-1; mp:=m; ap:=a; end;writeln('le jour précédant est :',jp,'/',mp,'/',ap);readln;end.

case 6: case 9: case 11:nj=30; case 2: if (biss) nj=29; else nb=28; } if (j==1) { if (m==1) { ap=a-1; jp=nj; mp=12; } else { mp=m-1; ap=a; jp=nj; } else { jp=j-1; mp=m; ap=a; } printf("le jour precedant est :%d/%d/%d",jp,mp,ap); getch(); }}



Exercice 30Ecrire un programme qui calcule la somme 5+6+7+….+N (N>=5).Program Somme_entiers;var N,i,S:integer;beginwriteln('donner un entier >=5:');readln(N);S:=0;i:=5;while i<=N dobeginS:=S+i;i:=i+1;end;writeln('la somme est égale à’,S);readln;end.

#include<stdio.h>#include<conio.h>void main(){ int N,i,S; printf("donner un entier >=5:\n"); scanf("%d",&N); S=0; i=4; while(i<N) { i=i+1; S=S+i; }printf("la somme est egale a :%d" ,S);getch(); }

Exercice 31Ecrire un programme qui calcule le produit des N (N>0) premiers entiers positifs.program Produit_Entiers;var P,i,N:integer;beginwriteln('donner un entier >0:');readln(N);if N<=0 then writeln('il faut donner un entier > 0!')else


int p,i,n;printf("Donner un entier >0:");scanf("%d",&n);



P:=1;for i:=1 to N doP:=P*i;writeln('le produit des N premiers entiers est :',P);end.

if(n<=0) printf("Il faut donner un entier >0!!");else{

p=1;for(i=1;i<=n;i++) p=p*i;printf("le produit des %d premiers entiers

est:%d",n,p);}getch();

}Exercice 32Ecrire un programme qui calcule la somme 1+1/2+1/4+1/6+…1/2N (N>0).program Serie_Fraction;var i,N:integer;S:real;beginwriteln('donner un entier N>0');readln(N);S:=1;i:=1;repeat begin S:=S+(1/(2*i)); i:=i+1; end;until i=N+1;writeln('S=,'S);


int i,n;float s;printf("Donner un entier >0:");scanf("%d",&n);s=1;i=1;do{

s=s+(float)1/(2*i);i=i+1;

}while(i<=n);printf("la somme est: %f",s);getch();



readln;end.

}

Exercice 33Ecrire un programme qui échange les contenus de trois données numériques si leur somme est paire, sinon il met la somme des trois dans la première donnée, leur produit dans la seconde et la valeur zéro dans la troisième.program echange_cond_trois;uses crt;var s,tmp,x,y,z:integer;beginclrscr;writeln('donner trois entiers:');readln(x,y,z);s:=x+y+z;if(s mod 2)=0 then begin tmp:=x; x:=y; y:=z; z:=tmp; writeln('x=',x,' ','y=',y,' ','z=',z); end

else begin tmp:=x; x:=x+y+z; y:=y*tmp*z; z:=0;

void main(){

clrscr();int x,y,z,tmp,s;printf("Donnez trois entiers:");scanf("%d %d %d",&x,&y,&z);s=x+y+z;if(s%2==0){

tmp=x;x=y;y=z;z=tmp;printf("x=%d,y=%d,z=%d",x,y,z);

}else{

tmp=x;x=x+y+z;y=y*tmp*z;z=0;printf("x=%d,y=%d,z=%d",x,y,z);

}



writeln('x=',x,' ','y=',y,' ','z=',z); end;readln;end.

getch();}

Exercice 34Ecrire un programme qui calcule la somme :1-1/2+1/3-1/4+…+/-1/N program Serie_Alternative;var i,N:integer; S:real; b:boolean;beginwriteln('donner un entier >0');readln(N);S:=1;for i:=2 to N do begin b:=(i mod 2)=0; if b then S:=S-1/i else S:=S+1/i; end;writeln('S=',S);readln;end.

include<stdio.h>#include<conio.h>void main(){

int i,n,b;float s;printf("Donner un entier >0:");scanf("%d",&n);s=1;for(i=2;i<=n;i++){

b=(i%2==0);if(b) s=s-(float)1/i;else s=s+(float)1/i;

}printf("la somme est: %f",s);

getch(); }Les fonctions

Exercice 35Ecrire une fonction paramétrée qui retourne si un nombre donné est premier ou non.



beginS:=0;R:=0;for i:=1 to N-1 doif N mod i = 0 then S:=S+i;for j:=1 toM-1 doif M mod j = 0 then R:=R+j;Amis:=((M=S) and (N=R));end;

{int s,r,i,j;r=0;s=0;for(i=1;i<N;i++)

if(N%i==0) s+=i;for(j=1;j<M;j++)

if(M%j==0) r+=j;return((M==s)&&(N==r));

}Exercice 38Ecrire une fonction paramétrée qui retourne l’inverse d’un nombre entier donné

function inverse(n:longint):longint;var r,inv:longint;begin inv:=0; while n mod 10 =0 do n:=n div 10; while n mod 10 <>0 do begin r:=n mod 10; inv:=(inv*10)+r; n:=n div 10; end; inverse:=inv;end;

#include<stdio.h>#include<conio.h>long inverse(long n){

long r,inv;inv=0;

while(n%10==0) n=n/10;while(n%10!=0){

r=n%10;inv=(inv*10)+r;n=n/10;

}return(inv);



}

Exercice 39Ecrire une fonction récursive permettant de calculer le PGDC de deux nombres entiers positifs A et B.function pgdc(a,b:integer):integer;beginif a>b then pgdc:=pgdc(a-b,b)else if a<b then pgdc:=pgdc(a,b-a)else pgdc:=a;end;

#include<stdio.h>int pgdc(int A,int B){

if(A>B) return(pgdc(A-B,B));else if(A<B) return(pgdc(A,B-A));else return A;

}Exercice 40Ecrire une fonction récursive permettant de calculer le PPMC de deux nombres entiers positifs A et B.function calcul_ppmc(A:integer,B:integer):integer;var multiple,k:integer;beginif A<B then ppmc:=ppmc(B,A)else begin multiple:=A; k:=2; endwhile multiple mod B<> 0 do begin multiple:= A*k; k:=k+1;

#include<stdio.h>int ppmc(int A,int B){

int multiple,k;if(A<B) return(ppmc(B,A));else{

multiple=A;k=2;while(multiple%B!=0){

multiple=A*k;k++;

}return(multiple);



end;

ppmc:=multiple; end;end;

}}

Exercice 41Ecrire une fonction récursive qui permet de calculer le factoriel d’un nombre donné.function Factoriel(N:integer):integer;beginif N=0 then factoriel:=1elsefactoriel:= N*factoriel(N-1);end;

include<stdio.h>long fact(int n){

if(n>1) return(fact(n-1)*n);else return 1;

}

Exercice 42Ecrire une fonction récursive qui permet de calculer la puissance d’un entier donné. function puissance(N:integer,k:integer):longint;beginif k=0 then puissance:=1elsepuissance:=N*puissance(N,k-1);end;

#include<stdio.h>long puiss(int n,int k){

if(k==0) return 1;else return (puiss(n,k-1)*n);

}

Exercice 43Ecrire une fonction récursive qui calcule la valeur de la fonction d’Ackermann « A » définie pour m>0 et n>0 par :



A(m, n)=A((m-1),A(m,n-1)) pour n>0, m>0 ; A(0,n)=n+1 pour n>0; A(m,0)=A(m-1,1) pour m>0 ;function acker(n,m:integer):integer;beginif (m<0) or (n<0) then acker:=0else if n=0 then acker:=m+1 else if m=0 then acker:= acker(n-1,1) else acker:=acker(n-1,acker(n,m-1))end;

#include<stdio.h>#include<conio.h>int acker(int n,int m){

if((m<0)||(n<0)) return 0;else if(n==0) return (m+1);else if(m==0) return(acker(n-1,1));else return(acker(n-1,acker(n,m-1)));

}Exercice 44Ecrire une fonction qui fournit le nombre de chiffres d’un entier donné.function NCHIFFRES (N:longint):integer;var I:integer;begin If N<0 then N:=N*(-1); I:=1; while N>10 do begin N:=N div 10; I:=I+1; end; NCHIFFRES:=I;

int NCHIFFRES(long N){int I; if (N<0) N *= -1;for (I=1; N>10; I++) N /= 10; return I;}



End;Les procédures

Exercice 45Ecrire une procédure qui permet de dessiner la lettre X, à l'aide d'espaces et d'une "lettre" fournie par l'utilisateur, auquel on demande aussi la "hauteur" du dessin qu'il désire obtenir. Avec les réponses : a et 5, elle donnera : a a a a a a a a aprocedure DessX(hauteur:integer;lettre:char);

var no_ligne,i:integer;begin for no_ligne:=1 to ((hauteur+1) div 2)-1 do begin for i:=1 to no_ligne-1 do write(' '); write(lettre); for i:=0 to (hauteur-2*no_ligne)-1 do write(' '); write(lettre); writeln; end;for i:=1 to ((hauteur+1) div 2)-1 do

void DessX(int hauteur,char lettre){ int no_ligne,i;for(no_ligne=1;no_ligne<((hauteur+1)/2);no_ligne++) { for (i=1;i<no_ligne;i++) printf("%c",' '); printf("%c",lettre); for(i=0;i<hauteur-2*no_ligne;i++) printf("%c",' '); printf("%c",lettre); printf("\n"); } for(i=1;i<(hauteur+1)/2;i++) printf("%c",' '); printf("%c",lettre);



write(' '); write(lettre); writeln; for no_ligne:=1 to ((hauteur+1) div 2)-1 do begin for i:=0 to ((hauteur-2*no_ligne-1) div 2)-1 do write(' '); write(lettre); for i:=0 to (2*no_ligne-1)-1 do write(' '); write(lettre); writeln; end;end;

printf("\n"); for(no_ligne=1;no_ligne<((hauteur+1)/2);no_ligne++) { for (i=0;i<(hauteur-2*no_ligne-1)/2;i++) printf("%c",' '); printf("%c",lettre); for(i=0;i<2*no_ligne-1;i++) printf("%c",' '); printf("%c",lettre); printf("\n"); }}

Exercice 46Soit un programme qui visualise un menu composé de trois rubriques : Hors d’œuvre, plat chaud et dessert.Ecrire une procédure qui permet d’effectuer, à chaque fois, un choix exclusif. program menu;uses crt;procedure Plat(choix1,choix2,choix3:string);var choix:char;begin choix:=readkey; writeln; write('-',choix,'-'); if choix=choix1[1] then writeln(choix1)

#include<stdio.h>#include<conio.h>void plat(char choix1[10],char choix2[10],char choix3[10]){

char choix;choix=getch();printf("-%c-",choix);if(choix==choix1[0]) printf("%s",choix1);



else if choix=choix2[1] then writeln(choix2) else if choix=choix3[1] then writeln(choix3);end;begin clrscr; plat('soupe','crudit','oeuf Dur'); plat('steak','poulet','hamburger'); plat('gateau','poire','fromage'); readln;end.

if(choix==choix2[0]) printf("%s",choix2);if(choix==choix3[0]) printf("%s",choix3);

}

Exercice 47Ecrire une procedure paramétrée, qui permet l’échange des contenus de deux paramètres formels par valeur A et B. Appeler cette procédure dans un programme principal.On écrira les résultats dans le corps de la procédure, et dans le programme principal.program exchange;var A:real; B: real;procedure echange(x,y:real);var temp:real;begin writeln('Ecange:',x:10:2,y:10:2); temp:=x; x:=y; y:=temp; writeln('Echange:',x:10:2,y:10:2);end;

include<stdio.h>#include<conio.h>void echange(float x,float y){

float temp;printf("Echange:%10.2f %10.2f",x,y);temp=x;x=y;y=temp;printf("\nEchange:%10.2f %10.2f",x,y);

}void main()



begin readln(A,B); echange(A,B); writeln('Echange:',x:10:2,y:10:2); readln;end.

{clrscr();float A,B;scanf("%f %f",&A,&B);echange(A,B);printf("\nEchange:%10.2f %10.2f",A,B);getch();

}Exercice 48 Ecrire une procedure paramétrée, qui permet l’échange des contenus de deux paramètres formels par adresse A et B. Appeler cette procédure dans un programme principal.On écrira les résultats dans le corps de la procédure, et dans le programme principal.program exchange;var A:real; B:real;procedure echange(var x,y:real);var temp:real;begin writeln('Ecange:',x:10:2,y:10:2); temp:=x; x:=y; y:=temp; writeln('Echange:',x:10:2,y:10:2);end;begin readln(A,B);

#include<stdio.h>#include<conio.h>void echange(float&x,float&y){

float temp;printf("Echange:%10.2f %10.2f",x,y);temp=x;x=y;y=temp;printf("\nEchange:%10.2f %10.2f",x,y);

}void main(){

clrscr();



echange(A,B); writeln('Echange:',x:10:2,y:10:2); readln;end.

float A,B;scanf("%f %f",&A,&B);echange(A,B);printf("\nEchange:%10.2f %10.2f",A,B);getch();

}Exercice 49Ecrire une procédure qui affiche tous les nombres premiers qui sont compris entre 1 et 200.procedure Nombres_premiers; var i,j,nb:integer; begin for j:=1 to 200 do begin nb:=0; for i:=1 to (j div 2) do if( j mod i =0) then nb:=nb+1; if nb=1 then writeln(j); end; end;

Void Nombres_premiers (void){ int i,j,nb ; for(j=1; i<=200;i++){ for(nb=0,i=1;i<=j/2;i++) if (!(j %i) nb++; if( nb==1 ) printf(“%d\n”,j);}}

Exercice 50Ecrire une procédure qui affiche tous les nombres parfaits qui sont compris entre 1 et 200.procedure Nombres_parfaits; var i,j,nb,S:integer; begin for j:=1 to 200 do begin

Void Nombres_parfaits(){ int i,j,S ; for(j=1;j<=200;j++){ for (S=0,i=1;i<=j-1;i++)



S:=0; for i:=1 to j-1 do

if( j mod i =0) then S:=S+I; if S=j then writeln(j); end; end;

{ if (!(j%i)) s+=i; if (s==j ) printf(“%d\n”,j);}}

Exercice 51Ecrire une procédure qui permet d’afficher tous les diviseurs d’un entier N ainsi que leur nombre.procedure Diviseurs(N :integer) ;var i,nb:integer;beginnb:=0;writeln(‘Les diviseurs de ‘,N,’sont :’) ;for i:=1 to N do if N mod i =0 then begin writeln(i); nb:=nb+1; end;writeln(‘Le nombre de diviseurs de ‘,N,’est :’,nb);end ;

void Diviseurs(int N){ int nb=0 ; printf(“les diviseurs de % sont \n”,N); for( int i=1 ;i<=N ;i++) if (!(N%i )){ printf(‘’ %d\n”,i); nb+=1;}printf(“le nombre de diviseurs de %d est%d”,N,nb);}

Exercice 52 Affichez un triangle isocèle formé d'étoiles de N lignes (N est fourni au clavier): Nombre de lignes : 8

*



********

****************

************************

***************procedure DessinerTri(L:integer);var k:integer; {compteur des lignes} ESP,I,j:integer; begin for k:=1 to L do begin ESP := L-k; for I:=1 to ESP do write(' '); for j:=1 to 2*k-1 do write('*'); writeln; end; readln; end ;

void DessinerTri(int L){ int i; /* compteur des lignes */ int j; /* compteur des caractères */ int e; /* nombre d'espaces */ for (i=0;i<L;i++) { e = L-i-1; for (j=0 ; j<e ; j++) putchar(' '); for (j=0 ; j<2*i+1 ; j++) putchar('*'); putchar('\n'); } getchar() ;}

Exercice 53Calculer pour une valeur X donnée du type float la valeur numérique d'un polynôme de degré n:P(X) = AnXn + An-1Xn-1 + ... + A1X + A0



Les valeurs de n, des coefficients An, ..., A0 et de X seront entrées au clavier. Utiliser le schéma de Horner qui évite les opérations d'exponentiation lors du calcul:

procedure polynome(N:integer;X:real);var I:integer; A,B:real;beginfor I:=1 to N+1 dobegin writeln('donner le ',I,'eme coefficient'); readln(B); A:=A*X+B; end; writeln(‘Valeur du polynôme pour X = ‘,X,’est :’,A); readln; end;

void polynome(int N, float X){ float A; /* coefficients successifs du polynôme */ float P; /* coefficient courant du terme Horner */ for(P=0.0 ; N>=0 ; N--) { printf("Entrer le coefficient A%d : ", N); scanf("%f", &A); P = P*X + A; } printf("Valeur du polynôme pour X = %.2f : %.2f\n", X, P);}

Exercice 54Ecrire une procédure qui affiche la table des produits pour N variant de 1 à 10 : X*Y I 0 1 2 3 4 5 6 7 8 9 10--------------------------------------------------



0 I 0 0 0 0 0 0 0 0 0 0 01 I 0 1 2 3 4 5 6 7 8 9 102 I 0 2 4 6 8 10 12 14 16 18 203 I 0 3 6 9 12 15 18 21 24 27 304 I 0 4 8 12 16 20 24 28 32 36 405 I 0 5 10 15 20 25 30 35 40 45 506 I 0 6 12 18 24 30 36 42 48 54 607 I 0 7 14 21 28 35 42 49 56 63 708 I 0 8 16 24 32 40 48 56 64 72 809 I 0 9 18 27 36 45 54 63 72 81 9010 I 0 10 20 30 40 50 60 70 80 90 100

program tabMul; CONST MAX= 10; var I,J:integer; begin write(' X*Y I'); for I:=0 to MAX do write(I:4); writeln; writeln('-----------------------------------------------’); for J:=0 to max do begin write(J:7,’ I’); for I:=0 to Max do write(I*J:4);

void tabMul(void) { const int MAX = 10; /* nombre de lignes et de colonnes */ int I; /* compteur des lignes */ int J; /* compteur des colonnes */

/* Affichage de l'en-tête */ printf(" X*Y I"); for (J=0 ; J<=MAX ; J++) printf("%4d", J); printf("\n"); printf("------"); for (J=0 ; J<=MAX ; J++)



writeln; end; readln; end.

printf("----"); printf("\n");

/* Affichage du tableau */ for (I=0 ; I<=MAX ; I++) { printf("%3d I", I); for (J=0 ; J<=MAX ; J++) printf("%4d", I*J); printf("\n"); } }

Les TableauxExercice 55Ecrire une procédure qui affiche les nombres négatifs d’une liste réelleType tab=array[0..50] of real ;

Procedure nbre_negatif(a:tab;n:integer);Var i:integer;Begin for i:=0 to n-1 do if a[i]<0 then writeln(a[i]);End;

void nbre_negatif(float a[],int n){int i; for(i=0;i<n;i++) if(a[i]<0) printf("%f\t",a[i]);}

Exercice 56Ecrire une procédure qui met à zéro la diagonale d’une matrice carrée. type matrice=array[1..50,1..50] of integer;procedure mise_zero(var a:matrice;n:integer);

typedef int ligne[50];typedef ligne matrice[50];



var i:integer;begin for i:=1 to n do a[i,i]:=0;end;

void mise_zero(matrice A,int n){int I; for (I=0; I<n; I++) A[I][I]=0;}

Exercice 57Ecrire une procédure qui affiche l’occurrence d’existence d’un nombre réel dans une liste de nombres réelsType tab=array[0..50] of real ;Procedure occurrence(a:tab;n:integer;nbre:real);Var i,cpt:integer;Begin cpt:=0; for i:=0 to n-1 do if a[i]=nbre then cpt:=cpt+1; writeln(‘L’’occurrence d’’existence du nombre ‘,nbre,’ est ’,cpt) ;End;

void occurrence(float a[],int n,float nbre){int i,cpt; for(i=0,cpt=0;i<n;i++) if(a[i]==nbre) cpt++; printf("L'occurrence d'existence du nombre %f est %d",nbre,cpt);}

Exercice 58Ecrire une procédure qui met le plus petit élément d’une liste au début de celle-ci type tab=Array[0..50] of real;procedure min_debut(var a:tab;n:integer);var i,ind:integer; tmp: real;begin ind:=0; for i:=0 to n-1 do

void min_debut(float a[],int n){int i,ind; float tmp; for(i=1,ind=0;i<n;i++) if(a[i]<a[ind]) ind=i; tmp=a[0]; a[0]=a[ind];



if a[i]<a[ind] then ind:=i; tmp:=a[0]; a[0]:=a[ind]; a[ind]:=tmp;end;

a[ind]=tmp;}

Exercice 59Ecrire une procédure qui met les éléments négatifs d’une liste à gauche et les éléments positifs à droite de la listetype tab=Array[0..50] of real;procedure negatif_gauche(var a:tab;n:integer);var i,j:integer; tmp: real;begin j:=0; for i:=0 to n-1 do if a[i]<0 then begin tmp:=a[j]; a[j]:=a[i]; a[i]:=tmp; j:=j+1; end; end;

void negatif_gauche(float a[],int n){int i,j; float tmp; for(i=0,j=0;i<n;i++) if(a[i]<0) { tmp=a[j]; a[j]=a[i]; a[i]=tmp; j++; } }

Exercice 60Ecrire une procédure qui classe une liste de notes de la plus petite à plus grandetype tab=Array[0..50] of real;procedure tri(var note:tab;n:integer);

void tri(float note[],int n){int i,j,min;



var i,j,min:integer; tmp:real;begin for i:=0 to n-2 do begin min:=i; for j:=i+1 to n-1 do

if note[j]<note[min] then min:=j; if min<>i then begin

tmp:=note[i];note[i]:=note[min];note[min]:=tmp;

end; end;end;

float tmp; for(i=0;i<n-1;i++) { for(min=i,j=i+1;j<n;j++) if(note[j]<note[min]) min=j; if (min!=i) { tmp=note[i];

note[i]=note[min];note[min]=tmp;

} }}

Exercice 61Etant donné N étudiants, leurs notes correspondantes à M matières et leur moyenne. Ecrire une procédure qui affiche à côté de chaque étudiant son classement. type matrice=array[1..50,1..50]of real;procedure moyenne(var m:matrice;tl,tc:integer);var i,j:integer; s:real;begin for i:=1 to tl do begin

void moyenne(float m[50][50],int tl,int tc){float s; int i,j; for (i=0;i<tl;i++)

{s=0; for(j=0;j<tc-2;j++)

s+=m[i][j];



s:=0; for j:=1 to tc-2 do s:=s+m[i,j]; m[i,tc-1]:=s/(tc-2); end;end;

procedure classement(var m:matrice;tl,tc:integer);var te,i,j,cl:integer; p:array[1..50] of integer; arret:boolean;begin for i:=1 to tl do m[i,tc]:=0; arret:=false; cl:=1; repeat begin j:=1; te:=0; while (m[j,tc]<>0) and (j<=tl) do j:=j+1; if m[j,tc]<>0 then arret:=true else begin te:=te+1; p[te]:=j;

m[i][tc-2]=s/(tc-2); }}

void classement(float m[50][50],int tl,int tc){int te,i,cl=1,j,p[50],arret=0; for(i=0;i<tl;i++) m[i][tc-1]=0; do {j=0;te=0; while(m[j][tc-1]!=0 && j<tl) j++; if (m[j][tc-1]!=0) arret=1; else {p[te++]=j; for (j=p[te-1]+1;j<tl;j++) if(m[j][tc-1]==0) {if(m[j][tc-2]>m[p[te-1]][tc-2]) {te=0;

p[te++]=j; } else if (m[j][tc-2]==m[p[te-1]][tc-2]) p[te++]=j; } for(i=0;i<te;i++) m[p[i]][tc-1]=cl; cl+=te; }



for j:= p[te]+1 to tl do if m[j,tc]=0 then if m[j,tc-1]>m[p[te],tc-1] then begin te:=1; p[te]:=j; end else if m[j,tc-1] = m[p[te],tc-1] then begin te:=te+1; p[te]:=j; end; for i:=1 to te do m[p[i],tc]:=cl; cl:=cl+te; end; end; until arret;end;

} while(!arret);}

Exercice 62 Le tri par bulles est un tri par échange. Le principe de base est de réordonner les couples non classés tant qu’ils en existent. La méthode de tri par bulles consiste à parcourir la liste en comparant deux éléments successifs en les permutant s’il y a lieu. Ecrire une procédure qui réalise ce tri. Type tab=array[0..50] of integer ;Procedure echanger(var t:tab;i,j: integer);

void echanger(int t[],int i, int j){int tmp=t[i];



Var tmp:integer;Begin tmp :=t[i]; t[i] :=t[j]; t[j] :=tmp;End;Procedure tri_bulles(var t: tab; n: integer);Var p,k:integer;Begin for k:=0 to n-2 do for p:=n-2 downto k do if t[p+1]<t[p] then echanger(t,p+1,p);End;

t[i]=t[j]; t[j]=tmp;}void tri_bulles (int t[], int n){int k,p; for(k=0;k<=n-2;k++) for(p=n-2;p>=k;p--) if(t[p+1]<t[p]) echanger(t,p+1,p);}

Les chaînes de caractères :Exercice 63Un palindrome est un mot, ou une phrase, lisible indifféremment de la gauche vers la droite ou inversement. Ecrire une fonction qui rend si une chaîne de caractères est un palindrome ou non.Function palindrome(s:string):boolean;Var i,taille :integer; miroir:string;begin taille :=length(s) ; miroir:=’’; for i:= 1 to taille do miroir:=miroir+s[taille-i+1];

int palindrome (char s[]){int i,taille; char miroir[255]; taille=strlen(s); for(i=0;i<taille;i++) miroir[i]=s[taille-i-1]; return(!strncmp(miroir,s,taille));}



palindrome :=(s=miroir) ;end ;

Remarque : Vous devez ajouter la ligne suivante au début de votre programme : #include <string.h>, pour pouvoir utiliser les fonctions strlen et strncmp.

Exercice 64Ecrire une fonction qui retourne la fréquence de présence d’un mot dans une phrase.Function frequence(phrase,mot:string):integer;var cpt,debut:integer;begin cpt:=0; while pos(mot,phrase)<>0 do begin cpt:=cpt+1; debut:=pos(mot,phrase); delete(phrase,1,length(mot)+debut); end; frequence:=cpt;end;

int frequence (char phrase[],char mot[]){int cpt=0; while (phrase=strstr(phrase,mot))

{cpt++; phrase=phrase+strlen(mot); } return(cpt);}Remarque : Vous devez ajouter la ligne suivante au début de votre programme : #include <string.h>, pour pouvoir utiliser les fonctions strlen et strstr.

Exercice 65Ecrire une procédure qui enlève tous les blancs au début d’une phrase et laisse un seul blanc entre les différents mots de la phrase procedure blanc(var s:string);var ind:integer; tmp:string;begin while s[1]=' ' do delete(s,1,1);

void blanc (char s[ ]){ while(s[0]==' ') strcpy(s,s+1); while(s=strchr(s,' ')) { while(*(s+1)==' ') strcpy(s,s+1);



ind:=0; tmp:=s; while pos(' ',tmp)<>0 do begin ind:=pos(' ',tmp)+ind; while s[ind+1]=' ' do delete(s,ind+1,1); tmp:=copy(s,ind+1,length(s)); end;end;

s=s+1; }}Remarque : Vous devez ajouter la ligne suivante au début de votre programme : #include <string.h>, pour pouvoir utiliser les fonctions strcpy et strchr.

Exercice 66Soit un nombre entier positif N. Ecrire une fonction qui donne son équivalent dans une base donnée B (2B16)Function car(n :word) :char ;Begin If n<=9 then car:=chr(n+ord(‘0’)) Else car:=chr(n+ord(‘A’)-10); End;

Function dix_b(n,b:word):string;Var s:string;Begin s:=’’; While n<>0 do Begin s:=car(n mod b)+s;

char car(int n){if (n<=9) return('0'+n);else return(n+'A'-10);}

char* dix_b(int n,int b){char *s,t[40]; strcpy(s,""); while(n!=0) { t[0]=car(n%b); strcpy(t+1,""); strcat(t,s); strcpy(s,t);



n:=n div b; End; dix_b:=s;End;

n=n/b; } return(s);}

Exercice 67Soit N un nombre donné en base B1 (B 10). Ecrire une fonction qui donne son équivalent en base 10.Function valeur (c :char) :word ;Begin If c IN [‘0’..’9’] then valeur:=ord(c)-ord(‘0’) Else If upcase(c) IN [‘A’..’F’] then valeur:=ord(upcase(c))-ord(‘A’)+10;End;

Function b_dix(n:string;b:word):word;Var i:integer; res:word; Begin res:=0; For i:=1 to length(n) do res:=res*b+valeur(n[i]) ; b_dix :=res ;End ;

int valeur(char c){ if((c<='9') && (c>='0')) return(c-'0'); else if ((toupper(c) >='A') && (toupper(c)<='F')) return(toupper(c)-'A'+10);}

int b_dix(char n[],int b){int i,res=0; for(i=0;i<strlen(n);i++) res=res*b+valeur(n[i]); return(res);}Remarque : Vous devez ajouter les lignes suivantes au début de votre programme : #include <string.h> et #include <ctype.h>, pour pouvoir utiliser les fonctions strlen et



toupper.Exercice 68Soit N un nombre donné en base B1. Ecrire une fonction qui donne son équivalent en base B2.procedure baseB(n:string;b1,b2:integer;var r:string);var re:integer;begin baseB:=dix_b(b_dix(n,b1),b2);end;

void baseB(char n[],int b1,int b2,char r[]){ return(dix_b(b_dix(n,b1),b2));}

Exercice 69Si on est amené à réaliser des opérations sur des nombres entiers très grands, on peut utiliser les chaînes de caractères pour représenter ces nombres et ensuite faire l’opération par bloc.Ecrire une procédure pour réaliser l’opération d’addition sur de tels nombres.Function calcul(N1,N2:String):String;var Code,R,V,V1,V2:Integer; N,S,S1,S2:string;begin N:=''; R:=0; While ( N1<>'') or (N2<>'') Do Begin If Length(N1)>4 Then Begin S1:=Copy(N1,Length(N1)-3,4); Delete(N1,Length(N1)-3,4); End Else

char* calcul(char n1[],char n2[]){char s1[100],s2[100],s[100],n[100],t[2]; int r,v; r=0; strcpy(s1,"");strcpy(s2,"");strcpy(s,"");strcpy(n,"");strcpy(t,""); while((strlen(n1)!=0) || (strlen(n2)!=0)) { if(strlen(n1)>=4) { strcpy(s1,n1+strlen(n1)-4); strcpy(n1+strlen(n1)-4,""); }



Begin S1:=N1; N1:=''; End ; If Length(N2)>4 Then Begin S2:=Copy(N2,Length(N2)-3,4); Delete(N2,Length(N2)-3,4); End Else Begin S2:=N2; N2:=''; End ; Val(S1,V1,Code); Val(S2,V2,Code); V:=V1+V2+R; Str(V,S); If Length(S)>4 Then Begin Val(Copy(S,1,1),R,Code); S:=Copy(S,2,Length(S)-1); End Else R:=0; N:=S+N; End;

else { strcpy(s1,n1); strcpy(n1,""); } if(strlen(n2)>=4) { strcpy(s2,n2+strlen(n2)-4); strcpy(n2+strlen(n2)-4,""); } else { strcpy(s2,n2); strcpy(n2,""); } v=atoi(s1)+atoi(s2)+r; strcpy(s1,"");strcpy(s2,"");itoa(v,s,10); if(strlen(s)>4) { strncpy(t,s,1); r=atoi(t); strcpy(s,s+1); } else r=0; strcat(s,n);strcpy(n,s);



Calcul:=Nend;

} return(n);}Remarque : Vous devez ajouter les lignes suivantes au début de votre programme : #include <string.h> et #include <stdlib.h>pour pouvoir utiliser les fonctions strlen, strcat, strcpy, atoi, itoa et strncpy.

Exercice 70Ecrire une procédure qui permet de passer de la représentation d’un nombre en chiffres romains à sa représentation décimale.function ConvDec1(c:char):integer;begin case upcase(c) of 'I':ConvDec1:=1; 'V':ConvDec1:=5; 'X':ConvDec1:=10; 'L':ConvDec1:=50; 'C':ConvDec1:=100; 'D':ConvDec1:=500; 'M':ConvDec1:=1000; end;end;procedure ConvDec(rom:string;var dec:integer);var i,d,dn:integer;begin

int ConvDec1(char c){ switch (toupper(c)) { case 'I': return 1; case 'V': return 5; case 'X': return 10; case 'L': return 50; case 'C': return 100; case 'D': return 500; case 'M': return 1000; }}

void ConvDec(char rom[],int *dec){



dec:=0; d:=ConvDec1(rom[1]); for i:=1 to length(rom)-1 do begin dn:=ConvDec1(rom[i+1]); if(d<dn) then dec:=dec-d else dec:=dec+d; d:=dn; end; dec:=dec+d;end;

int i, d, dn; *dec = 0; d = ConvDec1(rom[0]); for (i = 0; rom[i+1] != '\0'; i++) { dn = ConvDec1(rom[i+1]); if (d < dn) *dec -= d; else *dec += d; d = dn; } *dec += d; }Remarque : Vous devez ajouter la ligne suivante au début de votre programme : #include <ctype.h> pour pouvoir utiliser la fonction toupper.

Exercice 71Ecrire une procédure qui permet de passer de la représentation décimale d’un nombre à sa représentation en chiffres romains.procedure ConvRom(var rom:string;dec:integer);const ntok=13;var tok:integer; const romval:array[1..13]of string[2]=(‘I’,’IV’,’V’,’IX’,’X’,’XL’,’L’,’XC’,’C’,’CD’,’D’,’CM’,’M’); const decval:array[1..13]of

void ConvRom(char rom[], int dec){ int tok; const int ntok = 13; const char *romval[13]={"I","IV","V","IX","X","XL","L","XC","C",



integer=(1,4,5,9,10,40,50,90,100,400,500,900,1000);begin rom:=''; for tok:=ntok downto 2 do begin while dec>=decval[tok] do begin rom:=rom+romval[tok]; dec:=dec-decval[tok]; end; end;end;

"CD","D", "CM", "M"}; const int decval[13] ={1,4,5,9,10,40,50,90,100,400,500,900,1000}; rom[0] = '\0'; for (tok = ntok-1; tok >= 0; tok--) { while (dec >= decval[tok]) { strcat(rom, romval[tok]); dec -= decval[tok]; } }}Remarque : Vous devez ajouter la ligne suivante au début de votre programme : #include <string.h> pour pouvoir utiliser la fonction strcat.

Exercice 72Ecrire une fonction qui retourne le déterminant d’une matrice carrée.const DIM=10;type matrice=array[0..DIM-1,0..DIM-1] of real;procedure det_aux(ma:matrice;var mb:matrice;l,c:integer;n:integer);var i,j,d,e:integer;begin e:=0; for i:=0 to n-1 do begin

#define DIM 10typedef float ligne[DIM];typedef ligne matrice[DIM];float expo(int n){ if(!(n%2)){return (1);} return (-1);}



d:=0; if i<>l then begin for j:=0 to n-1 do if j<>c then begin mb[e][d]:=ma[i][j]; d:=d+1; end; e:=e+1; end; end;end;

function expo(n:integer):real;begin if n mod 2=0 then expo:=1 else expo:=-1;end;

function determinant(m:matrice;l:integer):real;var i:integer; m2:matrice; x:real;begin

void det_aux(matrice ma,matrice mb,int l,int c,int n){int i,j,d,e=0; for(i=0;i<n;i++) { d=0; if(i!=l) { for(j=0;j<n;j++) if(j!=c) {mb[e][d]=ma[i][j]; d++; } e++; } }}

float determinant(matrice m,int l){ int i; matrice m2; float x=0; if(l==1)return (m[0][0]); for(i=0;i<l;i++) {

det_aux(m,m2,i,0,l);



x:=0; if l=1 then determinant:= m[0][0] else begin for i:=0 to l-1 do begin

det_aux(m,m2,i,0,l);x:=x+(expo(i)*m[i][0]*determinant(m2,(l-1)));

end; determinant:=x; end;end;

x=x+(expo(i)*m[i][0]*determinant(m2,(l-1))); } return (x);}

Exercice 73Ecrire une procédure qui calcule l’inverse d’une matrice carrée.procedure transp_mat(ma:matrice;var mb:matrice;n:integer);var i,j:integer;beginfor i:=0 to n-1 do for j:=0 to n-1 do mb[j][i]:=ma[i][j];end;

procedure multi_R(a:real;ma:matrice;var mb:matrice;n:integer);var i,j:integer;

void transp_mat(matrice ma,matrice mb,int n){int i,j;for (i=0;i<n;i++) for (j=0;j<n;j++) mb[j][i]=ma[i][j];}

void multi_R(float a,matrice ma,matrice mb,int n){ int i,j; for(i=0;i<n;i++)



begin for i:=0 to n-1 do for j:=0 to n-1 do mb[i][j]:=ma[i][j]*a;end;

procedure coffacteur(ma:matrice;var mb:matrice;l:integer);var i,j:integer; m2:matrice;begin if l=1 then

mb[0][0]:=1 else begin for i:=0 to l-1 do for j:=0 to l-1 do begin det_aux(ma,m2,i,j,l); mb[i][j]:=expo(i+j)*determinant(m2,(l - 1)); end; end;end;

procedure inverse(ma:matrice;var mb:matrice;l:integer);

for(j=0;j<n;j++) mb[i][j]=ma[i][j]*a;}

void coffacteur(matrice ma,matrice mb,int l){ int i,j; matrice m2; if (l==1)

mb[0][0]=1; else { for (i=0;i<l;i++) for (j=0;j<l;j++) { det_aux(ma,m2,i,j,l); mb[i][j]=expo(i+j)*determinant(m2,(l - 1)); }

}}

void inverse(matrice ma,matrice mb,int l){ matrice m1,m2; float d;



var m1,m2:matrice; d:real;begin d:=(1/determinant(ma,l)); coffacteur(ma,m1,l); transp_mat(m1,m2,l); multi_R(d,m2,mb,l);end;

d=(1/determinant(ma,l)); coffacteur(ma,m1,l); transp_mat(m1,m2,l); multi_R(d,m2,mb,l);}

Exercice 74Un carré magique est un carré divisé en cellules dans lesquelles les nombres entiers, à partir de 1 sont disposés de telle sorte que les sommes de chaque ligne, de chaque colonne et de chaque diagonale soient égales.Exemple :

6 1 87 5 32 9 4

Ecrire une procédure qui permet de réaliser le carré magique.const k=11;type magique=array[1..k,1..k]of integer;

procedure CaMag(var carre:magique;n:integer);var fin,nombre,l,c:integer;begin nombre:=1; l:=1; fin:=n*n; c:=(n+1) div 2;

#define k 11typedef int ligne[k+1];typedef ligne magique[k+1];void CaMag(magique carre,int n){ int fin,nombre=1,l=1,c; fin=n*n; c=(n+1)/2; carre[l][c]=nombre;



carre[l,c]:=nombre; while nombre<>fin do begin if nombre mod n =0 then inc(l) else begin if l=1 then l:=n else dec(l); if c=1 then c:=n else dec(c); end; inc(nombre); carre[l,c]:=nombre; end;end;

while(nombre!=fin) { if(nombre%n==0) l++; else {

if(l==1) l=n; else l--; if(c==1) c=n; else c--;

} nombre++; carre[l][c]=nombre; }}

Les enregistrementsExercice 75Ecrire un programme qui permet de saisir et d’afficher les informations d’une liste d’étudiants.Program gest;

uses crt;Type Date=record J,M,A:Integer; end; etud=record

#include <stdio.h>#include <conio.h>typedef struct{

int j; int m; int a;}date;



Nom,Prn:string[20]; CIN:string[10]; Date_Nais:Date; End;Var TEtud:Array[1..100] of etud; Te:Integer;

Procedure Affich_formul(Titre:String);Begin TextBackground(Blue); ClrScr; TextColor(Yellow); Gotoxy(35,4); Write(Titre); Gotoxy(20,7); Write('Nom :'); Gotoxy(20,9); Write('Pr‚nom :'); Gotoxy(20,11); Write('C.I.N :'); Gotoxy(20,13); Write('Date de Naissance :');End;

Procedure saisie(Var E:Etud);Begin

typedef struct{char nom[21];

char prn[21]; char cin[11]; date date_naiss;}etud;etud tetud[10];int te=0;

void affich_formul(char titre[]){ textbackground(BLUE); clrscr(); textcolor(YELLOW); gotoxy(35,4); cprintf("%s",titre); gotoxy(20,7); cprintf("Nom:"); gotoxy(20,9); cprintf("Prenom"); gotoxy(20,11); cprintf("C.I.N"); gotoxy(20,13); cprintf("Date de naissance");}void saisie(etud *e)



TextColor(White); With E, Date_Nais Do Begin Gotoxy(26,7); Clreol; Readln(Nom); Gotoxy(29,9); Clreol; Readln(Prn); Gotoxy(28,11); Clreol; Readln(CIN); Gotoxy(40,13); Clreol; Readln(J); Gotoxy(42,13); Write('/'); Readln(M); Gotoxy(45,13); Write('/'); Readln(A);End;End;

Procedure Saisietout; Var E:Etud;

{ textcolor(WHITE); gotoxy(26,7); clreol(); scanf("%s",e->nom); gotoxy(29,9); clreol(); scanf("%s",e->prn); gotoxy(28,11); clreol(); scanf("%s",e->cin); gotoxy(40,13); clreol(); scanf("%d",&e->date_naiss.j); gotoxy(42,13); printf("/"); scanf("%d",&e->date_naiss.m); gotoxy(45,13); printf("/"); scanf("%d",&e->date_naiss.a);}void affich(etud e){ textcolor(WHITE); gotoxy(26,7);clreol();cprintf(e.nom); gotoxy(29,9);clreol();cprintf(e.prn);



Rep:Char;Begin Te:=0; Affich_formul('S A I S I E'); Repeat Saisie(E); Te:=Te+1; TEtud[Te]:=E; TextColor(Yellow); Gotoxy(45,17); Write('Voulez-vous continuez (O/N)?'); Rep:=readkey; Gotoxy(45,17); Clreol; Until Rep In ['N', 'n'];End;

Procedure Affich(Var E:Etud);Begin TextColor(White); With E, Date_Nais Do Begin Gotoxy(26,7); Clreol; Write(Nom); Gotoxy(29,9);

gotoxy(28,11);clreol();cprintf(e.cin); gotoxy(40,13);clreol();cprintf("%d/%d/%d",e.date_naiss.j,e.date_naiss.m,e.date_naiss.a);}void saisietout(){ char rep; affich_formul("S A I S I E"); do { saisie(&tetud[te++]); textcolor(YELLOW); gotoxy(45,17); cprintf("Voulez-vous continuez (O/N)?"); fflush(stdin); rep=getchar(); gotoxy(45,17); clreol(); } while((rep!='n') && (rep!='N'));}void affichtout(){ char rep; int i; affich_formul("C O N S U L T A T I O N");



Clreol; Write(Prn); Gotoxy(28,11); Clreol; Write(CIN); Gotoxy(40,13); Clreol;

Write(J,'/',M,'/',A); End;End;

Procedure Affichtout; Var E:Etud; Rep:Char; I:Integer;Begin Affich_formul('C O N S U L T A T I O N'); For i:=1 To Te Do Begin Affich(TEtud[I]); TextColor(Yellow); Gotoxy(45,17); Write('Taper une touche pour continuer'); Rep:=readkey; Gotoxy(45,17);

for(i=0;i<te;i++) { fflush(stdin); affich(tetud[i]); textcolor(YELLOW); gotoxy(45,17); cprintf("Taper une touche pour continuer"); rep=getchar(); fflush(stdin); gotoxy(45,17); clreol(); }}

main(){etud e; saisietout(); affichtout(); clrscr(); getch();}



Clreol; End;End;BEGIN saisietout; Affichtout; ClrScr; Readln;END.Exercice 76Ecrire les procédures qui donnent le calcul sur les nombres complexes au moyen d’un type enregistrement.type complexe=Record a,b:real;end;

procedure zsomme(z1,z2:complexe;var z : complexe);begin z.a:=z1.a+z2.a; z.b:=z1.b+z2.b;end;

procedure zmoins(z1,z2:complexe;var z : complexe);begin z.a:=z1.a-z2.a; z.b:=z1.b-z2.b;end;

typedef struct{float a;

float b;}complexe;

void Zsomme(complexe z1,complexe z2,complexe *z){z->a=z1.a+z2.a; z->b=z1.b+z2.b;}

void Zmoins(complexe z1,complexe z2,complexe *z){z->a=z1.a-z2.a; z->b=z1.b-z2.b;}



procedure zmul(z1,z2 : complexe; var z:complexe);begin z.a:=z1.b*z2.b-z1.a*z2.a; z.b:=z1.a*z2.b+z2.b*z2.a;end;

void Zmul(complexe z1,complexe z2,complexe *z){z->a=z1.b*z2.b-z1.a*z2.a; z->b=z1.a*z2.b+z2.b*z2.a;}

Les listes chaînées1. Les listes simples:

type liste=^element; element=record info:integer; suivant:liste; end;

typedef struct str{int info;str*suivant;

}*liste;

Exercice 77Ecrire une procédure qui permet la création en file d’une liste chaînée procedure creation_file(var tete:liste);var p,q:liste; x:integer; begin new(p); write('donner des entiers (0 pour terminer) : '); readln(x); tete:=nil; while x<>0 do begin

void creer_file(liste &L){

int x;printf("entrer des entiers (0 pour terminer):");scanf("%d",&x);while(x!=0){liste p=(liste)malloc (sizeof(str));p->info=x;p->suivant=NULL;if(L==NULL) L=p;



p^.info:=x; p^.suivant:=nil; if tete=nil then tete:=p else begin q:=tete; while q^.suivant<>nil do q:=q^.suivant; q^.suivant:=p; end; new(p); readln(x); end; end;

else{ liste q=L; while(q->suivant!=NULL) q=q->suivant;

q->suivant=p;}scanf("%d",&x);}

}

Exercice 78Ecrire une procédure qui permet la création en pile d’une liste chaînée procedure creation_pile(var tete:liste);var p:liste; x:integer; begin new(p); write('donner des entiers (0 pour terminer) : '); readln(x); tete:=nil; while x<>0 do

void creer_pile(liste &L){

int x;printf("entrer des entiers (0 pour terminer):");scanf("%d",&x);while(x!=0){liste p=(liste)malloc (sizeof(str));

p->info=x;p->suivant=NULL;



begin p^.info:=x; p^.suivant:=tete; tete:=p; new(p); readln(x); end; end;

if(L==NULL) L=p;else{

p->suivant=L; L=p;}

scanf("%d",&x);}

}

Exercice 79Ecrire une procédure qui recherche un élément dans une liste chaînée function rechercher (tete:liste;x:integer) :liste;var p:liste;begin if tete=nil then recherche:=nil else if tete^.info=x then recherche:=tete else recherche:=recherche(tete^.suivant,x);end;

procedure rech_elt (tete:liste;x:integer; var pred:liste;var pos:liste);begin if tete=nil then begin pos:=nil; pred:=nil; end

liste rechercher(liste L,int x){ if(L!=NULL){

if(L->info==x) return L;else return(rechercher(L->suivant,x));

}else return NULL;

}

void recherch_elt(liste L,int x,liste &pos,liste &pred){

if(L!=NULL){if(L->info==x){

pos=L;pred=NULL;

}



else if tete^.info=x then begin pos:=tete; pred:=nil; end else begin p:=tete; while (p^.suivant<>nil) and (p^.info<>x) do begin pred:=p; p:=p^.suivant; end; if p^.info=x then pos:=p else pos:=nil; end;end;

else{liste p=L;

while((p->suivant! = NULL)&&(p->info!=x)){

pred=p;p=p->suivant;

}if(p->info==x) pos=p;else pos=NULL;}

}}

Exercice 80Ecrire une procédure qui insert un élément dans une liste chaînée procedure inserer(var tete:liste;x:integer;position:liste);var p,q:liste;begin new(q); q^.info:=x; q^.suivant:=nil; if position=tete then

void inserer(liste &L,liste pos,int x){liste p;p=(liste)malloc(sizeof(str));

p->info=x;p->suivant=NULL;if(L!=NULL){



begin q^.suivant:=tete; tete:=q; end else begin q^.suivant:=position; p:=tete; while p^.suivant<>position do p:=p^.suivant;

p^.suivant:=q; end;end;

procedure insere(var tete:liste;x:integer;position:liste;pred:liste);var q:liste;begin new(q); q^.info:=x; q^.suivant:=nil; if position=tete then begin q^.suivant:=tete; tete:=q;

if(pos==L){p->suivant=L;L=p;

}else{

liste q=L; while(q->suivant!=pos)

q=q->suivant;p->suivant=pos;q->suivant=p;

}}

}

void insere(liste &L,liste pos,liste pred,int x){

liste p;p=(liste)malloc(sizeof(str));p->info=x;p->suivant=NULL;if(L!=NULL){

if(pos==L){



end else begin q^.suivant:=position; pred^.suivant:=q; end;end;

p->suivant=L;L=p;

}else{

p->suivant=pos;pred->suivant=p;

}}

}Exercice 81Ecrire une procédure qui élimine un élément d’une liste chaînéeprocedure eliminer(var tete:liste;x:integer);var trouve:boolean; q,p:liste; begin p:=tete; trouve:=false; while(not trouve)and(p<>nil) do begin if p^.info=x then trouve:=true else begin q:=p; p:=p^.suivant; end; end;

void supprimer(liste &L,int x){

int trouve =1;liste p,q;p=L;q=L;while((trouve)&&(p!=NULL)){

if(p->info==x) trouve=0;else {

q=p;p=p->suivant;

}}if(trouve==0){if(p==L) L=p->suivant;



if trouve then if p=tete then tete:=p^.suivant else q^.suivant:=p^.suivant; dispose(p); end;

procedure elimine(var tete:liste;pos:liste;pred:liste);begin if pos=tete then tete:=pos^.suivant else pred^.suivant:=pos^.suivant; dispose(pos);end;

procedure afficher_liste(tete:liste);var p:liste;begin p:=tete; while p<>nil do begin writeln('- ',p^.info); p:=p^.suivant; end;end;

q->suivant=p->suivant;free(p);}

}

void supprime(liste &L,liste pos,liste pred){if(pos==L) L=pos->suivant;else pred->suivant =pos->suivant;free(pos);}

void afficher(liste L){

liste p=L;printf("\n la liste est:\n");while(p!=NULL){

printf("\n%d",p->info);p=p->suivant;

}}

Exercice 82Ecrire une procédure qui empile un élément dans une pile représentée par une liste chaînée



procedure empiler(var tete:liste;x:integer);var p:liste;begin new(p);p^.info:=x;p^.suivant:=tete;tete:=p;end;

void empiler(liste &L,int x){

liste p=(liste)malloc(sizeof(str));p->info=x;p->suivant=L;L=p;

}

Exercice 83Ecrire une procédure qui désempile un élément dans une pile représentée par une liste chaînéeprocedure desempiler(var tete:liste);begin if tete<>nil then begin p:=tete; tete:=tete^.suivant; dispose(p); end;end;

void desempiler(liste &L){

liste p;p=L;L=p->suivant;free(p);

}

2. les listes doublement chainéestype liste=^element; element=record info:integer; suivant,precedent:liste; end;

typedef struct str{int info;str*suivant;str*pred;

}*liste;



Exercice 84Ecrire une procédure qui permet la création d’une liste doublement chaînée procedure creation(var tete:liste;var Queue:liste);var p,q:liste; x:integer; begin new(p); write('donner des entiers (0 pour terminer) : '); readln(x); tete:=nil; while x<>0 do begin p^.info:=x; p^.suivant:=nil; Queue:=p; if tete=nil then begin p^.precedent:=nil; tete:=p end else begin q:=tete; while q^.suivant<>nil do q:=q^.suivant; q^.suivant:=p;

void creation(liste &L,liste &Qu){


p->info=x;p->suivant=NULL;Qu=p;if(L==NULL){

p->pred=NULL;L=p;

}else{

liste q=L;while(q->suivant!=NULL) q=q-

>suivant;q->suivant=p;p->pred=q;

}scanf("%d",&x);

}}



p^.precedent:=q; end; new(p); readln(x); end; end;Exercice 85Ecrire une procédure qui recherche un élément dans une liste doublement chaînée function rechercher(tete:liste;x:integer) :liste;var p:liste;begin if tete=nil then recherche:=nil else if tete^.info=x then recherche:=tete else recherche:=recherche(tete^.suivant,x);end;

function rechercher (tete:liste; Queue:liste;x:integer):liste;begin if tete=nil then rech:=nil else if tete^.info=x then rech:=tete else if Queue^.info=x then rech:=Queue else rech:=rech(tete^.suivant,Queue^.precedent,x);end;

liste rechercher(liste L,int x){

if(L!=NULL){if(L->info==x) return L;else return(rechercher(L->suivant,x));

}else return NULL;

}

liste rechercher(liste L,liste Qu,int x){

if(L->pred!=Qu){if(L->info==x) return L;

else if(Qu->info==x) return Qu; else return(rechercher(L->suivant , Qu->pred,x));



}else return NULL;

}

Exercice 86Ecrire une procédure qui insert un élément dans une liste doublement chaînée procedure inserer(var tete:liste;x:integer;position:liste);var p,q:liste;begin new(q); q^.info:=x; q^.suivant:=nil; if position=tete then begin q^.precedent:=tete^.precedent; q^.suivant:=tete; position^.precedent:=p; tete:=q; end else if position=nil then begin p:=tete; while p^.suivant<>nil do p:=p^.suivant; p^.suivant:=q; q^.precedent:=p;

void inserer(liste&L,int x,liste pos){

liste p=(liste)malloc(sizeof(str));p->info=x;if(L!=NULL){

if(pos==L){

p->pred=NULL;p->suivant=L;L->pred=p;L=p;

}else{

p->suivant=pos;p->pred=pos->pred;pos->pred->suivant=p;pos->pred=p;

}}

}



end else begin q^.suivant:=position; q^.precedent:=position^.precedent; position^.precedent^.suivant:=q; position^.precedent:=q; end;end;

Exercice 87Ecrire une procédure qui élimine un élément d’une liste doublement chaînée procedure eliminer(var tete:liste;position:liste);var q,p:liste; begin if position=tete then begin position^.suivant^.precedent:=nil; tete:=position^.suivant; end else if position^.suivant=nil then position^.precedent^.suivant:=nil else begin position^.precedent^.suivant:=position^.suivant;

void supprimer(liste &L,liste pos){

if(L!=NULL){if(pos==L){

pos->suivant->pred=NULL;L=pos->suivant;free(pos);

}else if(pos->suivant==NULL){

pos->pred->suivant=NULL;free(pos);

}else{

pos->pred->suivant=pos->suivant;



position^.suivant^.precedent:=position^.precedent; end; dispose(position); end;

pos->suivant->pred=pos->pred;free(pos);

}}

}2. Les listes circulaires:type liste=^element; element=record info:integer; suivant:liste; end;var l,p:liste;

typedef struct str{int info;str*suivant;

}*liste;

Exercice 88Ecrire une procédure qui permet la création d’une liste chaînée circulaire procedure creation(var tete:liste);var p,q:liste; x:integer; begin new(p); write('donner des entiers (0 pour terminer) : '); readln(x); tete:=nil; while x<>0 do begin p^.info:=x; if tete=nil then

void creer(liste &L){


p->info=x;if(L==NULL) L=p;else{

liste q=L;while(q->suivant!=L) q=q->suivant;



tete:=p else begin q:=tete; while q^.suivant<>tete do q:=q^.suivant; q^.suivant:=p; end; p^.suivant:=tete; new(p); readln(x); end; end;

q->suivant=p;}p->suivant=L;scanf("%d",&x);}

}

Exercice 89Ecrire une fonction qui recherche un élément dans une liste chaînée circulaire function recherche(tete:liste; x:integer) :liste;var p:liste;beginif tete<>nil thenbegin p:=tete; while (p^.suivant<>tete) and (p^.info<>x) do p:=p^.suivant; if p^.info=x then recherche:=p else recherche:=nil;

liste rechercher(liste L,int x){

if(L!=NULL){liste p=L;do{

if(p->info==x) return p;p=p->suivant;

}while(p!=L);return NULL;

}



end;end;

return NULL;}

Exercice 90Ecrire une procédure qui insert un élément dans une liste chaînée circulaire procedure inserer(var tete:liste;x:integer;position:liste);var p,q:liste;beginif tete<>nil thenbegin new(q); q^.info:=x; if position=tete then begin p:=tete; while p^.suivant<>tete do p:=p^.suivant; p^.suivant:=q; q^.suivant:=tete; tete:=q; end else if position=nil then begin p:=tete; while p^.suivant<>tete do p:=p^.suivant;

void inserer(liste &L,liste pos,int x){

liste q;liste p=(liste)malloc(sizeof(str));p->info=x;if(L!=NULL){

if(pos==L){q=L;p->suivant=L;

while(q->suivant!=L) q=q->suivant;q->suivant=p;L=p;

}else if(pos==NULL){

q=L;while(q->suivant!=L) q=q->suivant;q->suivant=p;p->suivant=L;

}else{



p^.suivant:=q; q^.suivant:=tete; end else begin q^.suivant:=position; p:=tete; while p^.suivant<>position do p:=p^.suivant; p^.suivant:=q; end;end; end;

q=L;while(q->suivant!=pos) q=q-

>suivant;q->suivant=p;p->suivant=pos;

}}

}

Exercice 91Ecrire une procédure qui élimine un élément d’une liste chaînée circulaire procedure eliminer(var tete:liste;position:liste);var q,p:liste;begin if tete<>nil then begin if position=tete then begin p:=tete; while p^.suivant<>tete do p:=p^.suivant; p^.suivant:=tete^.suivant; tete:=tete^.suivant; dispose(position);

void supprimer(liste &L,liste pos){

liste p;if(L!=NULL){

if(pos==L){p=L;while(p->suivant!=L) p=p->suivant;p->suivant=pos->suivant;L=pos->suivant;free(pos);

}else{



end else begin p:=tete; while p<>position do begin q:=p; p:=p^.suivant; end; q^.suivant:=position^.suivant; dispose(position); end; end;end;

p=L;while(p->suivant!=pos) p=p-

>suivant;p->suivant=pos->suivant;free(pos);

}}

}

Exercice 92Un paragraphe est une suite de phrases. Une phrase est une suite de mots qui se termine par un point(‘.’). deux mots sont séparés par un blanc(‘ ’).Dans cet exercice on représentera un paragraphe par une liste chainée, et aussi une phrase par une liste chainnée.

1- Ecrire une procédure qui permet la création d’une telle représentation.2- Ecrire une procédure qui permet la recherche de la première occurrence d’un mot dans le paragraphe. Le

résultat de la recherche donne la position de ce mot.3- Ecrire une procédure qui permet l’insertion d’un mot M1 après un mot M2 donnée. Si le mot ne se trouve

pas dans le paragraphe, on ne fait pas d’insertion.4- Ecrire une procédure qui permet l’élimination d’un mot M1 du paragraphe.5- Ecrire une fonction qui permet la recherche d’une phrase, donnée par son premier mot, dans le

paragraphe le résultat de la recherche donne la position de cette phrase dans le paragraphe.



6- Ecrire une procédure qui permet l’insertion d’une phrase ph1 après une phrase ph2 donnée. Si la phrase ph2 ne se trouve pas dans le paragraphe, on insert ph1 à la findu paragraphe.

7- Ecrire une procédure qui permet l’élimination d’une phrase ph1 du paragraphe.PROGRAM paragraphe;

type ligne=^element; element=record info:string; suivant:ligne; end;type para=^str; str=record line:ligne; suivant:para; end;var L,q:ligne; Pa,p:para;

procedure creation_ligne(var L:ligne);var p,q:ligne; mot:string;begin new(p); writeln('entrer une suite de mots (point"." pour terminer):'); readln(mot);

#include<stdio.h>#include<conio.h>#include<alloc.h>#include<string.h>typedef struct str1{

char info[20];str1*suivant;

}*ligne;typedef struct str2{

ligne line;str2*suivant;

}*para;

void creer_ligne(ligne &L){

char mot[20];printf("Entrer une suite de mots ('.' pour

terminer):");scanf("%s",mot);while(strcmp(mot,".")){

int n=strlen(mot) ;//printf("__%d",n);ligne p=(ligne)malloc(sizeof(str1));



while mot<>'.' do begin p^.info:=mot; p^.suivant:=nil; if L=nil then L:=p else begin q:=L; while q^.suivant<>nil do q:=q^.suivant; q^.suivant:=p; end; readln(mot); new(p); end;end;

procedure afficher_ligne(L:ligne);var p:ligne;begin if L<>nil then begin p:=L; while p^.suivant<>nil do begin write(p^.info,' ' );

//p->info=(char*)malloc(sizeof(char)*n);strcpy(p->info,mot);p->info[n]='\0';p->suivant=NULL;if(L==NULL) L=p;else{

ligne q=L;while(q->suivant!=NULL) q=q-

>suivant;q->suivant=p;

}//free(p->info);scanf("%s",mot);

}}

void afficher_ligne(ligne L){

ligne p=L;while(p->suivant!=NULL){

// strcat(p->info," ");printf("%s ",p->info);p=p->suivant;

}printf("%s.",p->info);

}



p:=p^.suivant; end; write(p^.info,'.'); end;end;

procedure creation_paragraphe(var Pa:para);var p,q:para; L:ligne; rep:string;begin repeat L:=nil; creation_ligne(L); new(p); p^.line:=L; p^.suivant:=nil; if Pa=nil then Pa:=p else begin q:=Pa; while q^.suivant<>nil do q:=q^.suivant; q^.suivant:=p; end; write('voulez vous continuer?(oui/non) ');readln(rep);

void creer_paragraphe(para&Pa){

para p,q;ligne L;char rep;do{

L=NULL;creer_ligne(L);p=(para)malloc(sizeof(str1));p->line=L;p->suivant=NULL;if (Pa==NULL) Pa=p;else{

q=Pa;while(q->suivant!=NULL) q=q-

>suivant;q->suivant=p;

}getchar();printf("voulez vous continuer(o/n)? ");scanf("%c",&rep);

}while(rep=='o');}

void afficher_paragraphe(para Pa)



until (rep='non');end;

procedure afficher_paragraphe(Pa:para);var p:para;begin if Pa<>nil then begin p:=Pa;

while p<>nil do begin afficher_ligne(p^.line); writeln; p:=p^.suivant; end; end;end;

procedure rechercher(Pa:para;mot:string;var p:para;var l:ligne);var q:para; r:ligne; trouve:boolean;begin trouve:=false;

{para p=Pa;while(p!=NULL){

afficher_ligne(p->line);p=p->suivant;

}}

void chercher(para Pa,char*mot,para&P, ligne &L){

int trouve=0;para q=Pa;while((q!=NULL)&&(!trouve)){

P=q ;ligne l=q->line;while((l!=NULL)&&(!trouve)){

if(!strcmp(l->info,mot)) {trouve=1;L=l;

}l=l->suivant;

}q=q->suivant;

}}



if Pa<>nil then begin q:=Pa; while (q<>nil)and(not trouve) do begin r:=q^.line; while(r<>nil)and(not trouve) do begin if r^.info = mot then begin l:=r; p:=q; trouve:=true; end else r:=r^.suivant; end; q:=q^.suivant; end; end;end;

procedure inserer(Pa:para;M1,M2:string);var q,r,l:ligne; p:para;begin

void inserer(para Pa,char*M1,char*M2){

ligne q,r,l;para p;if(p!=NULL){

r=(ligne)malloc(sizeof(str1));strcpy(r->info,M2);r->suivant=NULL;chercher(Pa,M1,p,q);l=p->line;l=q;r->suivant=l->suivant;l->suivant=r;

}}

void supprimer(para &Pa,char*mot){

ligne l,q;para p;if(Pa!=NULL){

chercher(Pa,mot,p,q);if(q==p->line){

p->line=q->suivant;free(q);



if p<>nil then begin new(r); r^.info:=M2; r^.suivant:=nil; rechercher(Pa,M1,p,q); l:=p^.line; l:=q; r^.suivant:=l^.suivant; l^.suivant:=r; end;end;

procedure supprimer(var Pa:para;M1:string);var p:para; q,l:ligne;begin if Pa<>nil then begin rechercher(Pa,M1,p,q); if q=p^.line then p^.line:=q^.suivant else begin l:=p^.line; while l^.suivant<>q do

}else{

l=p->line;while(l->suivant!=q) l=l->suivant;l->suivant=q->suivant;free(q);

}}

}

para rechercher_phrase(para Pa,char*M1){

para p;ligne q;p=Pa;if(Pa!=NULL){

while(p!=NULL){q=p->line;if(!strcmp(q->info,M1))

return(p);p=p->suivant;

}return NULL;}return NULL;

}



l:=l^.suivant; l^.suivant:=q^.suivant; end; dispose(q); end;end;

function rechercher_phrase(Pa:para;M1:string):para;var p:para; q:ligne; trouve:boolean;begin p:=Pa; trouve:=false; if p<>nil then begin while(p<>nil) and (not trouve)do begin if(p^.line^.info=M1) then begin rechercher_phrase:=p; trouve:=true; end else p:=p^.suivant; end;

void inserer_phrase(para Pa,ligne l,char*M1){

para p,q,r;if(Pa!=NULL){

q=(para)malloc(sizeof(str2));q->line=l;q->suivant=NULL;p=rechercher_phrase(Pa,M1);if(p!=NULL){

q->suivant=p->suivant;p->suivant=q;

}else{

r=Pa;while(r->suivant!=NULL) r=r-

>suivant;r->suivant=q;

}}

}

void supprimer_phrase(para&Pa,ligne l){

para p,q,m;



end;end;

procedure inserer_phrase ( Pa:para ; l:ligne ; M1:string);var p,q,r:para;begin if Pa<>nil then begin new(q); q^.line:=l; q^.suivant:=nil; p:=rechercher_phrase(Pa,M1); if p<>nil then begin q^.suivant:=p^.suivant; p^.suivant:=q; end else begin r:=Pa; while r^.suivant<>nil do r:=r^.suivant; r^.suivant:=q; end; end;end;

ligne r;p=rechercher_phrase(Pa,l->info);if(p==Pa){

Pa=p->suivant;free(p);

}else{

q=Pa;while((q!=NULL)&&(q->line!=p->line)){

m=q;q=q->suivant;

}if(q!=NULL){

m->suivant=q->suivant;free(p);

}}

}



procedure supprimer_phrase(var Pa:para;l:ligne);var p,q,m:para;begin p:=rechercher_phrase(Pa,l^.info); if p=Pa then Pa:=p^.suivant else begin q:=Pa; while(q<>nil)and(q^.line<>p^.line) do begin m:=q; q:=q^.suivant; end; if q<>nil then m^.suivant:=q^.suivant; end; dispose(p); end;

Les Arbres Binairestype Noeud=^element; element=record cle:integer; g:Noeud; d:Noeud; end;

typedef struct str{int cle;str*g,*d;

}*Noeud;

Exercice 93



Ecrire la procédure du parcours d’un arbre binaire en préordre.procedure preordre(A:Noeud);begin if A<>nil then begin write(A^.cle,' '); preordre(A^.g); preordre(A^.d); end;end;

void preordre(Noeud A){

if(A!=NULL){printf("%d ",A->cle);preordre(A->g);preordre(A->d);

}}

Exercice 94Ecrire la procédure du parcours d’un arbre binaire en postordre.procedure postordre(A:Noeud);begin if A<>nil then begin postordre(A^.g); postordre(A^.d); write(A^.cle,' '); end;end;

void postordre(Noeud A){

if(A!=NULL){postordre(A->g);postordre(A->d);printf("%d ",A->cle);

}}

Exercice 95Ecrire la procédure du parcours d’un arbre binaire en ordre.procedure ordre(A:Noeud);begin if A<>nil then

void ordre(Noeud A){

if(A!=NULL){



begin ordre(A^.g); write(A^.cle,' '); ordre(A^.d); end;end;

ordre(A->g);printf("%d ",A->cle);ordre(A->d);

}}

Exercice 96Ecrire une fonction qui recherche un élément dans un arbre ordonné horizontalementfunction recherche(A:Noeud;x:integer):Noeud;begin if A<>nil then begin if A^.cle=x then recherche:=A else if A^.cle>x then recherche:=recherche(A^.g,x) else recherche:=recherche(A^.d,x); end else recherche:=nil;end;

Noeud recherche(Noeud A,int x){

if(A!=NULL){if(A->cle==x) return A;else{

if(A->cle>x) return(recherche(A->g,x));

else return(recherche(A->d,x));}

}else return NULL;

}

Exercice 97Ecrire une procédure qui insert un élément dans un arbre ordonné horizontalementprocedure insertion(var A:Noeud;x:integer);var N:Noeud;

void insertion(Noeud &A,int x){



begin new(N); N^.cle:=x; N^.g:=nil; N^.d:=nil; if A=nil then A:=N else begin if x<A^.cle then insertion(A^.g,x) else insertion(A^.d,x); end;end;

Noeud p=(Noeud)malloc(sizeof(str));p->cle=x;p->g=NULL;p->d=NULL;if (A==NULL) A=p;else{

if(A->cle>x) insertion(A->g,x);else insertion(A->d,x);

}}

Exercice 98Ecrire une procédure qui supprime un élément dans un arbre ordonné horizontalementprocedure suppression(var A:Noeud;x:integer);var pt,pd,pg:Noeud;begin if A<>NIL then begin if A^.cle=x then begin pt:=A^.d; if pt<>nil then begin while pt<>nil do

void suppression(Noeud &A,int x){

Noeud pt,pg,pd;if(A!=NULL){

if(A->cle==x){pt=A->d;if (pt!=NULL){

while(pt!=NULL){pg=pt;pt=pt->g;

}



begin pg:=pt; pt:=pt^.g; end; pg^.g:=A^.g; A:=A^.d; end else A:=A^.g; end else if x=A^.g^.cle then begin pt:=A^.g^.d; if pt<>nil then begin while pt<>nil do begin pg:=pt; pt:=pt^.g; end; pg^.g:=A^.g^.d; A^.g:=A^.g^.d; end else A^.g:=A^.g^.g; end else

pg->g=A->g;A=A->d;

}else A=A->g;

}else if(x==A->g->cle){

pt=A->g->d;if(pt!=NULL){

while(pt!=NULL){pg=pt;pt=pt->g;

}pg->g=A->g->d;A->g=A->g->d;

}else A->g=A->g->g;

}else if(x==A->d->cle){

pt=A->d->g;if(pt!=NULL){

while(pt!=NULL){pd=pt;pt=pt->d;

}pd->d=A->d->d;A->d=A->d->g;



if x=A^.d^.cle then begin pt:=A^.d^.g; if pt<>nil then begin while pt<>nil do begin pd:=pt; pd:=pt^.d; end; pd^.d:=A^.d^.d; A^.d:=A^.d^.g; end else A^.d:=A^.d^.d; end else if x<A^.cle then suppression(A^.g,x) else suppression(A^.d,x); end;end;

}else A->d=A->d->d;

}else{

if(x<A->cle) suppression(A->g,x);else suppression(A->d,x);

}}

}

Les FichiersExercice 99Ecrire un programme qui permet de créer un fichier d’étudiants.Program gest_fich;uses crt;Type Date=record

#include<stdio.h>#include<conio.h>#include<alloc.h>



J,M,A:Integer; end; etud=record Nom,Prn:string[20]; CIN:string[10]; Date_Nais:Date; End;Var FEtud:File of etud;

Procedure Affich_formul(Titre:String);Begin TextBackground(Blue); ClrScr; TextColor(Yellow); Gotoxy(35,4); Write(Titre); Gotoxy(20,7); Write('Nom :'); Gotoxy(20,9); Write('Pr‚nom :'); Gotoxy(20,11); Write('C.I.N :'); Gotoxy(20,13); Write('Date de Naissance :');End;

#include<string.h>typedef struct{

int J,M,A;}date;typedef struct{

char nom[20];char prn[20];char cin[10];date date_nais;

}etudiant;

void affich_formul(char *titre){

textbackground(BLUE);clrscr();textcolor(YELLOW);gotoxy(35,4);cprintf("%s",titre);gotoxy(20,7);cprintf("Nom :");gotoxy(20,9);cprintf("Prenom :");gotoxy(20,11);cprintf("C.I.N :");gotoxy(20,13);cprintf("Date de naissance :");



Procedure saisie(Var E:Etud);Begin TextColor(White); With E, Date_Nais Do Begin Gotoxy(26,7); Clreol; Readln(Nom); Gotoxy(29,9); Clreol; Readln(Prn); Gotoxy(28,11); Clreol; Readln(CIN); Gotoxy(40,13); Clreol; Readln(J); Gotoxy(42,13); Write('/'); Readln(M); Gotoxy(45,13); Write('/'); Readln(A);End;End;

}

void saisie(etudiant &E){

textcolor(WHITE);gotoxy(26,7);clreol();scanf("%s",E.nom);gotoxy(29,9);clreol();scanf("%s",E.prn);gotoxy(28,11);clreol();scanf("%s",E.cin);gotoxy(40,13);clreol();scanf("%d",&E.date_nais.J);gotoxy(42,13);clreol();cprintf("/");scanf("%d",&E.date_nais.M);gotoxy(45,13);cprintf("/");clreol();scanf("%d",&E.date_nais.A);

}



Procedure Ajout; Var E:Etud; Rep:Char;Begin Assign(Fetud,'C:\Gestion'); {$I-} Reset(Fetud); {$I+} If IOResult<>0 Then Rewrite(Fetud) Else Seek(Fetud,FileSize(Fetud)); Affich_formul('S A I S I E'); Repeat Saisie(E); Write(Fetud,E); TextColor(Yellow); Gotoxy(45,17); Write('Voulez-vous continuez (O/N)?'); Rep:=readkey; Gotoxy(45,17); Clreol; Until Rep In ['N', 'n']; Close(Fetud);End;

Procedure Affich(Var E:Etud);Begin

void ajout(){

etudiant E;int rep;FILE*Fetud=fopen("Gestion","ab");affich_formul("SAISIE");do{

saisie(E);fwrite(&E,sizeof(etudiant),1,Fetud);textcolor(YELLOW);gotoxy(45,17);cprintf("voulez_vous continuez(o/n)?");clreol();flushall();rep=getchar();

}while(rep=='o' || rep=='O');fclose(Fetud);

}void affich(etudiant &E){

textcolor(WHITE);gotoxy(26,7);clreol();cprintf("%s",E.nom);gotoxy(29,9);



TextColor(White); With E, Date_Nais Do Begin Gotoxy(26,7); Clreol; Write(Nom); Gotoxy(29,9); Clreol; Write(Prn); Gotoxy(28,11); Clreol; Write(CIN); Gotoxy(40,13); Clreol; Write(J,'/',M,'/',A); End;End;

Procedure Affichtout; Var E:Etud; Rep:Char; I:Integer;Begin Assign(Fetud,'C:\Gestion'); {$I-} Reset(Fetud);

clreol();cprintf("%s",E.prn);gotoxy(28,11);clreol();cprintf("%s",E.cin);gotoxy(40,13);clreol();cprintf("%d/%d/%d",E.date_nais.J,

E.date_nais.M,E.date_nais.A);}

void affichtout(){

etudiant E;FILE*Fetud=fopen("Gestion","rb");if (Fetud==NULL) return;

affich_formul("CONSULTATION");do{fread(&E,sizeof(etudiant),1,Fetud);

affich(E);textcolor(YELLOW);gotoxy(45,17);cprintf("Tapez une Entree pour

continuer");getch();gotoxy(45,17);



{$I+} If IOResult<>0 Then write('Probleme de lecture !!!!') Else Begin Affich_formul('C O N S U L T A T I O N'); Repeat Read(Fetud,E); Affich(E); TextColor(Yellow); Gotoxy(45,17); Write('Taper une touche pour continuer'); Rep:=readkey; Gotoxy(45,17); Clreol; Until EOF(Fetud); Close(Fetud); End;End;BEGIN Ajout; Affichtout; ClrScr; Readln;END.

}while(!feof(Fetud));fclose(Fetud);

}

void main(){ ajout() ; affichtout() ; clrscr() ; getch() ;}

Exercice 100Ecrire une procedure qui permet de modifier les informations d’un etudiant



Procedure Modif;Var N: Integer; E:Etud;Begin Assign(Fetud,'C:\Gestion'); {$I-} Reset(Fetud); {$I+} If IOResult<>0 Then write('Probleme de lecture !!!!') Else Begin ClrScr; Write('Donner le numero d''ordre de l''etudiant a modifier'); readln(N); Seek(Fetud,N-1); Read(Fetud,E); With E do Begin Write('Nom : ',Nom); Readln(Nom); Write('Pr‚nom : ',Prn); Readln(Prn); Write('C.I.N : ',CIN); Readln(CIN); End;

void modif(){

int i;char*CIN;char nom[20],prn[20],cin[10];int J,M,A;etudiant E;etudiant *Et;FILE*Fetud=fopen("Gestion","rb");FILE*f=fopen("tmptmp.$$","wb");textcolor(YELLOW);textbackground(BLUE);clrscr();if(Fetud==NULL) return;cprintf("Donnez le C.I.N de l'etudiant a modifier:

");scanf("%s",CIN);getch();

i=fread(&E,sizeof(etudiant),1,Fetud); while((strcmp(E.cin,CIN))&&(i!=0)){ fwrite(&E,sizeof(etudiant),1,f); i=fread(&E,sizeof(etudiant),1,Fetud);

}if(!strcmp(E.cin,CIN)){

etudiant *Et=(etudiant*)malloc(sizeof(etudiant));



Seek(Fetud,N-1); Write(Fetud,E); Close(Fetud) End;End;

cprintf("Nom : %s ",E.nom);scanf("%s",nom);strcpy(Et->nom,nom);cprintf("Prenom : %s ",E.prn);scanf("%s",prn);strcpy(Et->prn,prn);cprintf("C.I.N : %s ",E.cin);scanf("%s",cin);strcpy(Et->cin,cin);getch();cprintf("Date de naissance :%d/%d/%d

",E.date_nais.J,E.date_nais.M,E.date_nais.A);scanf("%d",&J);printf("/");Et-

>date_nais.J=J;scanf("%d",&M);printf("/");Et-

>date_nais.M=M;scanf("%d",&A);Et->date_nais.A=A;fwrite(Et,sizeof(etudiant),1,f);

}i=fread(&E,sizeof(etudiant),1,Fetud);while(i!=0){

fwrite(&E,sizeof(etudiant),1,f);

i=fread(&E,sizeof(etudiant),1,Fetud);}fclose(f);



fclose(Fetud);remove("Gestion");rename("tmptmp.$$","Gestion");

}


Annexe

GESTION DE L’ÉCRAN

Les fonctions de gestion de l’écran sont les mêmes en C et en Pascal. Vous aurez, en ce qui suit, une brève description des instructions les plus courantes.Remarque :

En C, toutes ces fonctions se trouvent dans la bibliothèque conio.h

I. Notion de fenêtre

On peut définir une fenêtre dans un écran. L’écran actif sera réduit à cette fenêtre.WINDOW(x1,y1,x2,y2) où :

x1 et y1 représentent les coordonnées du coin supérieur gauche de la fenêtre.x2 et y2 représentent les coordonnées du coin inférieur droit de la fenêtre.

II. Gestion du curseur

L’instruction Gotoxy(x,y) positionne le curseur sur le point de coordonnées (x,y) de la fenêtre active.La fonction WhereX retourne la colonne où se trouve le curseur.La fonction WhereY retourne la ligne où se trouve le curseur.

III. Instructions de gestion de l’écran

ClrScr : efface la fenêtre active et positionne le curseur au point de coordonnées (1,1).ClrEol : efface les caractères se trouvant après la position du curseur jusqu’à la fin de la ligne.DelLine : élimine la ligne pointée par le curseur et déplace toutes les lignes suivantes vers le haut. La dernière ligne devient vide.InsLine : insère une ligne vide à la place du curseur et décale les lignes suivantes vers le bas. La dernière ligne sera perdue.


Annexe

IV. Instructions de gestion des couleurs

TextColor(couleur) : définit la couleur du texte (16 couleurs codées de 0 à 15).TextBackGround(couleur) : défint la couleur du fond du texte (8 couleurs codées de 0 à 7).

Le tableau suivant présente les 16 couleurs existantes pour l’écriture du texte :

N° Couleur N° Couleur N° Couleur N° Couleur0 Noir 4 Rouge 8 Gris foncé 12 Rouge clair1 Bleu 5 Magenta 9 Bleu clair 13 Magenta2 Vert 6 Brun 10 Vert clair 14 Jaune3 Cyan 7 Gris clair 11 Cyan clair 15 Blanc


Conclusion

CONCLUSION

En conclusion, le langage Pascal reste le plus adapté à l’enseignement d’algorithmique pour les élèves de l’enseignement secondaire ou pour les débutants en algorithmique.

Malgré sa performance parfois supérieure à celle de Pascal, C est plutôt destiné à des utilisateurs avertis (école d’ingénieurs, etc.).

Malgré le nombre très important d’exercices et leur diversité, on pourrait prévoir quelques problèmes de synthèse tels que les Tours de Hanoi, problèmes complets de système (gestion de stock, etc.), gestion très poussée de l’écran avec par exemple un menu déroulant, etc.

On pourrait aussi suggérer pour les promotions à venir de compléter les solutions proposées par une analyse du problème consistant à mettre en évidence les données du problème et leurs types, ainsi les principales actions à réaliser pour calculer les données de sortie (résultats) en partant des données d’entrée.


Références

RÉFÉRENCES

Programmer en langage C Claude Delanoy .

Turbo Pascal manuel de l’utilisateur version 5.0 .

Algorithmique : cours et exercices méthodologiques corrigés Guy CHATY & Jean VICARD.

Turbo Pascal et ses fichiers (version 3) : Jacques BOISGONTIER & Christophe DNAY.

Manuel d’Algorithmique réalisé par Mr LAMHARCHI Brahim.


100exercices en pascal & c

Documents