programme de baccalauréat en informatique algorithmique et programmation ift-17582 abder alikacem...

Programme de baccalauréat en informatique Algorithmique et programmation

IFT-17582

Abder AlikacemAbder Alikacem

Semaine 3Bâtir un algorithme

Département d’informatique et de génie logiciel

Plan

• Retour sur les outils algorithmiques• Conception des algorithmes• La documentation dans les algorithmes• Les types de données

Lecture: chapitre 3 des notes de cours

Étapes de la construction d’un programmeÉtapes de la construction d’un programmeÉtapes de la construction d’un programmeÉtapes de la construction d’un programme

• Analyse et définition des besoins • Spécification du programme • Conception• Programmation

• Tests et validation• Maintenance • Documentation du programme

Algorithme

Programme

Ordinateur

Description formelle

Solution

Problème

Programmation impérative• Définition• Propriétés • Le paradigme• Variable • Constante• Notion d’état

Répéter débutDEMANDER nfin

Tant Que (???)

DEMANDER n

{A: n est un entier compris entre 0 et 10}

DEMANDER n

{A: n vaut 1 ou 2}

Répéter débutDEMANDER nfin

Tant Que (????)

Retour sur les assertions (1)

La validation de données

SI condition est vrai alors

DÉBUT

Instructions v

FIN

SINON

DÉBUT

Instruction f

FIN

Début Si n = 0 Alors Début fact 1 Fin Sinon Début Si n = 1 Alors Début fact 1 Fin Sinon Début fact 1 Répéter i [2, n] Début fact fact * i Fin Fin Fin Fin

Retour sur les structures d’alternatives

Cas V de

v1 : b1

v2 : b2...vn : bn

Autrement c

FinCas

Début Cas n de 0 : Début fact 1 Fin 1 : Début fact 1 Fin Autrement : Début fact 1 Répéter i [2, n] Début fact fact * i Fin Fin FinCasFin

Structures d’alternatives

Répéter i [1, n] début Bloc fin

i 1Tant Que i <= n début Bloc i i + 1 fin

i 1Répéter n fois début Bloc i i + 1 fin

i 1Répéter début Bloc i i + 1 finTant Que i <= n

Structures de répétitions

Algorithme : Calculer n! pour un entier n 0début{ Assertion : n est un entier 0 }i 0fact 1Tant que i < n

débuti i + 1fact fact * ifin

fin

Il est impératif que dans tout schéma de répétition conditionnelle la valeur de la condition puisse changer, sinon nous serions dans une boucle sans fin (boucle infinie);

On doit faire précéder la structure de contrôle de la boucle Tant Que par des instructions de démarrage (initialisation).

Pour s’assurer qu’un algorithme structuré se termine il est suffisant de vérifier que chaque boucle se termine.

Une première condition nécessaire est qu’au moins une des variables de la condition c soit modifiée dans la portée de la boucle.

Remarque

Technique de la sentinelle

Début total 0

n 0 Demander note

{ A: .. } Tant Que note -1 Début total total + note

n n + 1 Demander note

{A: .. } Fin

moyenne total / n Afficher moyenneFin

Dans le cas du mode conversationnel, la fin d’une suite d’informations saisie à l ’aide d’un processus itératif est indiquée au moyen de la technique de la sentinelle.

Idée de base Abstraire Décomposer Combiner

Structuration des actions Séquentielle Conditionnelle Itérative

Tout ce qu’on peut faire sur ordinateur peut être exprimé au moyen de l’affectation, d’alternatives et des répétitions.

Conception d’algorithmes

Problème Algorithme

Instance d'un problème = Ensemble de données pour calculer une solution d’un problème.

Ensemble de résultats

Les commentaires dans les algorithmes

Vous aurez à considérer 4 types de commentaires

–Les commentaires généraux.–Identifier les grandes étapes de l’algorithme–Expliquer certaines séquences d’opérations qui peuvent sembler plus ou moins claires à première vue

- Les assertions.

- Les commentaires de spécification formelle;- Les commentaires de spécification d’un bloc;

Début

Demander n

{ Assertion : n est un entier 0 }

Si n = 1 ou n = 0 alors

Début

fact 1

Fin

Sinon

Début

fact 1

Répéter i [1, n] :

Début

fact fact * i

Fin

Fin

{ Assertion : n est un entier 0 inchangé et fact contient n!}

Fin

Si

Alors

Les assertions (2)

Les post-conditionsLes post-conditions

Les pré-conditionsLes pré-conditions

Elle consiste à considérer un problème dans son ensemble, préciser les données nécessaires et les résultats attendus décomposer le problème en plusieurs sous-problèmes plus

simples qui seront traités séparément et éventuellement décomposés eux-mêmes de manière encore plus fine (raffinement)

L’approche descendante

Exemple p.32 dans les notes de coursExemple p.32 dans les notes de cours

Imaginons un robot domestique à qui nous devons fournir

un algorithme lui permettant de préparer une tasse de café

