L’algorithmique et la programmation

La révolution industrielle du début de siècle a permis d’augmenter les possibilités physiques de l’homme, de remplacer les tâches physiques répétitives. La révolution informatique a, quant à elle, permis d’augmenter les possibilités mentales de l’homme, de remplacer les tâches mentales répétitives.  Les ordinateurs donnent la possibilité de réaliser certaines tâches mentales répétitives en réalisant des opérations simples très rapidement. Un algorithme décrit une tâche à effectuer. C’est une suite de pas élémentaires permettant de réaliser une tâche.  Voici quelques exemples concrets permettant de mieux comprendre ce qu’est un algorithme :

Pour amener une machine à réaliser une tâche, il faut :

1.        Concevoir un algorithme qui décrive la tâche à exécuter.

2.        Exprimer l’algorithme dans un langage de programmation.

3.        Faire exécuter le programme par la machine.

 Un algorithme ne dépend pas du langage de programmation dans lequel il est implanté, ni de la machine qui exécute le programme correspondant.

 Exemple : Les recettes peuvent être exprimées dans des langues différentes, pourtant une recette mène au même résultat (au même plat).

 Un algorithme peut être plus ou moins long (temps) et  plus ou moins conséquent (espace mémoire). Un algorithme est bien évidemment meilleur s’il s’exécute rapidement et s’il prend le moins d’espace mémoire possible.

 Comme dit précédemment, un algorithme est la description d’une façon de réaliser une tâche. Souvent une tâche nécessite des ingrédients (entrées) et produit un résultat (sortie).

Examinons les entrées et les sorties des exemples précédents :

 Souvent, un programme informatique a en entrée des informations (d’où le terme « informatique »). Par exemple, pour le calcul de la paye, les données sur les employés, comme les heures qu’ils ont effectuées, la base de calcul du salaire, etc.

Les 3 étapes principales d’un algorithme :

1.        La préparation du traitement : déterminer les données nécessaires à la résolution du problème (la tâche).

2.        Traitement : résolution pas à pas après décomposition en sous-problèmes si nécessaire.

3.        Édition des résultats

 L’étape 2 est constituée de plusieurs étapes.

Une étape est une suite d’instruction.

Une instruction manipule des objets qui ont chacun :

      Un identificateur
Un type
Une valeur

Exemple :

Identificateur : temps
Type : nombre entier
Valeur : 28

Ou encore

Identificateur : Salaire
Type : nombre à virgule
Valeur : 9653,90

 Un exemple d’algorithme :

 Algorithme SommeDe3

{ Étant donnés trois nombres X, Y, Z, cet algorithme calcule leur somme}
{déclaration des identificateurs (variables) : ici 4 nombres entiers}

Variables X, Y, Z, Somme : entier ;
Début                  {Préparation du traitement}
Afficher (« Tapez successivement trois nombres entiers »)
Saisir (X,Y,Z) 

Somme ß X + Y + Z     {traitement}

{Édition des résultats}

Afficher (« la somme de »,  X)
Afficher (« de », Y)
Afficher (« et de », Z)
Afficher (« est égale à », Somme)
Fin

L’instruction de lecture de données

 Syntaxe : Saisir (<liste de noms des variables>)

 Fonction : L’utilisation de la commande signale à la machine que l’utilisateur va fournir une valeur pour chacune des variables de la liste ; lors de l’exécution, la machine s’arrête et attend cette valeur ; lorsqu’elle lui est fournie, elle crée un objet qui a pour identificateur le nom de la variable, pour type le type donné en déclaration, et pour valeur, la valeur fournie par l’utilisateur.  

Exemple : Saisir(X) Saisir(X,Y,Z)  

