Vous êtes sur la page 1sur 8

ALGORITHME

Un algorithme n'est jamais lié à un langage.

Principe de l'algorithme

L'algorithme doit être lisible, compréhensif

Règles d'algorithme :

- le nom le rôle, expliquer du résultat, le principe


- le corps : délimité par les mots début et fin
- description des variables d'écrire leur type

Convention
- mettre les identifiants des variables en minuscules, le nom de la variables doit refléter
son contenu
- nom de la fonction ou de la procédure : une majuscule au début de chaque mot, coller,
ou on utiliser des underscor.
- PQL : Plan qualité logiciel (description des normes algorithmique)

Les variables :
Une variable doit avoir un nom, une valeur et un type
Le type correspond au différente valeur de la variable

Les différents typess : entier, réel, boolean, les cractères(alphabétique ou numérique), les
chaînes de caractères (attention aux typages des varaibles);

Les operateurs mathématique : +,-,/,*, div(modulo)


Les opérandes
- opérateur binaire
- opérateur ternaire
- opérateur unaire

L'opérateur est associé à un type de donnée :

Les opérateur booleen :


- non
- et logique : il fout que les 2 opérandes soit vrai que la résultat soit vrai, si non faut
- ou logique : il faut au moins une opérande soit vrai pour le résultat soit vrai, si non le
résultat est faux.
- ou exclusif : les opérandes doivent avoir des valeurs différents

Les opérateur s de comparaison

Les priorités :
La multiplication est prioritaire sur la division et la soustraction
3 * 2 + 5 = 11
3 * (2 + 5) = 21

Les affectations : elles sont font toujours de la droite vers la gauche


ex : c  a + b
Si c avait une valeur avant l'affectation la valeur est perdu.

Afficher et lire le contenu d'une variable


variable  lire()
ecrire (variable)

Nom : carreEntier
Rôle : calculer le carré d'un entier et l'afficher
Donne : valeur entrer par l'utilisateur
Résultat : carre d

proc principale

début
ecrire ("Entrer une valeur")
valeur  lire()
carre  valeur * valeur
ecrire (carre)
fin

Ecrire un programme entrer deux valeur est les interchangé

Nom : changeValeur
Rôle : Echanger les valeurs de saisies
Donnee : les 2 valeurs saisies au clavier
Résultat : les 2 valeurs échangées
Principe :
debut
ecrire("Entrer deux valeurs")
a  lire()
b  lire()
ca
ab
bc
ecrire( "Valeurs de a et b"a,b )
fin
Lexique :
a, b, c: réel

Instructions

Instruction Si : instruction booléenne

Instruction Si, sinon

Ex

Ecrire un algo qui définit si une valeur est multiple de l'autre


Sachant que pour le diviseur (2 à 10)
Afficher si, c'est un multiple ou non
Afficher le résultat.

1 er test : la 1 er valeur doit être plus grand que la deuxième.


Multiple :
Rôle : rechercher si une valeur est multiple d'un nombre
Donnée : valeur saisies
Résultat :
Principe :

debut
ecrire("Entrer deux nombre")
valeur1  lire()
valeur2  lire()
if (valeur1 > valeur2) alors
resultat  valeur1 divvaleur2
reste  valeur1 mod valeur2

Les tableaux :

Un tableau doit être déclaré de même type, toutes les valeurs doit avoir un type commun.
Pour accéder à un élément du tableau, on utilise l'indice

Affectation d'un élément de tableau à une variable :


x  t[i]

Initialiser le contenu d'un tableau

Tableau[1..10] : permet de saisir et mémoriser des valeurs 0 à 100


Nom : saisiValeurTableau
Role : Saisir et remplir un tableau de 10 éléments contenant des valeur compris entre 0 et 100.
Donnee : les valeurs saisies
Résultat : le tableau rempli
Principe : Utiliser une boucle pour remplir le tableau et faire un teste à l'intérieur de la boucle
pour tester que la valeur soit compris [0,100]

debut
pour i de 0 à 9 faire
ecrire("Entrer un nombre")
valeur  lire()
si valeur > = 0 et valeur < = 100 alors
t[i] <- valeur
fsi
fpour
fin

Lexique :

Fonction et procédure

Le principe d'une ne peut avoir que des paramètres en entrée