soluble. Une première version de l'algorithme pourrait être:

(1) faire bouillir de l'eau

(2) mettre le café dans la tasse

(3) ajouter l'eau dans la tasse


(1) faire bouillir l'eau peut être affinée en

(1.1) remplir la bouilloire d'eau

(1.2) brancher la bouilloire sur le secteur

(1.3) attendre l'ébullition

(1.4) débrancher la bouilloire

(2) mettre le café dans la tasse pourrait être affiné en

(2.1) ouvrir le pot à café

(2.2) prendre une cuillère à café

(2.3) plonger la cuillère dans le pot

(2.4) verser le contenu de la cuillère dans la tasse

(2.5) fermer le pot à café


(3) ajouter de l'eau dans la tasse pourrait être raffinée en

(3.1) verser de l'eau dans la tasse jusqu'à ce que celle-ci soit pleine

Certaines étapes sont encore trop complexes pour notre robot, il faut les

raffiner davantage.

(1.1) remplir la bouilloire d'eau peut être raffiné comme suit:

(1.1.1) mettre la bouilloire sous le robinet

(1.1.2) ouvrir le robinet

(1.1.3) attendre que la bouilloire soit pleine

(1.1.4) fermer le robinet


Quand doit-on arrêter le raffinement?

Chaque décomposition sera encapsulée dans un bloc d ’instructions (bloc algorithmique).

La décomposition fonctionnelle permet de rapides construction de programmes (travail d’équipe), la possibilité de leur réutilisation, une rapide et efficace maintenance.

Blocs algorithmiques Utilisés afin de découper un algorithme en plusieurs sous-tâches. Cette façon de procéder s’inscrit très bien dans l’approche

descendante et la décomposition fonctionnelle. Chaque tâche à accomplir est alors détaillée au sein d’un bloc

algorithmique.


Un algorithme qui ajoute une journée à une date donnée.

Exemple (2)

DEBUTDEMANDER j,m,a{A: a représente une année dans le calendrier grégorien, m un mois dans l’année et j un jour du mois}max 30SI m=1 OU m=3 OU m=5 OU m=7 OU m=8 OU m=10 OU m=12 ALORS début

max 31 fin

SI m=2 ALORSdébutmax 28SI (a % 4 = 0) ET NON (a % 100 =0) ALORS début

max 29 fin

SI (a % 400=0) ALORS débutmax 29

finfin

j j+1SI j>max ALORS début

j 1m m+1SI m>12 ALORS début

m 1 a a+1 fin

finAFFICHER j,m,a{A: j, m et a représentent la date du lendemain}

FIN

On peut ré-écrire l’algorithme lendemain de la façon suivante:

Bloc B1 – la date du lendemainDEBUT

Déterminer une date (Bloc B2)Déterminer le dernier jour du mois m (Bloc B3)Déterminer la date du jour suivant (Bloc B4)AFFICHER « La journée suivante est: », j, m, a

{A:….}FIN

Les blocs algorithmiques

Bloc B2 – Déterminer une date DEBUT

DEMANDER j, m, a{A: j est un entier compris entre 1 et 31}{A: m est un entier compris entre 1 et 12}{A: a est un entier représentant une année dans le

calendrier}{A:…}FIN


Bloc B3 – Déterminer le dernier jour du moisDEBUT

max 30;SI m=1 OU m=3 OU m=5 OU m=7 OU m=8 OU m=10 OU m=12 ALORS

DEBUT max 31;FIN

SI m=2 ALORS débutmax 28;SI a est une année bissextile (voir B5)

ALORS débutmax 29;fin

fin {A:…}FIN


Bloc B4 – Déterminer la date du jour suivantDÉBUT

j j+1;SI j > max ALORSdébut

j 1;m m+1;SI m>12 ALORS début

m 1;a a+1;fin

fin{A:…}FIN


Bloc B5 Vérification si une année donnée est une année bissextile

DEBUTbis FAUXSI (a % 4 = 0) ET NON (a % 100 = 0)

ALORS débutbis VRAI;fin

SI (a % 400=0) ALORS début

bis VRAI;fin

{A:…}FIN


Les commentaires de spécification dans les algorithmes

Vous aurez à considérer 4 types de commentaires

des commentaires explicatifs; des commentaires du type assertions;les commentaires de spécification formelle d’un bloc;les commentaires de spécification internes à un bloc;

Les (4) commentaires de spécification formelle nous aideront à spécifier l’interface de chaque bloc issu d’une décomposition.

Les (8) commentaires internes à un bloc nous aideront à construire les instructions du bloc tout en assurant sa rapide maintenance.

Les commentaires de spécification

Les commentaires d’interface d’un bloc

L’en-tête : du bloc d ’instruction implantant une tâche

Pré-conditions :conditions devant être vraies au départ pour assurer le bon fonctionnement du bloc d ’instructions

Post-conditions :conditions étant vraies (observables) après exécution (correcte, i.e. les pré-conditions sont respectées) des instructions du bloc.

