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()
ca
ab
bc
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
dx+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.
