Briques de base

Le pseudo-code est constitué d'instructions dont le but est soit de manipuler des objets (création, affectation ou lecture) ou de contrôler le flux d'instructions (test et boucles).

Commençons par décrire les objets que l'on peut manipuler en pseudo-code et les moyens d'y accéder.

Objets et variables

Objets basiques

Les objets que nous aurons directement à notre disposition sans avoir besoin de les définir sont appelés objets basiques et sont au nombre de cinq :

• le vide (nommé None en python, null en javascript ou encore void en C)
• les booléens (vrai et faux)
• les nombres entiers
• les nombres réels
• les caractères

Tous les autres types d'objets que l'on peut créer seront des compositions de ces 5 types d'objets (un point en 3D par exemple est constitué de 3 réels).

Les instructions liées à ces objets sont de deux ordres. On doit pouvoir :

• créer des objets
• opérer sur ces objets :
  • opérations sur les entiers et/ou réels :
    • arithmétique : addition (+), soustraction (-), multiplication (*), division (/)
    • opérations usuelles : prendre la valeur entière, valeur absolue, le modulo
    • logique : égalité (avec le signe == ou =), plus petit que (<), plus grand que (>), plus petit ou égal (≤), plus grand ou égal (≥)
  • opérations sur les caractères :
    • logique : égalité (avec le signe ==)
  • opérations sur les booléens : "négation logique" (non, NOT, $\neg$), "et logique" (et, &&, AND), "ou logique" (ou, ||, OR)

Notez que tous les objets basiques à part les entiers sont de taille fixe :

• booléen 1bit
• caractères 32bits si on utilise les caractères Unicode
• réel norme IEEE sur 64bits

