Initiation à l'informatique
1) Informatique
- C'est le traitement automatique de l'information sur un ordinateur.
- aspect scientifique, outil, technique
*info théo -> langages...
*info méthodo -> analyse, programmation structurée...
*info techno -> composants, mémoires...
*info syst -> architecture, réseaux...
2) Ordinateur
Repère historique :
1945 : Premier calculateur, Leniac
1947 : Première mise en oeuvre des travaux de VAN NEUMAN
1950 : Apparition de Bimac conçu à partir de l'architecture de VAN....
* Microprocesseur (CPU:Central Processus Unit)
* Mémoire centrale (Central Memory) : endroit où est stockée l'information en cours de traitement.
* périphériques : - d'entrée (input) : exemple : le clavier (keyboard)
- de sortie (output) : exemple : écran, robot
- d'entrée/sortie : dispositif de mémoire externe (disque dur)
Hardware (matériel) /= Software (logiciel)
TD : Informatique : Représentation de données en machine
1 - Introduction
Les informations stockées ou circulant dans la machine sont toujours physiquement binaires (présences ou absences de charges électriques)
Une position binaire est notée logiquement "0" ou "1"
Usuellement, la valeur représentée sur la position binaire contigue est notée par un chiffre base 16. 8 bits (positions binaires) contigus constituent un octet (byte).
* Ko = 1024 octets = 2^(10)
2- Les numériques
2-1- Système binaire
Dans une base b, si un nombre est représenté par W,X,Y,Z, sa valeur est :
wb^3+xb^2+yb^1+zb^0 = wb^3+xb²+yb+z
base 10 : 1435
1*10^3+4*10^2+3*10+5
base 3 : 120
1*3²+2*3+0
base 2 : 10110
1*2^4+2^2+2
-> Passage d'une base x à une base 10
Exemple :
120 en base 3 = 15 en base 10
1*3²+2*3=15
10110 en base 2 = 22
1*2^4+2^2+2 = 22
-> Passage d'une base 10 à une base x
Exemple : 847 base 10 en base 3
847=282*3 + 1
282=94*3 + 0
94=31*3 + 1
31=10*3 + 1
10=3*3 + 1
3=1*3 + 0
1=0*3 + 1
On obtient 1011101
* Attention on prend ces chiffres (qui correspondent au reste) dans l'ordre inverse des opérations.
Exemple : 847 base 10 en base 2
847=423*2 + 1
423=211*2 + 1
211=105*2 + 1
105=52*2 + 1
52=26*2 + 0
26=13*2 + 0
13=6*2 + 1
6=3*2 + 0
3=1*2 + 1
1=0*2 + 1
On obtient 1101001111
On peut alors dresser le tableau suivant :
___________________
|base 10|base 16|base 2 |
-------------------------
| 0 | 0 | 0 |
-------------------------
| 1 | 1 | 1 |
-------------------------
| 2 | 2 | 10 |
-------------------------
| 3 | 3 | 11 |
-------------------------
| 4 | 4 | 100 |
-------------------------
| 5 | 5 | 101 |
-------------------------
| 6 | 6 | 110 |
-------------------------
| 7 | 7 | 111 |
-------------------------
| 8 | 8 | 1000 |
-------------------------
| 9 | 9 | 1001 |
-------------------------
| 10 | A | 1010 |
-------------------------
| 11 | B | 1011 |
-------------------------
| 12 | C | 1100 |
-------------------------
| 13 | D | 1101 |
-------------------------
| 14 | E | 1110 |
-------------------------
| 15 | F | 1111 |
-------------------------
2-2- Entiers : N
- Nombre de positions fixes
- Problème des nombres négatifs
Représentation en complément à 2 :
Exemple : +5 +5 =10
Base 10 : -6 est le nombre tel que en le retranchant de la base, on obtienne son complément.
3-(-7)=10 4-(-6)=10
On a 5 base 2 = 0101 donc -5 base 2 = 1011
car 0101 + 1011 = 0000
Exemple :
01011000 * En partant de la droite, on remarque que les
+ 10101000 * chiffres sont identiques jusqu'au premier 1
--------------- * puis sont tous inversés.
1)00000000
On a :
|base 10|base 2| |base 2|base10|
| 0 | 0000 | | 1111 | -1 |
| 1 | 0001 | | 1110 | -2 |
| 2 | 0010 | | 1101 | -3 |
| 3 | 0011 | | 1100 | -4 |
| 4 | 0100 | | 1011 | -5 |
| 5 | 0101 | | 1010 | -6 |
| 6 | 0110 | | 1001 | -7 |
| 7 | 0111 | | 1000 | -8 |
Table d'addition binaire :
0+0=0 0+1=1 1+1=0(avec 1 en retenue)
Exemple d'addition de deux nombres représentés en complément à deux.
2 -> 0010
+3 -> +0010
--- --------
5 -> 0101
+3 -> 0011
+-4 -> +1100
---- -------
-1 -> 1111
-1 -> 1111
+-3 -> +1101
---- -------
-4 ->1)1100
7 -> 0111
++2 -> 0010
---- ------
9 1001
or, 1001 correspond à -7
-3 -> 1101
+-7 -> 1001
---- -----
-10 1)0110
or, 0110 correspond à 6
Erreur si le ou exclusif entre le bit de debordement et la retenue precedente (3ieme position -> 4ieme) prend la valeur 1.
ou exclusif -> 1 si ils sont differents.
Exemple : + 0 1
0 0 1
1 1 0
Exemple : 11011011 = -37
+00011101 = 29
---------------------
11111000 -8
complement a 2 11011011
00100101 <- complement.
2^6+2^3+1 = 37
En turbo-pascal, max+ = 2^15-1 = 32768
max- = -32768
Complexité de l'addition
Algo addition
Variable a,b,r : entier
sa,sb,sr : signe
Début
Ecrire ('Donnez a')
Lire (a)
Ecrire ('Donnez b')
Lire (b)
Si sa=sb alors
r <- |a| + |b|
sr <- sa
sinon
si |a| > |b| alors
r <- |a| - |b|
sr <- sa
sinon
si |a|=|b| alors
r <- 0
sr <- 0
sinon
r <- |b|-|a|
sr <- sb
fin si
fin si
fin si
Ecrire ('Le résultat de l'additiion est : ', sr,r)
fin
2-3- Les réels :
base b : v,w,x,y,z
= vb²+wb+x+yb^-1+zb^-2
Seul un sous-ensemble fini des rationnels sera représenté, ce sous-ensemble ne coïncide pas avec un sous-ensemble des décimaux.
Exemple : 12,25
En base 2 : 1100,01
Notation scientifique : 1225 * 10^-2
Mantisse -> signes significatifs et exposant.
Le separateur decimal est toujours place au même endroit (avant le premier chiffre 1) et sa position est indique par un exposant.
0,110001*2^4
Mantisse binaire signee, exposant binaire signe.
Exemple : mantisse sur trois octets et exposant sur un.
0|11000100...0 0|0000100
24 bits exposant
En Turbo Pascal -> 6 octets (5 pour la mantisse et 1 pour l'exposant)
Onze chiffres significatifs.
Remarques : Depassement de capacite sur l'exposant pour une valeur absolue superieure a l'intervalle.
=> Erreur : floating point overflow.
=> Valeur trop petite alors la valeur est remplacee par 0.
3- Caractères (=1 octet)
Les deux normes les plus utilisées pour les micro-ordinateur sont : ASCII et ANSI.
Elles sont d'accord sur les sept premières positions.
Respect de l'ordre alphabètiquel, l'espace est situé avant le A, les majuscules sont placés avant les minuscules.
Désaccord sur l'extension du huitième bit.
=> caractères spéciaux (accents).
Les PC/DOS : ASCII
Macintosh : ANSI
Windows : ANSI
4- Instructions
code operations adresse
|-------------------|----------|
n bits p bits
Algorithmes
On pratique une analyse descendante.
Problème
ANALYSE
Algorithme
TRADUCTION
Programme Pascal
On part du problème global que l'on simplifie par raffinage successif en détails.
Algorithme est en trois parties :
i) Acquisition des données.
ii) Traitement sur ces données.
iii) Communication des résultats.
Algo surface cercle
{Algo de calcul de la surface d'un cercle}
Constante pi=3,14
Variables rayon, surface : réel
Début
{saisie de donnée}
Ecrire ('Ce programme calcule la surface d'un cercle')
Ecrire ('Donnez le rayon du cercle en cm')
Lire (rayon)
{calcul}
surface <- rayon * rayon * pi
{résultat}
Ecrire ('La surface d'un cercle de rayon ',rayon,'est ',surface,' cm²')
Fin
Algo moyenne
{algo de calcul de la moyenne d'un étudiant ayant passé trois épreuves : A de coef 1, M de coef 4 et I de coef 3.}
variables utilisées : nom :chaîne
NotA,NotM,NotI,moyenne : réel
Debut
{saisie de données}
Ecrire('Ce programme calcule la moyenne')
Ecrire('Donner le nom de l'élève :')
Lire (nom)
Ecrire('Donner la note d'anglais')
Lire (NotA)
Ecrire('La note de math : ')
Lire (NotM)
Ecrire('La note d'informatique : ')
Lire (NotI)
moyenne <- (NotA + 4*NotM + 3*NotI)
{résultat}
Ecrire ('La moyenne de ',nom,' est ',moyenne)
Fin
L'algorithme se construit avec trois structures :
- séquences (exemples : écrire, lire...)
- altrenative
- répétitive
Pb : Résolution d'une équation du second degré : ax²+bx+c=0
Début
Ecrire ('Résolution d'une équation....')
Ecrire ('Donner A')
Lire (A)
Ecrire ('Donner B')
Lire (B)
Ecrire ('Donner C')
Lire (C)
discr = b²-4ac
si discr = 0
alors
Ecrire ('Solution : ',-b/2a)
sinon
si discr < 0
alors
Ecrire ('Pas de solution')
sinon
Ecrire ('Les solutions sont : ',(-b-sqr(discr))/2a),' et ',(-b+sqr(discr))/2a))
fin si
fin si
fin
{Ce programme est incomplet car il ne prend pas en compte le cas où a=0 (ce qui fera bloquer la machine)}
* Si condition alors.... sinon....
Le condition est une expression booléenne (Vrai/Faux)
Algo test1
Variable A:entier
Début
Ecrire ("Donnez un entier")
Lire (A)
Si A>1
Alors
si A<5
alors
Ecrire (A," compris entre 1 et 5")
sinon
Ecrire (A," est > 5")
fin si
fin si
fin
Algo test2
Variable A:entier
Début
Ecrire ("Donnez un entier")
Lire (A)
Si A>1
Alors
si A<5
alors
Ecrire (A, "compris entre 1 et 5")
fin si
sinon
Ecrire (A, " est <= 1")
fin si
fin
Algo Ordre Croissant
Variable X, Y, Z: réel
Début
Ecrire ("Donner X")
Lire (X)
Ecrire ("Donner Y")
Lire (Y)
Ecrire ("Donner Z")
Lire (Z)
Si X>Y
alors
si Y>Z
alors
Ecrire ("X:",X,"Y:",Y,"Z:",Z)
sinon {Z>Y}
si X>Z
alors
Ecrire ("X:",X,"Y:",Z,"Z:",Y)
sinon
Ecrire ("X:",Z,"Y:",X,"Z:",Y)
fin si
fin si
sinon {Y>X}
si X>Z
alors
Ecrire ("X:",Y,"Y:",X,"Z",Z)
sinon
si Y>Z
alors
Ecrire ("X:",Y,"Y:",Z,"Z:",X)
sinon
Ecrire ("X:",Z,"Y:",Y,"Z:",X)
fin si
fin si
fin si
fin
* classer A et B
Si B < A alors {permutation}
D <- B
B <- A
A <- D
Fin si
Algo Classer 3 valeurs
variables A,B,C,D : réels
Début
Ecrire ('Valeur de a')
Lire (A)
Ecrire ('Valeur de b')
Lire (B)
Ecrire ('Valeur de c')
Lire (C)
si B < A alors
D <- B
B <- A
A <- D
fin si {A et B classés}
si C < A alors
D <- A
A <- C
C <- B
B <- D
sinon {classer B et C}
si B>C
alors
D <- B
B <- C
C <- D
fin si
fin si
Ecrire ("a,b,c sont classés dans l'ordre croissant")
fin
Les répétitions :
On connaît le nombre de répétition => on va les compter pour savoir si ce nombre est atteint.
Pour c cr de vd à vf faire
{instruction}
Fin pour
avec c:compteur, vd:valeur de départ et vf:valeur de fin
Exercices :
1) Demander N (compris entre 1 et 10) et afficher sa table de multiplication.
Algo Table de N
variables : N,c : entiers
Début
Ecrire ('Donner N')
Lire (N)
Pour c cr de 1 à 10 faire
Ecrire (N,' * ',c,' = ',N*c)
Fin pour
Fin
2) Calcul de n factoriel
Algo n!
Variables : N,r,i : entiers
Début
Ecrire ('Donnez la valeur N de l'opération N factoriel dont vous souhaitez le résultat')
Lire (N)
r <- 1
Pour i cr de 2 à N faire
r <- i * r
Ecrire (N,'! = ',r)
fin
3) X^n
Algo X^n
variables N,i : entiers
x,r : réels
Début
Ecrire ("Calcul de x^n")
Ecrire ("Donnez la valeur de x")
Lire (x)
Ecrire ("Valeur de N")
Lire (N)
r <- 1
Pour i cr de 1 à N faire
r <- x * r
Fin pour
Ecrire (x," exp",N," = ",r)
Fin
4) Nième terme de la suite de Fibonacci
Algo Fib
{calcul du nième terme de Fibonacci définie par F0=0, F1=1, Fn=Fn-1+Fn-2}
Variable F,n, prec1,prec2 : entiers
Début
Ecrire ("Entrez la valeur de n")
Lire (n)
{calcul}
prec1 = 1
prec2 = 0
pour i cr de 2 à n faire
F <- prec1 + prec2
prec2 <- prec1
prec1 <- F
fin pour
Ecrire ("Le ",n," ième terme de Fibonnaci est ",F)
Fin
5) Afficher la plus grande valeur parmi N
Algo Nmax
{Afficher la plus grande valeur parmi N}
variables : N,i,max,VL : entiers
Début
Ecrire ("Donner N le nombre de valeurs")
Lire (N)
Ecrire ("Donner la première valeur")
Lire (max)
Pour i cr 2 à N faire
Ecrire ("Donnez une valeur")
Lire (VL)
Si VL > max
alors max <- VL
Fin si
Fin pour
Ecrire ("La plus grande valeur est : ",max)
Fin
Algo plus petite valeur
variables : A,B,C : réels
Début
Ecrire ("Donnez votre premier entier : ")
Lire (A)
Ecrire ("Donnez votre second entier : ")
Lire (B)
Ecrire ("Donnez votre dernier entier : ")
Lire (C)
Si A>B
alors
si C>B
alors
Ecrire (B," est la plus petite valeur")
sinon
Ecrire (C," est la plus petite valeur")
fin si
sinon {A < B}
si A < C alors
Ecrire (A," est la plus petite valeur")
sinon
Ecrire (C," est la plus petite valeur")
fin si
fin si
fin
Lorsque plusieurs valeurs sont de même type et de même utilisation dans l'algorithme, on peut utiliser un tableau.
Une valeur est repérée par le nom du tableau et un indice (n° de la case).
Exemple: la troisième valeur T[3]
Exercice : l'horoscope chinois
Afficher le signe correspondant à une année de naissance.
Douze signes possibles.
Rat : 1900 1912 1924 ...
Boeuf : 1901 1913 1925 ...
....
Sanglier : 1911 1923 1935 ...
Algo horoscope
{Afficher le signe d'une personne suivant son année de naissance}
Type Tab = tableau [0...11] de chaînes
{En pascal : array [0..11] of string;}
Variable
Signe : tab
Année : entier
Début
signe [0] <- "Rat"
signe [1] <- "Boeuf"
....
signe [11] <- "Sanglier"
{recherche du signe}
Ecrire ("Donnez votre année de naissance")
Lire (Année)
Ecrire ("Votre signe est ",Signe[(Année-1900)mod 12]
Fin
Algo moyenne
{Trouver la moyenne d'une série statistique}
Constante : Nmax=50 {taille maximale des entiers}
Type tab1 = tableau [1..Nmax] d'entiers
tab2 = tableau [1..Nmax] de réels
Variable : somme_xini,moyenne : réels
tabni:tab1
tabxi:tab2
n,i,somme_ni : entiers
Début
Ecrire ("Donner n")
Lire (n)
{lecture du tableau}
Pour i cr de 1 à n faire
Ecrire ("Donnez la valeur n°",i)
Lire (tabxi[i])
Ecrire ("Donnez l'effectif n° ",i)
Lire (tabni[i])
Fin pour
{calcul en somme}
somme_xini <- 0
Pour i cr de 1 à n faire
somme_xini <- somme_xini + tabxi[i]*tabni[i]
somme_ni <- somme_ni + tabni[i]
Fin pour
{calcul de la moyenne}
moyenne <- somme_xini/somme_ni
{résultat}
Ecrire ("La moyenne est ",moyenne)
Fin
Les sous-programmes :
déclare 1 s.p -> indiquer la liste des paramètres formels.
Il y a deux sortes de sous-programmes :
- les procédures : 0 ou plusieurs paramètres qui pourront être des données modifiées ou des résultats.
- les fonctions : 1 seul résultat (1 seule valeur). 1 ou plusieurs paramètres donnés
L'appel d'une procédure est une instruction.
L'appel d'une fonction se fait dans une expression.
Exemple : Sp factorielle
. Premier cas : procédure
déclaration : procédure factorielle (donnée n:entier,résultat f:entier)
application : factorielle (n,x)
Ecrire (n,"!=",x)
. Deuxième cas : fonction
déclaration : fonction factorielle (donnée n:entier):entier
application : Ecrire (n,"!=",factorielle (n))
On va maintenant faire un programme sur les matrices avec :
-s.p de lecture d'une matrice (remplissage)
-s.p d'écriture d'une matrice (affichage des valeurs de la matrice)
-s.p de somme de deux matrices
-s.p de produit de deux matrices.
-p.p qui demande la dimension des matrices, les lit, les écrit, demande si on veut effectuer la somme ou le produit, effectue le travail correspondant au choix et écrit la matrice résultat.
Algo calcul_matriciel
{effectue l'addition ou la multiplication de deux matrices à la demande}
Constante
nmax=20 {maximum matrice 20*20}
type
matrice=tableau [1..nmax,1..nmax] de réels
{déclaration des sous-programmes}
Procedure lire_mat (donnees NL,NC:entier, résultat M:matrice)
Variables locales
i,j:entiers
Début
Pour i cr de 1 à NL faire {pour chaque ligne}
Pour j cr de 1 à NC faire {pour chaque colonne}
Ecrire ("Donnez le ",j,"ème élément de le ligne ",i)
Lire (M[i,j])
Fin pour
Fin pour
Fin {procedure lire_mat}
Procedure ecrire_mat (donnees NL,NC:eniers, M:matrice)
Variables locales
i,j : entiers
Début
Pour i cr de 1 à NL faire
Pour j cr de 1 à NC faire
Ecrire (M[i,j])
Fin pour
Fin pour
Fin
Procedure somme (donnees A,B:matrice, donnees NL,NC:entier, C:matrice)
Variables locales
i,j : entiers
Début
Pour i cr de 1 à NL faire
Pour j cr de 1 à NC faire
C[i,j] <- A[i,j] + B[i,j]
Fin pour
Fin pour
Fin {procédure}
Procedure produit (donnees NL,NC,NLC:entiers, A,B,C:matrice)
Variables locales :
i,j,k : entiers
s : réel
Début
s <- 0
Pour i cr de 1 à NL faire
Pour j cr de 1 à NC faire
Pour k cr de 1 à NLC faire
s <- s + A[i,k] + B[k,j]
C[i,j] <- s
Fin pour
Fin pour
Fin pour
Fin
{PP}
Variables
NL1,NC1,NL2,NC2 : entier {dimension des deux matrices}
M1,M2,MR : matrice
choix : entier {somme ou produit}
Début
{lecture des dimensions}
Ecrire ("Donnez nb lignes matrice1")
Lire (NL1)
Ecrire ("Donnez nb colonnes matrice1")
Lire (NC1)
Ecrire ("Donnez nb lignes matrice1")
Lire (NL2)
Ecrire ("Donnez nb colonnes matrice1")
Lire (NC2)
{Appel lecture matrice1}
lire_mat (NL1,NC1,M1)
{Appel lecture matrice2}
lire_mat (NL2,NC2,M2)
{Appel écriture matrice1}
ecrire_mat (NL1,NC1,M1)
{Appel écriture matrice2}
ecrire_mat (NL2,NC2,M2)
{choix}
Ecrire ("Voulez-vous additionner (1) ou multiplier (2)")
Lire (choix)
Si choix = 1
alors {somme}
si NL1=NL2 et NC1=NC2
alors
somme (M1,M2,NL1,NC1,MR)
ecrire_mat (NL1,NC1,MR)
sinon
Ecrire ("Somme impossible !")
fin si
sinon {produit}
si NC1=NL2
alors
produit (NL1,NC2,NC1,M1,M2,MR)
ecrire_mat (NL1,NC2,MR)
sinon
Ecrire ("Produit impossible !")
fin si
fin si
fin
Rappel :
Lorsque l'on utilise la boucle pour, le nombre de répétition est connu à priori. On compte le nombre d'exécution des corps de la boucle (variable compteur).
Problème : si on ne connaît pas le nombre d'exécutions. On utilisera alors une boucle tant que. Tant que condition
....
....
Fin tant que
* Le pour est un cas particulier de tant que.
Exemple : calcul du pgcd de deux entiers > 0
Variables : A,B,D : entiers
Début
Ecrire ("Donnez A")
Lire (A)
Ecrire ("Donnez B")
Lire (B)
D <- A mod B
Tant que D <> 0 faire
A <- B
B <- D
D <- A mod B
Fin tant que
Ecrire ("Le pgcd est ",B)
Fin
Exemple : calculer la moyenne d'une liste de nombre >= 0 terminé par un nombre négatif
Algo moyenne
Variable : s,n,nb : entier
Début
nb <- 0
s <- 0
n <- 1
Tant que n > 0 faire
{dans ce cas, une valeur est nécessaire}
Ecrire ("Donnez la valeur : ")
Lire (n)
s <- s+n
nb <- nb + 1
Fin tant que
Ecrire ("La moyenne est : ",s/nb)
Fin
Algo polynôme
Type tab=tableau [0..100] d'entiers
Variables : i,puis,n,x,s : entier
d : tab
Début
Ecrire ("Polynôme du type a0+a1x+a2x²...")
{Ce programme calcule la valeur d'un polynôme}
Ecrire ("Donnez le degré du polynôme : ")
Lire (n)
Pour i cr de 0 à n faire
Ecrire ("Donnez le a correspondant au degré ",i, ": ")
Lire (d[i])
Fin pour
Ecrire ("Donnez la valeur de x:")
Lire (x)
s <- 0
puis <- 1
Pour i cr de 0 à n faire
s <- d[i]*puis + s
puis <- puis * x
Fin pour
Ecrire ("Le résultat du polynôme de degré ",n," et ayant pour valeur x : ",x," est ",s)
Fin
Exercice : Nous allons de nouveau calculer la valeur d'un polynôme en utilisant cette fois des sous-programmes et en proposant deux méthodes de calcul (classique ou Horner).
procédure affich_poly (donnees dg:entier, P:polynome)
{affichage d'un polynôme}
Variable i:entier
Début
Ecrire (P[dg],"x^",dg)
Pour i de dg-1 à 2 faire
si P[i] <> 0
alors
si P[i] > 0
alors
Ecrire ("+")
fin si
Ecrire (P[i],"x^",i)
fin si
Fin pour
si P[1] <> 0
alors
si P[1] > 0
alors
Ecrire ("+")
fin si
Ecrire (P[1],"x^")
fin si
si P[0] <> 0
alors
si P[0] > 0
alors
Ecrire ("+")
fin si
Ecrire (P[0])
fin si
fin
Procédure saisie_poly (résultat n:entier, TC:tab1,TExp:tab2)
constante : nbmax=20
type
tab1=tableau[1...nbmax] de réel
tab2=tableau[1...nbmax] d'entier
Variables locales : coef : réel
exp : entier
Début
Ecrire ("Donnez le premier coef")
Lire (coef)
si coef <> 0
alors
TC[1] <- coef
Ecrire ("Donnez le premier exposant")
Lire Texp[1]
Ecrire ("Donnez le deuxième coefficient")
Lire (coef)
n <- 1
x <- 0
Tant que coef <> 0 faire
n <- n+1
TC[n] <- coef
Ecrire ("Donnez votre exposant")
Lire (exp)
Tant que exp <= Texp [n-1] faire
Ecrire ("Exposant décroissant, redonnez l'exposant")
Lire (exp)
Fin tant que
Texp[n] <- exp
Ecrire ("Donnez coef suivant (0 pour arrêter")
Lire (coef)
Fin tant que
Fin si
Fin
Fonction classique (donnée dg:entier, x:réel, P:polynôme):réel
Variables locales : s:réel
i:entier
Début
s <- 0
puis <- 1
Pour i cr de 0 à dg faire
s <- d[i] * puis + s
puis <- puis * x
Fin pour
classique <- s
Fin
Fonction Horner (donnée dg:entier, x:réel,P:polynôme):réel
Variables locales : s:réel
i:entier
Début
s <- P[dg]
Pour i decr de dg-1 à 0 faire
s <- s * x + P[i]
Fin pour
Horner <- s
Fin
Programme principal
Variables : P:polynôme
dg:entier
x:réel
Début
Ecrire ("Donnez le degré du polynôme")
Lire (dg)
Saisie_poly (dg,P)
Ecrire ("P(x)=")
affich_poly (dg,P)
Ecrire ("Valeur de x : ")
Lire (x)
Ecrire("P(",x,")= ",classique (dg,x,P))
Ecrire("P(",x,")= ",Horner (dg,x,p))
Fin
Exercice 5p8
Constante N=10
Type
tab=tableau[1..N,1..N] de réels
fonction dominante (donnée D:entier;M:tab):booléen
Variable
i,j : entier
somme : réel
down : booléen
Début
i <- 1
down <- vrai
Tant que (i<=D) et down faire
{calcul somme ligne}
somme <- 0
Pour j cr de 1 à D faire
somme <- somme + abs (T[i,j])
Fin pour
si abs (T[i,j] <= somme - abs (T[i,j])
alors
down <- faux
fin si
{passage à la ligne suivante}
i <- i + 1
Fin tant que
dominante <- down
Fin
Programme principal
Début
Si dominante (D,M)
alors
Ecrire ("La matrice est à diagonale strictement dominante.")
sinon
Ecrire ("La matrice n'est pas à diagonale strictement dominante.")
fin si
fin
Exercice 8p9:
Constante nmax=20
Type
tab=tableau [1..nmax,1..nmax] de réel
Fonction nbzéro (donnée i,p:entier,M:tab):entier
Variable
j,nbz : entier
Début
nbz <- 0
Pour j cr de 1 à p faire
si M[i,j]=0
alors
nbz <- nbz + 1
fin si
fin pour
nbzero <- nbz
fin
Procedure echange_ligne (donnees i,j,p:entier;donnees modifiees M:tab)
{i,j=n° des lignes à permuter, pp nombre de colonnes de M}
Variable
k:entier
inter:réel
Début
Pour k cr de 1 à p faire
inter <- M[i,k]
M[i,k] <- M[j,k]
M[j,k] <- inter
fin pour
fin
fonction num_ligne (donnees n,p:entier,M:tab):entier
{retourne le n° de la ligne de la matrice M ayant le plus de zero}
Variables
i,max,no,nbz:entier
Début
max <- nbzero (1,p,M)
no <- 1
Pour i cr de 2 à n faire
nbz <- nbzero (i,p,M)
si nbz > max
alors
max <- nbz
no <- i
fin si
fin pour
num_ligne <- no
fin
procedure reorganiser (donnees n,p:entier;donnees modifiées M:tab)
{réorganise M(n*p) suivant le nombre de zero dans la ligne}
Variable
i:entier
Début
Pour i decr de n à 2 faire
echangeligne (i,num_ligne(i,p,M),p,M)
finpour
fin
Exercice 1p7
Constante nmax = 15
Type tab = tableau [0..nmax] d'entier
Procédure conversion_pos (donnée N:entier; résultat T:tab)
Variable
i:entier
Début
pour i cr de 0 à nmax faire
T[i] <- N mod 2
N <- N div 2
fin pour
fin
Procédure c2 (donnée modifiée T:tab)
Variable
i,j:entier
Début
i <- 0
Tant que T[i]=0 faire
i <- i+1
Fin tant que
{i pointe sur le ième 1}
Pour j cr de i+1à nmax faire
si T[j]=0
alors
T[j] <- 1
sinon
T[j] <- 0
fin si
fin pour
fin
Procédure conversion (donnée N:entier;résultat T:tab)
Début
Si N<0
alors
conversion_pos (-N,T)
c2(T)
sinon
conversion_pos (N,T)
fin si
fin
Procédure affiche_bin (donnée T:tab)
Variable
i:entier
Début
Pour i decr de nmax à 0 faire
Ecrire (T[i])
fin pour
fin
Procédure calcul (données A,b:tab;résultat S:tab)
Variables
i,R : entier
Début
R <- 0
Pour i cr de 0 à nmax faire
S[i] <- (A[i]+B[i]+R) mod 2
R <- (A[i]+B[i]+R) div 2
Fin pour
Fin
Fonction conversion_dec_pos (donnée T:tab):entier
Variable
i,somme,puis2:entier
Début
somme <- 0
puis2 <- 1
pour i cr de 0 à nmax faire
somme <- somme + T[i]*puis2
puis2 <- puis2*2
fin pour
conversion_dec_pos <- somme
fin
Fonction conv_dec (donnée T:tab):entier
Début
Si T[nmax]=1
alors
c2(T)
conv_dec <- -1*conv_dec_pos (T)
sinon
conv_dec <- conv_dec_pos (T)
Programme principal
Variable
n1,n2 : entier
T1,T2,s : tab
Début
Ecrire ("Donner premier nombre : ")
Lire (n1)
Ecrire ("Donner deuxième nombre : ")
Lire (n2)
conversion (n1,T1)
conversion (n2,T2)
Ecrire ("Conversion de ",n1," = ")
affich_bin (T1)
Ecrire ("Conversion de ",n2," = ")
affich_bin (T2)
calcul (T1,T2,s)
Ecrire ("Somme = ")
affich_bin (s)
Ecrire ("Somme en base 10 = ",conv_dec(S))
Fin
Les TP en cliquant ici...