Fonction addition(x : entire, y : entire) : reel
d : entire
dx+y
retourner d
Fin
Debut
a, b, c : entier
c = addition(a,b)
Fin
addition(

Procédure peut avoir des paramètres :


- entrée
- entrée
- entrée-sortie

Algo Saisir 10 valeurs dans un tableau :


Fonction saisie
Fonction mini
Fonction maxi
Fonction moyenne

Procédure Saisie(e t[i] :entier, e taille : entier)


i : entier
pour i de 0 à taille faire
ecrie("Entrer un entier")
t[i]  lire()
finfaire
Fin

Fonction rechercheMax(e t[i] : entier, e taille : entier)


max : entier

max  t[0]
pour i de 1 à taille faire
if t[i] > max alors
max  t{i]
finsi
finfaire
retourner max
Fin

Fonction rechercheMin(e t[i] : entier, e taille : entier)


min : entier

min  t[0]
pour i de 1 à taille faire
if t[i] < min alors
min  t{i]
finsi
finfaire
retourner min
Fin

Procedure calculMoyenne(e t[i] : entier, e taille : entier, s x_moyenne : réel)


somme : entier
Debut
somme  0
pour i de 0 à taille
somme = somme + t[i]
Finfaire
x_moyenne  somme/taille
Fin

Programme principale
MAX  10
minTab, maxTab : entier
tab tableau[MAX] : entier
Saisie(tab, M)
minTab = rechercheMax(tab, MAX)
maxTab = rechercheMaxtab,Min)
calculMoyenne(tab,MAX, moyenne)

ecrire("La valeur de max est :"maxTab)


ecrire("La valeur de min est :" minTab)
ecrie("La moyenne est :" moyenne)

Fin

Exercice résolution d'une équation du second degre

Programme principale

Début
a,b, c, delta : entier

ecrire("Entrer a : ")
a  lire()
ecrire("Entre b:")
b  lire()
ecrire("Entrer c")
c  lire()

delta  calculDiscriminant(a,b,c)
calculRacine(delta, racine)

Fin

fonction calculDiscirminant(x : entier, y : entier, z : entier)


d : entier

d = (y ^2) – (4*x*z)
returner d
Fin
Fonction calculRacinePositif(e x : entier, e y : entier, e delta :entier, r1 : entier, r2 : entier)

r1, r2 : entier
r1 = - y –sqrt(delta)/2 * x
r2 = - y + sqrt(delta)/2 * x
Fin

Utilisation obligatoire des fonctions, le nombre de choix possible de p par rapport à n


Exercice 3 Choix possible p pour n
Combien de possibilité y a-t-il pour que tire N numéros sur une grille d'un ensemble

Formule
n!/p!*(n-p)!

var p,n, nbPass : entier


Début
écrire("Saisir le nombre de numéro tirés")
p  lire()
écrire("Saisir le taille de la grille des nombres")
n  lire();
nbPass  factorielle(n)/ factorielle(p)* factorielle(n-p)
Fin

Fonction factorielle(val : entier) : entier


var i, res : entier

Debut
res  val
pour i de 1 à val-1 faire
res  res *i
finpour
Fin

Fonction récursif

Fonction Facto(n : entier) : entier


Début
si n = 1 alors
renvoyer 1
sinon
renvoyer Facto(n-1) * n
finsi
Fin
………………………………............

Algorithme de trie : peut aller du simple et plus complexe.

Les tries à Bull : n'est pas trop optimisé. Le principe c'est de balayer tout le tableau, et on va
comparer élément par éléments (2 par 2) élément en cours avec l'élément suivant. Si l'élément
en cours et plus grand que la suivante en échange. Il faut faire 2 boucles imbriqué. Il faut le
tableau soit pré-reillé
Trie par insertion
On part du principe, qu'on déplace les éléments au bon endroit.
Pour le trie insertion fonctionne, il faut que la tableau soit déjà triller.
Utiliser. Pour insérer la valeur :
- soit on fait un décallage
- soit on dimentionne
- soit on supprime un élément

12345 insertion de 8

Trie par sélection, le tableau n'est pas triller au départ. Il faut rechercher la plus petite valeur.
Ensuite on la mais dans la première position, et on reboucle

82031
02831
01832
01238

Tableau pré-triller (pré-shell)


Le tableau est presque triller, Le tableau pré-triller à 4 rang pré
Et ensuite on fait un trie à bull

Déterminer le pas du Shell : prendre des caleurs qui ne sont pas pert et qui ne sont pas
multiples entre elles

Quick Sort
Le trie le plus rapide, trie de récurssion. On choisi une valeur dans le tableau éléatoire. et on
cherche la position définitive de cette valeur. Eµnsuite on exécute des déplacements. On
compare la valeur médiane. Puis au décalle la madiane vers la gauche et en redivise par 2.

Recherche récursif

On par de la moitié du tableau

Structure dynamique

Un pointeur : c'est une variable au lieu de contenir une valeur, va contenir l'adresse d'une
valeur. Le pointeur indique l'adresse le premier élément de la structure.
Un pointeur doit être initialisé à null au départ, un contient une structure de même type.