On peut très bien sans perte de généralité se restreindre aux entiers entree 0 et $2^{64}$, et c'est d'ailleurs ce que beaucoup de langages de programmation font, puisque qu'un entier quelconque peut être représenté en base $2^{64}$ et ainsi être représenté par un tableau d'entiers codé sur 64bits. C'est d'ailleurs ce qui se passe en python pr exemple où un entier, qui n'est pas borné, est composé d'un tableau d'entiers codés sur 64bits. Ceci est cependant transparent pour l'utilisateur (et c'est tant mieux).

Variables

Les objets que l'on manipule doivent pouvoir être conservés pour que l'on puisse les réutiliser tout au long du programme. Cet espace espace de stockage, que l'on nomme une mémoire, est identifié d'un point de vue algorithmique, à une gigantesque suite de cases adjacentes à laquelle l'algorithme peut accéder en 1 instruction et pouvant contenir un objet basique.

Une variables est alors associé à la première case de la mémoire contenant l'objet. D'un point de vue algorithmique, cela revient à référencer un objet, à le nommer :

Les instructions autorisées sur les variables sont :

• l'affectation : a = 3 défini le nom a (appelé variable) qui est associé à un entier valant 3. (vous verrez parfois utilisé $a \leftarrow 3$ à la place de $a = 3$ pour qu'il n'y ait pas de confusion si l'on utilise = pour l'égalité)
• la lecture. Si j'ai affecté 3 à la variable a, je dois pouvoir l'utiliser, par exemple en écrivant b = a * 3
• l'affichage à l'écran. Pour permettre un retour à l'utilisateur de ce qu'à produit le pseudo-code.

a = 3
b = a

Structures

Les objets basiques sont les briques élémentaires permettant de créer tout ce dont un algorithme à besoin. Un nombre complexe est composé de 2 approximations de réels ou une phrases d'une suite de caractères par exemples. Gérer ces objets complexes, appelés structures, se fait aux tableaux. Comme une structure est toujours in fine composée d'objet basiques :

Tableaux

Les différentes variables du tableaux sont stockées de façon contiguë en mémoire pour pouvoir y accéder rapidement pour y être lu ou modifiée.

Les tableaux peuvent être simples comme une suite finie d'entiers ou des types plus complexes comme une matrice à 2 dimensions où chaque élément du tableau est un autre tableau.

On considérera que :

• la création d'un tableau prend 1 instruction : [1, 3, x] crée un tableau qui affecte à sa variable :
  • d'indice 0 un entier valant 1
  • d'indice 1 un entier valant 3
  • d'indice 2 l'objet associé à la variable x
• l'affectation d'un tableau à une variable prend 1 instruction : t=[1, 3, x] prend 2 instructions une pour la création et une pour l'affectation
• l’accès à un élément particulier du tableau se fait en 1 instruction et en utilisant les crochets : t[2] vaut le caractère "l"

Les opérations sur les tableaux sont faites graces aux opérations des objets basiques qui les composent. Il n'y a pas d'opérations spécifiques à ceux-ci :

Chaînes de caractères

Les chaines de caractères sont un tableau uniquement composés de caractères. Cette structure est utilisée lorsque l'on veut écrire ou représenter plus qu'un caractère, c'est à dire quasi tout le temps.

Une chaîne de caractères est un tableau constitué uniquement de caractères.

On peut les manipuler essentiellement comme un tableau. On peut :

• créer une chaîne de caractères : "salut" crée la chaîne contenant les caractères "s", "a", "l", "u" et "t" de façon contiguë en mémoire.
• affecter une chaîne de caractères à une variable prend 1 instruction : s = "salut" prend 2 instructions, une pour la création et une pour l'affectation.
• accéder à un caractère particulier en utilisant les crochets : s[2] vaut le caractère "l"

Les chaines étant très utilisées, des langages comme python les considèrent comme un type de base et considèrent les caractères comme étant des chaîne de langueur 1. Les chaines de caractères héritent donc de certains comportements spécifiques aux objets basiques :

• une fois crées on ne peut pas les modifier (s[2] ="p" n'est pas une instruction valide).
• on définit l'opération de concaténation avec l'opérateur + : "salut" + " toi !" vaut la chaîne de caractères "salut toi !"

Instructions de contrôle

Si un des deux buts d'une instruction est de créer des objets à partir d'autres (ce que l'on vient de voir), le second but est de contrôler le flux d'instructions à exécuter. Ces instructions sont de deux types :

• l'exécution conditionnelle d'instructions,
• la répétition d'instructions

Ces formes d'instruction nécessitent de grouper les instructions en blocs.

Blocs

Lier les instructions en blocs. On va utiliser ici le formalisme de python pour définir un bloc :

type de bloc:
    instruction 1
    instruction 2
    ...
    instruction n

On décale les instructions du bloc de sa définition. C'est un truc clair qui permet de voir du premier coup d'œil les instructions d'un bloc.

Exécution conditionnelle d’instructions

On veut pouvoir exécuter un bloc de code si une condition logique est vérifiée :

si (condition logique) est vraie:
    instruction 1
    ...
    instruction n

Cette instruction basique peut avoir plein de variantes comme :

si (condition logique) est vraie:
    instruction 1
    ...
    instruction n
sinon:
    instruction 1
    ...
    instruction n'

ou encore :

si (condition logique) est vraie:
    instruction 1
    ...
    instruction n
sinon si (autre condition logique) est vraie:
    instruction 1
    ...
    instruction n'

Ou tout mix de tout ça, du moment que c'est clair !

Répétition

TBD : dire que l'on en a de deux types : for et while. Que l'on peut tout faire en while mais les boucles for sont plus lisible, en particulier leur condition d'arrêt est claire.

On doit pouvoir répéter un bloc tant qu'une condition logique est vérifiée (boucle while):

tant que (condition logique) est vraie:
    instruction 1
    ...
    instruction n

Il existe une variation de ce bloc très utile (boucle for):

pour chaque élément x d'un tableau:
    instruction 1
    ...
    instruction n

On exécutera alors le bloc autant de fois qu'il y a d'éléments dans le tableau et à chaque itération du bloc, la variable x vaudra un autre élément du tableau. On prendra les éléments du tableau par indice croissant.