LISP - Séquences

La séquence est un type de données abstrait dans LISP. Les vecteurs et les listes sont les deux sous-types concrets de ce type de données. Toutes les fonctionnalités définies sur le type de données séquence sont en fait appliquées sur tous les vecteurs et types de liste.

Dans cette section, nous aborderons les fonctions les plus couramment utilisées sur les séquences.

Avant de commencer sur différentes manières de manipuler des séquences (c'est-à-dire des vecteurs et des listes), examinons la liste de toutes les fonctions disponibles.

Créer une séquence

La fonction make-sequence vous permet de créer une séquence de n'importe quel type. La syntaxe de cette fonction est -

make-sequence sqtype sqsize &key :initial-element

Il crée une séquence de type sqtype et de longueur sqsize.

Vous pouvez éventuellement spécifier une valeur en utilisant l' argument: élément-initial , puis chacun des éléments sera initialisé à cette valeur.

Par exemple, créez un nouveau fichier de code source nommé main.lisp et tapez le code suivant dedans.

(write (make-sequence '(vector float) 
   10 
   :initial-element 1.0))

Lorsque vous exécutez le code, il renvoie le résultat suivant -

#(1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0)

Fonctions génériques sur les séquences

N ° Sr.	Description de la fonction
1	elt Il permet d'accéder à des éléments individuels via un index entier.
2	length Il renvoie la longueur d'une séquence.
3	subseq Il retourne une sous-séquence en extrayant la sous-séquence commençant à un index particulier et continuant jusqu'à un index de fin particulier ou à la fin de la séquence.
4	copy-seq Il renvoie une séquence contenant les mêmes éléments que son argument.
5	fill Il est utilisé pour définir plusieurs éléments d'une séquence sur une seule valeur.
6	replace Il prend deux séquences et la première séquence d'arguments est modifiée de manière destructive en y copiant des éléments successifs à partir de la deuxième séquence d'arguments.
sept	count Il prend un élément et une séquence et renvoie le nombre de fois où l'élément apparaît dans la séquence.
8	reverse Il renvoie une séquence contenant les mêmes éléments de l'argument mais dans l'ordre inverse.
9	nreverse Il renvoie la même séquence contenant les mêmes éléments que la séquence mais dans l'ordre inverse.
dix	concatenate Il crée une nouvelle séquence contenant la concaténation d'un nombre quelconque de séquences.
11	position Il prend un élément et une séquence et retourne l'index de l'élément dans la séquence ou nil.
12	find Il faut un élément et une séquence. Il trouve l'élément dans la séquence et le renvoie, s'il n'est pas trouvé, il renvoie nil.
13	sort Il prend une séquence et un prédicat à deux arguments et renvoie une version triée de la séquence.
14	merge Il prend deux séquences et un prédicat et renvoie une séquence produite en fusionnant les deux séquences, selon le prédicat.
15	map Il prend une fonction à n arguments et n séquences et renvoie une nouvelle séquence contenant le résultat de l'application de la fonction aux éléments suivants des séquences.
16	some Il prend un prédicat comme argument et itère sur la séquence d'arguments, et retourne la première valeur non NIL renvoyée par le prédicat ou renvoie false si le prédicat n'est jamais satisfait.
17	every Il prend un prédicat comme argument et itère sur la séquence d'arguments, il se termine, retournant false, dès que le prédicat échoue. Si le prédicat est toujours satisfait, il renvoie vrai.
18	notany Il prend un prédicat comme argument et itère sur la séquence d'arguments, et retourne false dès que le prédicat est satisfait ou vrai s'il ne l'est jamais.
19	notevery Il prend un prédicat comme argument et itère sur la séquence d'arguments, et retourne true dès que le prédicat échoue ou false si le prédicat est toujours satisfait.
20	reduce Il mappe sur une seule séquence, appliquant d'abord une fonction à deux arguments aux deux premiers éléments de la séquence, puis à la valeur renvoyée par la fonction et les éléments suivants de la séquence.
21	search Il recherche une séquence pour localiser un ou plusieurs éléments satisfaisant à un test.
22	remove Il prend un élément et une séquence et renvoie la séquence avec les instances d'élément supprimées.
23	delete Cela prend également un élément et une séquence et retourne une séquence du même type que la séquence d'arguments qui a les mêmes éléments à l'exception de l'élément.
24	substitute Il prend un nouvel élément, un élément existant et une séquence et renvoie une séquence avec des instances de l'élément existant remplacées par le nouvel élément.
25	nsubstitute Il prend un nouvel élément, un élément existant et une séquence et renvoie la même séquence avec des instances de l'élément existant remplacées par le nouvel élément.
26	mismatch Il prend deux séquences et renvoie l'index de la première paire d'éléments non concordants.

Arguments de mot-clé de fonction de séquence standard

Argument	Sens	Valeur par défaut
:tester	Il s'agit d'une fonction à deux arguments utilisée pour comparer l'élément (ou la valeur extraite par: fonction clé) à l'élément.	EQL
:clé	Fonction à un argument pour extraire la valeur de clé de l'élément de séquence réel. NIL signifie utiliser l'élément tel quel.	NÉANT
:début	Index de départ (inclus) de la sous-séquence.	0
:fin	Index de fin (exclusif) de la sous-séquence. NIL indique la fin de la séquence.	NÉANT
: à partir de la fin	Si vrai, la séquence sera parcourue dans l'ordre inverse, de la fin au début.	NÉANT
:compter	Numéro indiquant le nombre d'éléments à supprimer ou à remplacer ou NIL pour tout indiquer (REMOVE et SUBSTITUTE uniquement).	NÉANT

Nous venons de discuter de diverses fonctions et mots-clés qui sont utilisés comme arguments dans ces fonctions travaillant sur des séquences. Dans les sections suivantes, nous verrons comment utiliser ces fonctions à l'aide d'exemples.

Recherche de la longueur et de l'élément

le length renvoie la longueur d'une séquence et la elt La fonction vous permet d'accéder à des éléments individuels à l'aide d'un index entier.

Exemple

Créez un nouveau fichier de code source nommé main.lisp et tapez le code suivant dedans.

(setq x (vector 'a 'b 'c 'd 'e))
(write (length x))
(terpri)
(write (elt x 3))

Lorsque vous exécutez le code, il renvoie le résultat suivant -

5
D

Modifier des séquences

Certaines fonctions de séquence permettent d'itérer dans la séquence et d'effectuer certaines opérations telles que la recherche, la suppression, le comptage ou le filtrage d'éléments spécifiques sans écrire de boucles explicites.

L'exemple suivant illustre ceci -

Exemple 1

Créez un nouveau fichier de code source nommé main.lisp et tapez le code suivant dedans.

(write (count 7 '(1 5 6 7 8 9 2 7 3 4 5)))
(terpri)
(write (remove 5 '(1 5 6 7 8 9 2 7 3 4 5)))
(terpri)
(write (delete 5 '(1 5 6 7 8 9 2 7 3 4 5)))
(terpri)
(write (substitute 10 7 '(1 5 6 7 8 9 2 7 3 4 5)))
(terpri)
(write (find 7 '(1 5 6 7 8 9 2 7 3 4 5)))
(terpri)
(write (position 5 '(1 5 6 7 8 9 2 7 3 4 5)))

Lorsque vous exécutez le code, il renvoie le résultat suivant -

2
(1 6 7 8 9 2 7 3 4)
(1 6 7 8 9 2 7 3 4)
(1 5 6 10 8 9 2 10 3 4 5)
7
1

Exemple 2

Créez un nouveau fichier de code source nommé main.lisp et tapez le code suivant dedans.

(write (delete-if #'oddp '(1 5 6 7 8 9 2 7 3 4 5)))
(terpri)
(write (delete-if #'evenp '(1 5 6 7 8 9 2 7 3 4 5)))
(terpri)
(write (remove-if #'evenp '(1 5 6 7 8 9 2 7 3 4 5) :count 1 :from-end t))
(terpri)
(setq x (vector 'a 'b 'c 'd 'e 'f 'g))
(fill x 'p :start 1 :end 4)
(write x)

Lorsque vous exécutez le code, il renvoie le résultat suivant -

(6 8 2 4)
(1 5 7 9 7 3 5)
(1 5 6 7 8 9 2 7 3 5)
#(A P P P E F G)

Tri et fusion de séquences

Les fonctions de tri prennent une séquence et un prédicat à deux arguments et renvoient une version triée de la séquence.

Exemple 1

Créez un nouveau fichier de code source nommé main.lisp et tapez le code suivant dedans.

(write (sort '(2 4 7 3 9 1 5 4 6 3 8) #'<))
(terpri)
(write (sort '(2 4 7 3 9 1 5 4 6 3 8) #'>))
(terpri)

Lorsque vous exécutez le code, il renvoie le résultat suivant -

(1 2 3 3 4 4 5 6 7 8 9)
(9 8 7 6 5 4 4 3 3 2 1)

Exemple 2

Créez un nouveau fichier de code source nommé main.lisp et tapez le code suivant dedans.

(write (merge 'vector #(1 3 5) #(2 4 6) #'<))
(terpri)
(write (merge 'list #(1 3 5) #(2 4 6) #'<))
(terpri)

Lorsque vous exécutez le code, il renvoie le résultat suivant -

#(1 2 3 4 5 6)
(1 2 3 4 5 6)

Prédicats de séquence

Les fonctions every, some, notany et notevery sont appelées les prédicats de séquence.

Ces fonctions itèrent sur des séquences et testent le prédicat booléen.

Toutes ces fonctions prennent un prédicat comme premier argument et les arguments restants sont des séquences.

Exemple

Créez un nouveau fichier de code source nommé main.lisp et tapez le code suivant dedans.

(write (every #'evenp #(2 4 6 8 10)))
(terpri)
(write (some #'evenp #(2 4 6 8 10 13 14)))
(terpri)
(write (every #'evenp #(2 4 6 8 10 13 14)))
(terpri)
(write (notany #'evenp #(2 4 6 8 10)))
(terpri)
(write (notevery #'evenp #(2 4 6 8 10 13 14)))
(terpri)

Lorsque vous exécutez le code, il renvoie le résultat suivant -

T
T
NIL
NIL
T

Cartographie des séquences

Nous avons déjà discuté des fonctions de mappage. De même lemap fonction vous permet d'appliquer une fonction aux éléments suivants d'une ou plusieurs séquences.

le map function prend une fonction à n arguments et n séquences et renvoie une nouvelle séquence après avoir appliqué la fonction aux éléments suivants des séquences.

Exemple

Créez un nouveau fichier de code source nommé main.lisp et tapez le code suivant dedans.

(write (map 'vector #'* #(2 3 4 5) #(3 5 4 8)))

Lorsque vous exécutez le code, il renvoie le résultat suivant -

#(6 15 16 40)