Sinon, indiquer la ou les actions à entreprendre dans l ’exécution du

bloc.

Valeur(s) retournée(s) : en output de l ’exécution des instructions du bloc si les pré-conditions sont respectées, sinon indiquer ce que fournira le

bloc.

Les commentaires de spécification internes

Les commentaires de spécification servent à spécifier un bloc d’un algorithme:

Ce qu’il fait La façon dont il procède pour atteindre son but Les données nécessaires Les résultats qu’il fournit

Ces commentaires sont internes aux blocs. Ils aideront au développement rapide des blocs, ainsi qu’à leur validation de façon plus efficace.

Définitions

Objectifs: ce commentaire sert à décrire le but visé par le bloc.

Méthode: la façon dont on procède pour atteindre le but décrit au commentaire précédent

Besoins: toutes les données dont le bloc aura besoin pour atteindre son but.

Connus: les données que l’on connaît d’avance, que l’on n’aura pas besoin de demander au bloc appelant ni à l’usager.

Les (8) commentaires de spécification d’un bloc

Entrées: les données qui parviennent du bloc appelant. Sorties: les données que le bloc renvoie au bloc appelant Résultats: toute conséquence du bloc qui n’est pas visible par

les autres blocs, exemple: les affichages. Hypothèses: Les conditions nécessaires au bon

fonctionnement du bloc. Ces hypothèses concernent: les données en entrée du bloc; les données lues (saisies) dans le bloc.

Les (8) commentaires de spécification d’un bloc

DEMANDER nbEtudiants {Assertion: nbEtudiants 0}

Bloc B2… {.. Besoin : n , le nombre entier dont il faut calculer le

factoriel Entrée : n .. Hypothèses : n 0 } Début {début du bloc} {A: n 0 } …..

Les assertions (3)

Validation des hypothèses

Bloc B3.. { les 8 commentaires de spécification internes } début {début du bloc} … {A: post-condition de B3} fin {fin du bloc}

Bloc B1… { les 8 commentaires de spécification internes } début{début du bloc} … Calcul de la moyenne d'une série de notes (voir B3) {A: la variable moy contient la moyenne des notes} …. {A: post-condition de B1} fin {fin du bloc}

Les assertions (4)

Les post-conditions

Bloc B1: Calculer la somme de deux entiers positifs{Objectif: Calculer et afficher la somme de deux entiers positifsMéthode: usage de l’opérateur d’addition Besoin: a et b : les deux entiersConnu: -Entrée: -Sortie: -Résultat: la somme des deux entiersHypothèses : a et b > 0 }Début

Saisie des données ( Voir Bloc B 2 ){A : a et b sont deux entiers positifs} Calcul de la somme de a et b ( Voir Bloc B3 ){A : somme contient la somme des deux entiers} Affichage de la somme (Voir bloc B4 ){A : La somme est affichée à l’usager}

{A : La somme de deux entiers positifs est calculée}fin.

Exemple 3 (très simple)

Bloc B2: Saisie des données{Objectif : Saisie de données Méthode : Sollicitation de l’usagerBesoin: entier1 et entier2 : deux entiers Connu: -Entrée: -Sortie: entier1, entier2Résultat: -Hypothèses : entier1 et entier2 sont deux entiers positifs }

Début

Demander entier1, entier2{A : entier1 et entier2 sont deux entiers positifs}

{A : La saisie de données est effectuée} Fin.

Bloc B3: Calculer la somme de deux nombres {Objectif: Calculer la somme de deux nombresMéthode: usage de l’opérateur d’addition Besoin: x et y : les deux nombresConnu: -Entrée: x, ySortie: la somme de x et y Résultat: -hypothèses : x et y sont deux nombres}Début{A : x et y sont deux nombres}

z x + y

{A : z contient la somme de x et y}Fin.

Bloc B4: Affichage d’un nombre entier{Objectif: afficher un nombre entierMéthode: sollicitation du périphérique de sortie Besoin: w : le nombre Connu: -Entrée: wSortie: -Résultat: affichage de w Hypothèses : w est un nombre entier}

Début{A : w est un nombre entier}

Afficher w

{A : un nombre entier est affiché} Fin.

Exemple 4

Écrire un algorithme qui calcule une approximation de ex, le nombre népérien.

• Les données en entrée ?• Les données en sortie ?

L’algorithme ?

... 120

24

6

2

1 1

5432

0 !

xxxxxixe

i

ix

Exemple 4

Le critère d’arrêt ?

... 120

24

6

2

1 1

5432

0 !

xxxxxixe

i

ix

Exemple 4

Le critère d’arrêt ?• Fixer un n.

!

... 24

6

2

1

1 432

0 ! nxxxxx

ixe

nn

i

ix

Exemple 4

Bloc B1 : Bloc B1 : Calculer et afficher ex

Objectif :Objectif : Calculer ex

Méthode :Méthode : Approximation par le développement en sérieBesoins :Besoins : x : L’exposant

