Les Ensembles

> LeekScript

Un ensemble (set) est une collection de valeurs uniques et sans ordre. Il vaut mieux le voir comme un sac de valeurs distinctes que comme une liste : on ne lui demande pas « quel est le 3ᵉ élément ? », mais plutôt « est-ce que telle valeur est dedans ? ».

Deux propriétés le définissent :

Unicité — chaque valeur n'existe qu'en un seul exemplaire. Ajouter un doublon ne change rien.
Non trié — l'ordre des éléments n'est ni garanti, ni configurable. Deux exécutions peuvent les présenter différemment, et il n'existe pas de notion de « premier » ou de « dernier » élément.

C'est ce qui le distingue d'un tableau (Array), qui conserve l'ordre d'insertion, accepte les doublons et se manipule par indices.

---

Quand choisir un ensemble plutôt qu'un tableau ?

Posez-vous une seule question : « ai-je besoin de savoir rapidement si une valeur est présente, ou d'éviter les doublons ? »

Si oui → un ensemble. Le test d'appartenance ne coûte qu'une seule opération, quelle que soit la taille de l'ensemble, et le dédoublonnage est automatique.
Si vous avez besoin de l'ordre, d'indices, ou d'autoriser des répétitions → un tableau.

Ce coût constant est l'argument décisif : dans un tableau, vérifier la présence d'une valeur oblige à le parcourir, ce qui coûte autant d'opérations qu'il contient d'éléments. Dans un combat où les opérations sont limitées, l'ensemble fait toute la différence dès qu'on teste souvent l'appartenance.

Exemples typiques : mémoriser les cellules déjà visitées, garder la liste des ennemis repérés sans risquer de les compter deux fois, ou comparer deux zones du terrain.

---

Créer un ensemble

On peut écrire un ensemble en toutes lettres avec des chevrons ``, mais en pratique on part souvent d'un ensemble vide que l'on remplit au fil du programme.

L'opérateur .. permet de générer une plage de valeurs sans tout énumérer :

Comme un ensemble refuse les doublons, ceux-ci disparaissent dès la construction. L'ordre du résultat, lui, n'est pas garanti :

Typage

Un ensemble peut être typé selon son contenu :

| Type | Contenu | |-----------------|-------------------------------| | Set | uniquement des entiers | | Set | uniquement des nombres réels | | Set | n'importe quel type de valeur |

---

Remplir et vider un ensemble

setPut(set, element) → booléen ajoute une valeur. Sa valeur de retour est souvent plus utile que l'ajout lui-même : elle vaut true si l'élément était nouveau, false s'il existait déjà. C'est parfait pour détecter une première rencontre.

setRemove(set, element) → booléen retire une valeur et renvoie true si elle était présente, false sinon — pratique pour agir uniquement quand l'élément existait vraiment.

setClear(set) → set vide complètement l'ensemble, par exemple pour le réutiliser au tour suivant.

---

Interroger un ensemble

C'est ici que l'ensemble prend tout son sens.

Pour savoir si une valeur est présente, l'opérateur in est la forme la plus courte et la plus rapide : element in set renvoie un booléen et ne coûte qu'une seule opération, quelle que soit la taille de l'ensemble. La fonction setContains(set, element) fait exactement la même chose, au même coût, si vous préférez la notation fonction.

C'est précisément ce coût constant qui fait l'intérêt d'un ensemble : tester 10 in ennemis reste instantané, que l'ensemble contienne 3 ou 3000 éléments.

setSize(set) → entier donne le nombre d'éléments, et setIsEmpty(set) → booléen indique s'il est vide (plus lisible que setSize(s) == 0).

---

Combiner deux ensembles

Les ensembles permettent de raisonner sur des groupes de valeurs. Ces fonctions prennent deux ensembles et renvoient un nouvel ensemble (ou un booléen) sans modifier les originaux. C'est souvent beaucoup plus simple que d'écrire des boucles à la main.

Dans les exemples ci-dessous :

Union — setUnion(set1, set2) → set

Tout ce qui est dans l'un ou l'autre (A ∪ B). Idéal pour fusionner deux groupes, par exemple les cellules atteignables par deux chemins différents.

Intersection — setIntersection(set1, set2) → set

Ce qui est dans les deux à la fois (A ∩ B). Utile pour trouver le terrain commun : par exemple les cellules à la fois à portée de tir et sans obstacle.

Différence — setDifference(set1, set2) → set

Ce qui est dans set1 mais pas dans set2 (A \ B). Pensez à « toutes mes options, sauf les dangereuses ».

Différence symétrique — setDisjunction(set1, set2) → set

Ce qui appartient à exactement un des deux ensembles, jamais aux deux (A △ B) : ce qui les distingue l'un de l'autre.

Inclusion — setIsSubsetOf(set1, set2) → booléen

Vérifie que tous les éléments de set1 se trouvent dans set2. Par exemple : « ai-je déjà toutes les cellules nécessaires ? ».

---

Parcourir et convertir

Un ensemble se parcourt avec une boucle for ... in. Attention : l'ordre de parcours n'est pas garanti. N'écrivez donc pas de code qui suppose un ordre précis.

Si vous avez besoin d'un ordre, convertissez d'abord l'ensemble en tableau avec setToArray(set) → array, puis triez ce tableau.

---

Exemple complet

---

Aide-mémoire

| Élément | Retour | Rôle | |----------------------------|-----------|-----------------------------------------------| | x in s | booléen | Présence de x — coûte 1 opération | | setContains(s, x) | booléen | Présence de x (même coût que in) | | setPut(s, x) | booléen | Ajoute x ; true si nouveau | | setRemove(s, x) | booléen | Retire x ; true si présent | | setClear(s) | set | Vide l'ensemble | | setSize(s) | entier | Nombre d'éléments | | setIsEmpty(s) | booléen | true si l'ensemble est vide | | setToArray(s) | array | Convertit en tableau (ordre non garanti) | | setUnion(s1, s2) | set | A ∪ B | | setIntersection(s1, s2) | set | A ∩ B | | setDifference(s1, s2) | set | A \ B | | setDisjunction(s1, s2) | set | Différence symétrique A △ B | | setIsSubsetOf(s1, s2) | booléen | true si A ⊆ B |