Bon stop faisons le point. Depuis quelques lignes, nous vous parlons de variables ... pour les plus âgés  d’entre nous (pour ceux qui ont poussé leurs études jusqu’au lycée), il est facile de comprendre ce que cela représente. Pourtant nombre de fois, il s’est avéré que de jeunes programmeurs (Junior) ont dû stopper leur apprentissage de la programmation car les auteurs de leurs sources de documentation pensaient que les bases de la programmation comme les variables étaient évidentes.  On peut se représenter les variables comme des containers (des poubelles quoi ! !). Bien que le tri des ordures dans le monde réel soit d’actualité depuis peu, il a toujours était ainsi dans le monde de la programmation. Nous ne mélangeons pas les choux et les carottes. Il faut en plus savoir qu’un container ne peut contenir qu’un seul élément ... Ainsi chaque carotte sera contenu dans un container à carotte différent, et chaque choux dans un container à choux différent. Evidemment il est possible de remplacer un élément dans un container, à condition qu’un choux soit remplacé par un choux.  Ex : On déclare 2 Containers à carottes (donc deux carottes que l’ont peut mettre dedans) et 1 container à choux :

Vous ne pouvez pas mettre ce que contient le container qui s’appelle ContCAR dans le container de nom ConChoux car leur type de container est différent (bien qu’il y ait des exceptions). 

Par contre il est tout à fait possible de mettre la carotte contenu dans ContCAR dans le container PoubCAR. 

Une chose importante est à signaler, lorsque vous mettez le contenu d’un container dans un autre, l’élément dans le container qui reçoit, est écrasé par le nouvel élément (dans ce cas la carotte de ContCAR écrase celle de PoubCAR). Nous avons donc dupliqué notre carotte (si cela avait été des pains nous aurions certainement une statue à notre nom), l’une se trouve toujours dans ContCar, et l’autre, la copie de la première, dans PoubCAR.  

Une dernière chose à savoir est que votre rue n’est pas suffisamment grande pour mettre une infinité de container; cette place est limitée, c’est pourquoi il est impératif de bien nettoyer devant sa porte.  Mais qu’est-ce que les containers et les variables ont en commun nous demanderez-vous ?  Eh bien tout ! 

Une variable à un type indiquant ce qu’elle peut contenir, un nom unique, qui permet de l’identifier par rapport aux autres variables, et une valeur qu’elle contient. De plus la rue sur laquelle vous disposez vos containers, c’est tout simplement la mémoire de votre ordinateur. Plus elle est encombrée, et plus vos programmes sont lents.  Bon, nous espérons que ce petit cours sanitaire vous aura permis de comprendre les variables à défaut de vous avoir donné envie de trier vos ordures ;-)  

Dans notre exemple précédent, la commande Saisir(X,Y,Z) demande à l’utilisateur de taper un nombre au clavier qu’elle dépose ensuite dans la variable de nom X, puis un autre dans la variable Y puis la troisième dans la variable Z. 

L’instruction d’écriture de données

 Syntaxe : Afficher(<liste de noms des variables ou des messages>)

 Fonction : La machine affiche à l’écran les valeurs des variables et/ou le contenu des messages. Exemple :

 Afficher (X)            //cela affiche le contenu de la variable X

Afficher (X,Y,Z)  //cela affiche le contenu des variables X, Y, Z

Afficher (« ceci est un message.» )

Afficher (« Vous avez gagné », X ,  «  francs » )      // ceci affiche : Vous avez gagné  200 francs si la valeur contenu dans X était 200.

 L’instruction d’affectation

 Syntaxe : <identificateur> ß <expression>

<expression> étant soit une variable constante (dont la valeur reste la même du début à la fin du programme), soit une variable, soit une expression arithmétique (une opération).

 Fonction :

Attribue à l’objet identifié par <identificateur> la valeur de <expression>. Si l’objet <identificateur> avait déjà une valeur (s’il contenait déjà un élément), cette dernière est remplacée par la nouvelle valeur.

 Exemple :

  Constante : X ß 5        {l’objet X prend la valeur 5. 5 est une constante car sa valeur ne changera pas au cours du programme, ni au cours de l’éternité d’ailleurs.}

·         Variable : X ß Y        {l’objet X prend la valeur de l’objet  Y (variable dont le nom est Y)}

·         Expression : X ß Y*(Y-1)        {l’objet X prend comme valeur le résultat de l’opération Y*(Y-1)}

·         Expression et constante : X ß X-1        {si l’objet X avait la valeur a, il a désormais la valeur a-1}