N : Le nombre d’itérationsConnu :Connu : N (entier > 0)Entrée :Entrée : AucuneSortie :Sortie : AucuneRésultat :Résultat : Afficher l’approximation de ex

Hypothèse : Hypothèse : x est un réel.

Bloc B1 : Bloc B1 : Calculer et afficher ex

DÉBUT

DEMANDER x

{A : x est un nombre réel}

Approximer ex {voir le bloc B2}

{A : résultat contient l’approximation de ex}

AFFICHER résultat

{A : Le résultat est affiché à l’utilisateur}

FIN

Bloc B2 : Bloc B2 : Calculer ex


Méthode :Méthode : Approximation par le développement en sérieBesoins :Besoins : x : l’exposant

N : Le nombre d’itération

Connu :Connu : N (entier > 0)Entrée :Entrée : xSortie :Sortie : L’approximation de ex

Résultat :Résultat : Aucun



DÉBUT{A : x est un réel}

résultat 1

Si x≠0 Alors début

i 1TANT QUE i < NDÉBUTCalculer la factoriel de i ( voir le bloc B3){A : fact contient le factoriel de i}Calculer x exposant i (voir le bloc B4){A : xi contient x exposant i }résultat résultat + (xi/fact)

i i+1FIN

fin{A : résultat contient l’approximation de ex}FIN

Bloc B3 : Bloc B3 : Calculer la factoriel de n

Objectif :Objectif : Calculer la factoriel de n

Méthode :Méthode : 1 * 2 * 3 * … * (n-1) * n

Besoins :Besoins : n : un entier.

Connu :Connu : Aucun

Entrée :Entrée : n

Sortie :Sortie : La factorielle de n


Hypothèse : Hypothèse : n est un entier positif ou nul

Bloc B3 : Bloc B3 : Calculer la factoriel de n DÉBUT{A : n est un entier positif ou nul}

x 1k 1

{Si n = 0, x vaut 1 et on n’entre pas dans la boucle}TANT QUE k < nDÉBUT

x x * kk k + 1

FIN{A : x contient n! }FIN

Bloc B4 : Bloc B4 : Calculer x exposant i

Objectif :Objectif : Calculer x à la i Méthode :Méthode : multiplier x par lui-même i foisBesoins :Besoins : i : l’exposant

x : un réelConnu :Connu : AucunEntrée :Entrée : i, xSortie :Sortie : x exposant iRésultat :Résultat : AucunHypothèse : Hypothèse : i est un entier positif ou nul

Bloc B4 : Bloc B4 : Calculer x exposant i

DÉBUT

{A : i est un entier positif ou nul}

y 1

RÉPÉTER i FOIS

DÉBUT

y y * x

FIN

{A : y contient xi }

FIN

Exemple 4

Le critère d’arrêt ?• Fixer un n.

!

... 24

6

2

1

1 432

0 ! nxxxxx

ixe

nn

i

ix

Le critère d’arrêt ?• Un degré de précision P.

P 1

eenn

Exemple 4



Méthode :Méthode : Approximation par le développement en sérieBesoins :Besoins : x : l’exposant

P : La précision Connu :Connu : P(réel > 0)Entrée :Entrée : xSortie :Sortie : L’approximation de ex



PRISPRISE IIE II


DÉBUT{A : x est un réel}

résultat 1 {(x0/0!) = 1}SI x 0 ALORSDEBUT

résultat2 1résultat 1 + x {resultat + (x1/1!) =1+x}i 2

TANT QUE résultat – résultat2 > P

DÉBUT

Calculer la factoriel de i (voir bloc B3)

{A : fact contient i!}

Calculer x exposant i {B4}

{A : xi contient x exposant i}

résultat2 résultat

résultat résultat + (xi / fact)

i i+1

FIN

FIN{A : résultat contient l’approximation de ex avec une précision égale à P}

FIN

PRISPRISE IIE II

Réutilisation

Conception d’un bloc

algorithmique Bx

Primitives

Bx

Conception d’un autre bloc algorithmique

(Bn)Primitives

Réutilisation

Passage de paramètres

AlgorithmeBloc B3

n!

n

i

Bloc B2

DEBUT

…

… B3( i )

…

FIN

Paramètre effectif

Paramètre formel

Les types de données

• Les types prédéfinis• Les types composites• Notion de tableau• Algorithmique des tableaux

Lecture: RepresentationDeDonnées.htm, semainier/Semaine3

Les types de données

Justification du concept de type• Classer les objets selon :

• L'ensemble des valeurs que peut prendre l'objet• L'ensemble des opérations permises sur ces valeurs

Les types élémentaires

Les types composites• Tableaux• Structures• Fichiers• Etc..

Opérations •Sur le composé•Sur les composants du composé

Classification

types

prédéfinis définis explicitement

Types prédéfinis

• Booléen, Caractère, Entier, Réel, Chaîne

Notion de tableau

1 Nindices

Opérations de base• Accès à un élément par son indice

Algorithmes classiques• Recherche d'un élément• Tri de tableau selon une relation d'ordre (>, <)• Fusion

