Corpus d’instructions élémentaires

Corpus d'instructions élémentaires

Corpus d’instructions élémentaires 

Ce document présente l’ensemble des instructions élémentaires auxquelles il est possible d’avoir accès en programmation, quelque soit le langage utilisé. 

1) Types de base 

Les types de base sont les entiers (-1, 3, 48, …), les réels (3.24, 7.21,..), les booléens (qui prennent les deux valeurs logiques Vrai (True) ou Faux (False)), les caractères (a, b, c, …) et les chaînes de caractères (abc, def, NSI, mathématiques, …).

2) Variables

Afin d’utiliser une variable, il faut la nommer et lui attribuer un type, parmi les types de base précédent. C’est la phase de déclaration.

3) Opérateurs

Il est possible d’avoir recours à différents opérateurs :
– arithmétiques: + (somme), * (produit), % (division euclidienne), – (différence), / (division), ^ (puissance)
– logiques: AND (et), OR (ou), NOT (négation)
– relationnels : =, >, >=, <, <=, <> (différent)
– concaténation : +, il est permet de concaténer deux chaînes de caractères. Par exemple, PA + PA $to$ PAPA 
– fonctions numériques : $cos$, $sin$, abs (valeur absolue), sqrt (racine carrée), floor (partie entière) notée en mathématiques $lfloor rfloor$. Par exemple, $lfloor 3,56 rfloor = 3 $ et lfloor – 3,56 rfloor = -4$
– fonctions sur les chaînes, qui permettent par exemple de calculer la longueur d’une chaîne. 

4) Affectation d’une variable

L’affectation est symbolisée d’un point de vue algorithmique par $leftarrow$.
Exemple :
$A leftarrow 1$, on affecte à la variable $A$ qui est de type entier la valeur $1$
$flag leftarrow$ TRUE, on affecte à la variable booléenne $flag$ la valeur logique TRUE (vraie).

5) Variables indices ou tableau

Si on dispose d’un tableau $T$ contenant 10 “places”, on peut affecter à une de ses places une valeur :
$T[5] leftarrow 3$

6) Afficher

L’ordinateur peut afficher le contenu d’une variable à l’aide de la commande suivante :
print(A), qui affiche la valeur stockée dans la variable $A$

7) Lire

Cela permet à l’ordinateur de demander à l’utilisateur de rentrer une variable, à l’aide de la commande :
READ(x), l’ordinateur affecte donc à la variable $x$ la valeur entrée par l’utilisateur sur le clavier.
Il faudra veiller à être cohérent entre le type attendu par la variable $x$ et le type que l’utilisateur demande en écrivant la variable sur le clavier.

8) Test 

On peut effectuer des tests qui produisent une réponse adaptée en fonction du résultat à l’aide du modèle suivant :
Si … alors … sinon…

IF condition THEN
    $big |$ séquences instructions 1 (qui sont effectuées lorsque la condition est vérifiée)
                  ELSE (sinon)
    $big |$ séquences instructions 2 (qui sont effectuées lorsque la condition est fausse)

Ce test peut se représenter à l’aide du diagramme suivant :

Exemple :

IF A < B THEN
    DISP(A)
             ELSE
    DISP(B)
ENDIF

Ce programme compare $A$ et $B$, si $A < B$, on affiche $A$ sinon on affiche $B$. Ce programme permet donc d’afficher la plus petite valeur entre $A$ et $B$.

Si on avait affecté aux variables les valeurs suivantes :
$A leftarrow 2$
$B leftarrow 7$ 
Alors le programme affiche la valeur contenue dans la variable $A$ car $2 < 7$ c’est à dire $2$.

9) Boucle bornée

Il s’agit d’une boucle dont on connait à l’avance le nombre d’itérations requis. La syntaxe est la suivante :
FOR variable FROM valeur1 TO valeur2 BY pas DO
    $big |$ séquences instructions
ENDFOR
Cela signifie que variable (entière) va varier de valeur1 à valeur2 en augmentant de pas entre chaque itération. Lorsque pas est omis, cela signifie que le pas vaut 1.

Exemple :
$S leftarrow 0$
FOR i FROM 1 TO 5 DO 
    $S leftarrow S + I$
ENDFOR
DISP(S)

On représente sous forme d’un tableau les différentes valeurs prises par les variables $I$ et $S$ au cours des différentes itérations.

10) Boucles non bornées

a) Boucle WHILE
Il s’agit d’une boucle dont on répète des instructions tant que la condition est vérifiée. Cette boucle a pour syntaxe :
WHILE condition DO
    $big |$ séquences instructions
ENDWHILE

Cette boucle peut se représenter à l’aide du diagramme suivant :

Si la condition est toujours remplie, alors les instructions sont répétées indéfiniment et le programme ne sort jamais de la boucle.

Exemple :
On souhaite créer un programme donnant le reste dans la division euclidienne de $A$ par $B neq 0$ sans utiliser la fonction déjà codée. L’idée du programme consiste à retirer à $A$ la valeur de $B$ autant de fois que possible. 

WHILE A>=B DO (si $A geq B$, on peut soustraire $B$ à $A$)
    $A leftarrow A – B$ 
ENDWHILE
(Lorsque l’on ne peut plus soustraire $B$ à $A$, $A$ contient alors le reste)
DISP(A)

Supposons que les variables sont affectées des valeurs suivantes :
$A leftarrow 19$
$B leftarrow 7$ 

On représente sous la forme d’un tableau les valeurs prises par les variables lors de l’exécution du programme précédent.

Lorsque le programme est exécuté, la condition $19 geq 7$ est remplie. On affecte à $A$ le résultat de $19 -7$ c’est à dire $12$.
On compare ensuite $12$ et $7$. Comme la condition est respectée on soustrait à nouveau $B$ à la nouvelle valeur de $A$.
A la fin du programme, l’ordinateur renvoie la valeur $5$. 

On pourra remarquer que le nombre de passages dans la boucle donne le quotient de la division euclidienne de $A$ par $B$. 

b) Boucle REPEAT

La syntaxe de cette nouvelle boucle est :
REPEAT instructions UNTIL condition

Il est tout d’abord interessant de noter que les instructions sont situées tant la condition. Ainsi, dans tous les cas, les instructions sont au moins réalisées une fois. Si la condition est vérifiée, le programme sort de la boucle, sinon les instructions sont à nouveau appliquées.