Collections de données

Avertissement Cette page a été initialement créée avec AlgoTouch version 3, reflétant les principes fondamentaux qui restent au cœur du système. Depuis, AlgoTouch a évolué vers la version 5, offrant des fonctionnalités améliorées tout en conservant son essence originale.

Table des matières

Vidéo du tutoriel

Chapitres

Exercices d'application

Exercice : incrémentation des valeurs

Sujet

Soit le tableau (collection) t contenant la suite des valeurs [5, 1, 7, 18, 9, 20]. La longueur de t est de 6. L’idée de cet exercice est d’ajouter la valeur 1 à chaque élément du tableau t. A la fin de l’exécution du programme, le tableau t vaut [6, 2, 8, 19, 10, 21]. Pour cet exercice, l’idée est de parcourir le tableau et d’ajouter à chaque case la valeur 1. Les données du problème sont accessibles sur https://algotouch.irisa.fr/agt/

Corrigé

Define Plus1
From
   i = 0 ;
Until
   i >= t.length 
Loop
   t[i] = t[i] + 1 ;
   i = i + 1 ;
Terminate

End

Le programme complet est accessible sur https://algotouch.irisa.fr/agt/

Solution en vidéo

Exercice : inversion des valeurs

Sujet

Soit le tableau (collection) t contenant la suite des valeurs [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]. L’idée de cet exercice, est d’inverser l’ordre des éléments du tableau t. A la fin de l’exécution, la valeur de t est [100, 90, 80, 70, 60, 50, 40, 30, 20, 10]. Il est demandé que le programme réordonne les valeurs dans le tableau t sans utiliser un tableau intermédiaire. Les données du problème sont accessibles sur https://algotouch.irisa.fr/agt/

Corrigé

Define Inverse
From
   i = 0 ;
   j = t.length - 1 ;
Until
   i >= j 
Loop
   tmp = t[i] ;
   t[i] = t[j] ;
   t[j] = tmp ;
   i = i + 1 ;
   j = j - 1 ;
Terminate

End

Le programme complet est accessible sur https://algotouch.irisa.fr/agt/

Solution en vidéo

Retour sur la notion de collection ou tableau (array)

Besoin

Calcul de la somme de trois variables t0, t1, t2. Le programme AlgoTouch est le suivant:

Define Somme
Do
  s = 0 ;
  s = s + t0 ;
  s = s + t1 ;
  s = s + t2 ;
  Write "Valeur de s " s ;
  // ...
End

On observe:

une instruction initiale:
```
 s = 0;
```
une répétition d’instructions similaires:
```
 s = s + t? ;
```
La variable t? change à chaque ligne.
une instruction terminale:
```
 Write "La valeur de s" s ;
```

Il manque une structure de données permettant de stocker dans une même variable plusieurs valeurs repérées par un numéro (indice): 0, 1, 2, etc.

Accéder à AlgoTouch Le programme de cet exemple est disponible sur https://algotouch.irisa.fr/agt/.

Collection de données ou tableau

Une collection de données ou tableau est une variable contenant plusieurs valeurs. Par exemple, les trois variables t contenant trois valeurs 10, 5 et 7. Elles sont respectivement accessibles par t[0], t[1], t[2]. Une collection de données contient un nombre fini de valeurs, appelé sa longueur et accessible par t.length.

Le programme d’addition des valeurs d’un tableau devient:

Define Somme
Do
  s = 0 ;
  s = s + t[0] ;
  s = s + t[1] ;
  s = s + t[2] ;
  Write "Valeur de s " s ;
  // ...
End

Accès au programme Cet exemple est disponible sur https://algotouch.irisa.fr/agt/.

Comme précédemment, le code est divisé en trois parties:

une instruction initiale:
```
 s = 0;
```
une répétition d’instructions similaires:
```
 s = s + t[?] ;
```
L’indice de la variable t[?] change à chaque ligne.
une instruction terminale:
```
 Write "La valeur de s" s ;
```

Presqu'une boucle ! Le code produit est très similaire à celui d'une boucle. Il manque juste le moyen pour accéder aux différentes valeurs du tableau à chaque tour de boucle : un indice.

Indice

Un indice est une variable associée à un tableau. Elle permet d’accéder aux différents éléments d’un tableau en fonction de sa valeur. Par exemple, si i est l’indice associé au tableau t , quand i vaut 1, t[i] est équivalent à t[1].

Validité d'un indice Un indice d'un tableau t doit toujours être compris en 0 et t.length-1.

Utilisation de l’indice

Le programme peut maintenant utiliser une boucle pour parcourir le tableau élément par élément et effectuer la somme au fur et à mesure.

Corps de boucle

s = s + t[i] ;
i = i + 1 ;

Condition de sortie

i >= t.length

Initialisation

s = 0 ;
i = 0 ;

Terminaison

Write "Valeur de s " s ;

Données de cet exemple Accès sur https://algotouch.irisa.fr/agt/.

Code complet du programme:

Define Somme
From
  s = 0 ;
  i = 0 ;
  // ...
Until
  i >= t.length
  // ...
Loop
  s = s + t[i] ;
  i = i + 1 ;
  // ...
Terminate
  Write "Valeur de s " s ;
  // ...
End

Définition et syntaxe

Un tableau est un ensemble de valeurs de même type portant le même nom de variable et repérées par un indice (index en anglais). Un tableau doit être créé avec un type (entier ou caractère), un nom et un nombre de valeurs qu’il contient.

type t[n];

On accède aux valeurs du tableau par t[i] avec 0≤i<n. Un élément de tableau (nom + indice) peut être manipulé comme n’importe quelle variable. L’indice est soit une variable, soit une constante.

Exemple

t[0] = 0 ;
x = t[0] + 1 ;
t[0] = [1] ;
i = 5 ;
t[i] = 0 ;
x = t[i] ;
x = t.length ;

❮ Itérations

Macros ❯