Caractéristiques• Collection indicée d'éléments de même type

• Taille fixe • Accès aux composants

• Accès direct

Tableau à une dimension

Définitiont: tableau d’entiers de taille N //vecteur

Accès au i-ème élément• x t [i] // i 1..N• t [i] 10 // i 1..N

Algorithme de base

Répéter i [1,N] débuttraiter l’élément t[i]

fin

1 Ni

-35 7 2 -4 110

Tableau à deux dimensions

t : tableau NxM de réels // une matrice

Accès aux composants• t[i][ j] 5.67 // i 1..N; j 1..M • x t[i][ j] // i 1..N; j 1..M

Algorithme de base

Répéter i [1,N] // première dimension

début

Répéter j [1,M] // seconde dimension

début

Traiter l’élément t[i][ j]

fin

fin

Exemple. Algorithme avec un tableau

Bloc B3: trier un tableau

{

Objectif: trier un tableau en ordre croissant

Connu: -

Entrées: tab: le tableau et nbValeurs: son nombre d’éléments

Sorties: le tableau trié en ordre croissant

Résultats: -

Hypothèse: nbValeurs > 0

}

Début

{A: nbValeurs > 0}

Répéter i[1,nbValeurs-1]

Début

plusPetit i

Répéter candidat[i+1,nbValeurs]

Début

si(tab[candidat] < tab[plusPetit]) alors

Début

plusPetit candidat

Fin

Fin

……..

tampon tab[i]

tab[i] tab[plusPetit]

tab[plusPetit] tampon

Fin

{A: tab est trié en ordre croissant}

Fin

Retour au laboratoire #1

• La syntaxe décrit les formes correctes que peuvent prendre les éléments (expressions) d'un programme.

• La sémantique correspond à la signification des formes syntaxiques (c'est à dire aux constructions) d'un langage.

Syntaxe et sémantique


Syntaxe = l’ordre des éléments pour former une séquence correcte

Compilateur• Détecte les erreurs de syntaxe• Indique approximativement le lieu• Est incapable de les corriger

Un programme doit être syntaxiquement correct


Sémantique = Quel est le sens de ce qu’on écrit?

Erreurs sémantiques• Pas vues par le compilateur• Découvertes lors de l’exécution du programme

• Il « plante »• Il ne fait pas ce qui est demandé• Il ne s’arrête plus• …

Laboratoire #2

• Les erreurs de type sémantique dans un programme sont dues généralement à une mauvaise construction de l’algorithme correspondant (résolution du problème erronée). Un manière de contrer ce problème est de tester tout algorithme conçu (trace à la main : simulation à la main de l’exécution d’un algorithme) en choisissant adéquatement le jeu de données pour cette fin (il faut toujours penser aux cas limites ou d’exception).

• Attention : rien ne prouve qu’un algorithme est correct s’il passe correctement tous les tests que l’on peut imaginer! Il existe d’autres méthodes plus formelles pour démontrer l’exactitude d’un algorithme donné. On en reparlera sûrement.

Voici ce que vous êtes supposés de connaître:

L'architecture de Von Neuman:

• les périphériques d’entrée, de sortie: assurent la "conversation" avec un ordinateur via le clavier, l'écran, lecteur quelconque etc…

• L’unité de commande et de contrôle: le chef d'orchestre capable d'interpréter les instructions d'un programme et lancer des "ordres" aux autres composantes afin qu'elles soient exécutées.

• L’unité arithmétique et logique: la calculatrice. • La mémoire principale (rôle important dans la programmation

impérative):la partie déclarative de variables, réservation de la mémoire pour y entreposer les données utiles à l’exécution de la mémoire. Cette mémoire est comme un espace de rangement avec des « tiroirs » de différentes tailles : dans la réservation, on doit indiquer le type du tiroir.

Laboratoire #2

Laboratoire #3

Construction d’algorithmes simples

Il n’est pas nécessaire qu’ils décomposent leur solution en plusieurs blocs. Si certains zélés s’essayent, il faudrait que leur décomposition soit naturelle :

• la décomposition modulaire doit venir de la manière qu’ils ont résolu le problème en suivant une démarche descendante,

• les grandes lignes de la solution , • chaque grande ligne doit être raffinée dans un bloc à part,

le raffinement doit se terminer lorsque chaque instruction est décrite à l’aide d’uneinstructions de base.

Algorithme

Programme

Ordinateur

Description formelle

Transcription

CompilationLangage de programmation

Langage machine

Exécution Solution

Problème

Algorithme, programme et ordinateur

Exercices

Un algorithme naïf

Premier algorithme non trivial connu (295 avant J.C.):

Algorithme d'Euclide pour calculer le plus grand commun diviseur de deux nombres entiers.

Algorithme PGCD(m,n)i min(n,m)+1répéter

i i-1Tant que i ne divise pas m et nAfficher i

Exercice. Algorithme d'Euclide

Si n et m sont deux entiers > 0 avec par exemple n>=m, si r est le reste de la division de n par m, alors le PGCD de n et m vaut le PGCD de m et r.

Écrivez l’algorithme en pseudocode.

t m n15 21

15 6 156 3 63 0 3

Le PGCD est le dernier reste non nul.

Exercice. La division entière

Écrire un algorithme, Division, qui effectue la division de deux entiers positifs (notés x et y) donnés en utilisant uniquement la soustraction et l’addition.

L’algorithme doit afficher le résultat de la division ainsi que le reste.

Algorithme. Miroir d’un nombre entier

Exercice. Les nombres parfaits

Écrire un algorithme qui affiche la suite de tous les nombres parfaits inférieurs ou égaux à un nombre, entier positif donné noté n.

Un nombre est dit parfait s’il est égal à la somme de ses diviseurs stricts.

Exemple :

28 est un nombre parfait car 28 = 1 + 2 + 4 + 7 + 14

Voici la liste des nombres parfaits inférieurs à 10000 :

6, 28, 496, 8128.

Exercice. Rosalie dans le labyrinthe

Entrée

Sortie

Faire un pas devant elle. Tourner d'un quart de tour à gauche ou à droite. Détecter un mur placé devant elle. Détecter l'entrée du labyrinthe. Détecter la sortie du labyrinthe.

Les primitives

Si l'on considère deux suites numériques (U) et (V) telles que:

U1=U2=1Un = Un-1 +Un-2, pour tout n, un entier > 2

EtV= Un/Un-1

On montre que, si n est suffisamment grand, V tend vers une limite appelée nombre d'or (1,61803398874989484820458683436564).

Écrivez un algorithme qui calcule et affiche une approximation du nombre d'or tel que décrit précédemment.

Vous devez réfléchir à la condition d’arrêt dans l’approximation du calcul de V.

Exercice. Le nombre d’or

Il a été démontré que tout cube est égal à la somme de nombres impairs consécutifs.

Par exemple : 1 = 1 8 = 3 + 5 27 = 7 + 9 + 11 64= 13 + 15 + 17 + 19

Décrivez un algorithme qui lit un entier n strictement positif et donne une décomposition de n3.

Exercice. Propriété de nombres particuliers

Algorithme: un traitement de texte! début Demander CP {A: CP est un caractère}Afficher CP TANT QUE CP ‘!’

début Demander CL {A: CL est un caractère}

SI CL = CP ALORS début

Afficher le caractère de soulignement '_ ' fin

Afficher CL CP CL

fin fin

Exercice. Trace d’un algorithme

Qu’affiche cet algorithme si les données lues sont:" Etes vous efficace? ... Bonne chance!! "(Les guillemets ne font pas partie des données)

Proposez une décomposition fonctionnelle de l’algorithme précédent.

Complétez chaque bloc par:

les assertions aux endroits requis; les 8 commentaires de spécification internes.

Exercice…suite

Bloc B1: un traitement bien spécial

début

Demander CP

Afficher CP

TANT QUE CP ‘!’

début

faire le traitement (voir détails Bloc B2)

fin

fin

Bloc B2: le traitement

début

Demander CL


Afficher le caractère de soulignement '_ ’

fin

Afficher CL

CP CL

fin


début

Demander CP

Afficher CP

TANT QUE CP ‘!’

début


fin

fin


début

Demander CL



fin

Afficher CL

CP CL

fin

J’ai besoin de quoi?


début

Demander CP

Afficher CP

TANT QUE CP ‘!’

début


fin

fin


début

Demander CL



fin

Afficher CL

CP CL

fin

On quitte B1


début

Demander CP

Afficher CP

TANT QUE CP ‘!’

début


fin

fin


début

Demander CL



fin

Afficher CL

CP CL

fin

On a quitté...

J ’ai besoin de quoi?


début

Demander CP

Afficher CP

TANT QUE CP ‘!’

début


fin

fin


début

Demander CL



fin

Afficher CL

CP CL

fin

On a quitté...

CP et CL!


début

Demander CP

Afficher CP

TANT QUE CP ‘!’

début


fin

fin


début

Demander CL



fin

Afficher CL

CP CL

fin

Flux de donnéesentre B1 et B2

CP et CL!


début

Demander CP

Afficher CP

TANT QUE CP ‘!’

début


fin

fin


début

Demander CL



fin

Afficher CL

CP CL

fin

CP

CPCP…CL

Une entrée

Une sortie


début

Demander CP

Afficher CP

TANT QUE CP ‘!’

début


fin

fin


début

Demander CL



fin

Afficher CL

CP CL

finOn revient au point d’appel

Le point d ’appel


début

Demander CP

Afficher CP

TANT QUE CP ‘!’

début


fin

fin


début

Demander CL

SI CL = X ALORS début

Afficher '_ ’

fin

Afficher CL

X CL

fin

Paramètres formels de B2

Paramètre formel deB1mais effectif pour B2

Bloc B1: un traitement bien spécial{Objectif: intercaler le caractère de soulignement entre chaque suite

de 2 caractères identiques dans une phrase fournie par l'usager

Méthode: lecture séquentielle d'une suite de caractères, test sur 2 caractères successives

Besoin: la phrase à traiter Entrée: - Connu: - Sortie: - Résultat: ré-affichage de la phrase avec éventuellement le

caractère '_' séparant deux caractères successifs identiques.

Hypothèse: la phrase se termine par le caractère ‘!’}

Bloc B2: le traitement{Objectif: ajout du caractère de soulignement entre 2 caractères

successifs identiques Méthode: comparaison de 2 caractères successifs Besoin: CP : le caractère précédent, CL: le caractère suivantEntrée: CP Connu: - Sortie: le caractère suivantRésultat: affichage éventuel du caractère '_', CLHypothèse: CP et CL sont deux caractères}

Question

Est ce que c’est le même espace mémoire qui est associé à CP dans B1 et B2? En d’autres termes, est ce que c’est la même variable? Attention, ne confondez pas valeur assignée à une variable et variable (l’abstraction d’une cellule mémoire).

Exercice

Algorithme d'Euclide (version moderne)

Demander m, n{A:……………..}Tant que m>0début

t mm n % mn t

finAfficher n

t m n15 21

15 6 156 3 63 0 3

Si n et m sont deux entiers positifs avec par exemple n>=m, si r est le reste de n par m, alors le PGCD de n et m vaut le PGCD de m et r.

Le PGCD est le dernier reste non nul.

Demander nombreMaxnombreCourant 1Tant que ( nombreCourant <= nombreMax )debut sommeDiviseur 0 diviseurCourant 1 Tant que ( diviseurCourant < nombreCourant ) debut Si ( nombreCourant % diviseurCourant = 0 ) Alors début

sommeDiviseur sommeDiviseur + diviseurCourant fin

diviseurCourant diviseurCourant + 1 fin Si ( sommeDiviseur = nombreCourant ) Alors début

Afficher nombreCourant fin

nombreCourant nombreCourant + 1fin

Solution #1

Demander nombreMaxnombreCourant 2Tant que( nombreCourant <= nombreMax ) debut diviseurMax nombreCourant diviseurCourant 2 sommeDiviseur 1 Tant que( diviseurCourant < diviseurMax ) debut Si ( nombreCourant % diviseurCourant = 0 ) Alors début

sommeDiviseur sommeDiviseur + diviseurCourant diviseurMax nombreCourant / diviseurCourant sommeDiviseur sommeDiviseur + diviseurMax

fin diviseurCourant diviseurCourant + 1 fin Si ( sommeDiviseur = nombreCourant ) Alors début

Afficher nombreCourant fin

nombreCourant nombreCourant + 1fin

Solution #2 (?)

28 = 1 + 2 + 4 + 7 + 14

Algorithme: Sortir du labyrinthe en longeant le mur de gauche DébutAvancer d'un pasFaire un quart de tour à gaucheTant que Rosalie n'est pas sorti

DébutFaire un quart de tour à gaucheTant que mur en face Début

Faire un quart de tour à droiteFinAvancer d'un pas

FinFin.

Une solution pour Rosalie!

Algorithme: Sortir du labyrinthe en longeant le mur de gauche Début{A: Rosalie est en face de la porte d'entrée du labyrinthe }Avancer d'un pasFaire un quart de tour à gaucheTant que Rosalie n'est pas sortie


Faire un quart de tour à droiteFinAvancer d'un pas

Fin{A: Rosalie est sortie du labyrinthe}Fin.

Est ce utile de placer plus d’assertions?

Rosalie dans le labyrinthe

Algorithme: Sortir du labyrinthe en longeant le mur de gauche Début{A: Rosalie est en face de la porte d'entrée du labyrinthe }Avancer d'un pas{A: Rosalie a le dos face de la porte d’entrée barrée}Faire un quart de tour à gauche{A: le mur à longer est à gauche}Tant que Rosalie n'est pas sorti


Faire un quart de tour à droiteFin{A: il n'y a pas de mur en face}{A: Rosalie est dans la bonne direction}Avancer d'un pas


La solution avec des assertions

Quel est l’avantage?

Algorithme: Sortir du labyrinthe en longeant le mur de gauche Début{A: Rosalie est en face de la porte d'entrée du labyrinthe }{A: Rosalie a le dos face de la porte d’entrée barrée}{A: le mur à longer est à gauche}Tant que Rosalie n'est pas sortie

DébutTant que mur en face DébutFin{A: il n'y a pas de mur en face}{A: Rosalie est dans la bonne direction}



Le problème de Rosalie revu avec la décomposition fonctionnelle


Bloc B1: Sortir du labyrinthe en longeant le mur de gauche { objectif: faire sortir le Rosalie du labyrinthe méthode: en longeant le mur de gauche besoin: - connu: - entrée: sortie: - résultat: Rosalie est sortie du labyrinthe hypothèses : Rosalie est en face de la porte d'entrée} Début {A: Rosalie est en face de la porte d'entrée du labyrinthe } avancer d'un pas{A: Rosalie a le dos face de la porte d’entrée barrée}Repérer le mur de gauche (voir bloc B2){A: le mur à longer est à gauche}Longer le mur de gauche jusqu'à la sortie (voir bloc B3){A: Rosalie est sortie du labyrinthe} Fin.

Bloc B2: Repérer le mur de gauche { objectif: repérer le mur de gauche méthode: pivoter une fois vers la gauche besoin: connu: - entrée: sortie: - résultat: Rosalie a fait un quart de tour à gauche hypothèses : - } Début Faire un quart de tour à gauche{A: le mur à longer est à gauche} Fin

Bloc B3: Longer le mur de gauche jusqu'à la sortie { objectif: longer le mur de gauche jusqu'à la sortie méthode: avancer d'un pas et longer le mur de gauche besoin: connu: - entrée: sortie: - résultat: Rosalie est sortie du labyrinthe par la porte de sortie hypothèses : - } DébutTant que Rosalie n'est pas sortie Début

avancer d'un pas en longeant le mur de gauche (voir bloc B4){A: Rosalie avance d'un pas en longeant le mur de gauche}

Fin

{A: Rosalie est sorti du labyrinthe }Fin

Bloc B4: Avancer d'un pas en longeant le mur de gauche { objectif: avancer d'un pas en longeant le mur de gauche méthode: se mettre dans la bonne direction et avancer d'un pas besoin: connu: - entrée: sortie: - résultat: Rosalie avance d'un pas en longeant le mur de gauche hypothèses : -} Début se mettre dans la bonne direction (voir bloc B5){A: Rosalie est dans la bonne direction}avancer d'un pas{A: Rosalie avance d'un pas en longeant le mur de gauche}Fin

Bloc B5: Se mettre dans la bonne direction { objectif: se mettre dans la bonne direction méthode: faire des quarts de tour besoin: connu: - entrée: sortie: - résultat: Rosalie est dans la bonne direction hypothèses : -} Début

faire un quart de tour à gaucheTant que mur en face Début

faire un quart de tour à droiteFin{A: il n'y a pas de mur en face}

{A: Rosalie est dans la bonne direction}Fin

On peut chercher à décomposer un cube à partir de 1 :

S = (1 + 3 + ... + (2p-1) + (2p+1))

en incrémentant p jusqu'à ce que S ≥ n3.

En cas de dépassement (S > n3), il faut alors éliminer les nombres impairs les plus faibles à gauche :

S = ((2q-1) + (2q+1) + ... + (2p-1) + (2p+1))

jusqu'à ce que S = n3 (en incrémentant successivement q et p on finit par atteindre n3 exactement).

Solution. Propriété de nombres particuliers

Algorithme: développement d’un cube en une série de nombres impairs consécutifs.Début Demander n {A: n est un nombre entier > 0} cube n*n*n s 0 p 1 k 1 Tant que (s cube) début si (s>cube) alors début

s s - (2*k-1)k k + 1

fin si ( s<cube) alors début

s s + (2*p -1)p p + 1

fin fin

Solution. Propriété de nombres particuliers

premier 2*k -1 {le premier terme de la série}dernier 2* (p-1) -1 {le dernier terme}Afficher cube " = "k premier Tant que (k < dernier) début

Afficher k " + " k k+2

finAfficher dernier

{A: n3 est développé en une série de nombres impairs consécutifs}fin

Solution. Le nombre d’orAlgorithme: Calcul du nombre d’orDébut Demander précision {A : précision est un nombre réel compris entre 0 et 1 exclusivement {précision est l’écart minimum qui sera toléré entre 2 calculs successifs pour arrêter les itérations. Par exemple : 0.0001 u11 u21 Répéter

u3 u2+u1v1 u2/u1 {v1 est une approximation du nombre d’orv2 u3/u2 {v2 est l’approximation suivanteu1 u2u2 u3

diff v2-v1 {on détermine l’écart entre 2 calculs successifs Si ( diff < 0) Alors {simulation de la valeur absolue début

diff -diff fin Tant Que ( diff > précision) {on répète tant qu’on a pas atteint la précision souhaitée

Afficher v2 {A : v2 contient une approximation du nombre d’orFin

Algorithme. Miroir d’un nombre entier

DébutDemander n{A: n est un entier ≥ 0}

a0 Tant que (n 0) début a a*10 + n%10 n n÷10 fin

Afficher a{A: a contient la valeur miroir de n}Fin

Un exemple d’évaluation d’expression:

x * x 0 ET ( x + 1 ) * ( x + 1 ) < 162 2 2 2

3 3

94

V V

V

L’unité arithmétique et logique

Un exemple d’évaluation d’expression:

x x 0 x 1 x 1 162 2 2 2

+ +

**

<

ET

L’unité arithmétique et logique

programme de baccalauréat en informatique algorithmique et programmation ift-17582 abder alikacem...

Documents