LISP - Sekwencje

Sekwencja to abstrakcyjny typ danych w LISP. Wektory i listy to dwa konkretne podtypy tego typu danych. Wszystkie funkcje zdefiniowane w typie danych sekwencyjnych są faktycznie stosowane na wszystkich wektorach i typach list.

W tej sekcji omówimy najczęściej używane funkcje na sekwencjach.

Zanim zaczniemy od różnych sposobów manipulowania sekwencjami (tj. Wektorami i listami), spójrzmy na listę wszystkich dostępnych funkcji.

Tworzenie sekwencji

Funkcja make-sequence umożliwia tworzenie sekwencji dowolnego typu. Składnia tej funkcji to -

make-sequence sqtype sqsize &key :initial-element

Tworzy sekwencję typu sqtype i długości sqsize.

Możesz opcjonalnie określić jakąś wartość używając argumentu : initial-element , wtedy każdy z elementów zostanie zainicjowany tą wartością.

Na przykład Utwórz nowy plik kodu źródłowego o nazwie main.lisp i wpisz w nim następujący kod.

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

Po wykonaniu kodu zwraca następujący wynik -

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

Funkcje ogólne na sekwencjach

Sr.No. Opis funkcji
1

elt

Umożliwia dostęp do poszczególnych elementów poprzez indeks całkowity.

2

length

Zwraca długość sekwencji.

3

subseq

Zwraca podsekwencję, wyodrębniając podsekwencję rozpoczynającą się od określonego indeksu i kontynuując do określonego indeksu końcowego lub końca sekwencji.

4

copy-seq

Zwraca sekwencję zawierającą te same elementy, co jej argument.

5

fill

Służy do ustawiania wielu elementów sekwencji na jedną wartość.

6

replace

Pobiera dwie sekwencje, a pierwsza sekwencja argumentów jest destruktywnie modyfikowana przez kopiowanie do niej kolejnych elementów z drugiej sekwencji argumentów.

7

count

Pobiera element i sekwencję i zwraca liczbę wystąpień elementu w sekwencji.

8

reverse

Zwraca sekwencję zawierającą te same elementy argumentu, ale w odwrotnej kolejności.

9

nreverse

Zwraca tę samą sekwencję zawierającą te same elementy, co sekwencja, ale w odwrotnej kolejności.

10

concatenate

Tworzy nową sekwencję zawierającą konkatenację dowolnej liczby sekwencji.

11

position

Pobiera element i sekwencję i zwraca indeks elementu w sekwencji lub nil.

12

find

Potrzeba przedmiotu i sekwencji. Znajduje element w sekwencji i zwraca go, jeśli nie zostanie znaleziony, zwraca nil.

13

sort

Pobiera sekwencję i predykat dwuargumentowy i zwraca posortowaną wersję sekwencji.

14

merge

Pobiera dwie sekwencje i predykat i zwraca sekwencję utworzoną przez połączenie dwóch sekwencji, zgodnie z predykatem.

15

map

Pobiera funkcję n-argumentową in sekwencji i zwraca nową sekwencję zawierającą wynik zastosowania funkcji do kolejnych elementów sekwencji.

16

some

Pobiera predykat jako argument i wykonuje iterację po sekwencji argumentów i zwraca pierwszą wartość inną niż NIL zwrócona przez predykat lub zwraca fałsz, jeśli predykat nigdy nie jest spełniony.

17

every

Przyjmuje predykat jako argument i iteruje po sekwencji argumentów, kończy, zwracając fałsz, gdy tylko predykat zawiedzie. Jeśli predykat jest zawsze spełniony, zwraca prawdę.

18

notany

Przyjmuje predykat jako argument i iteruje sekwencję argumentów i zwraca fałsz, gdy tylko predykat zostanie spełniony lub prawda, jeśli nigdy nie jest.

19

notevery

Przyjmuje predykat jako argument i wykonuje iterację po sekwencji argumentów i zwraca prawdę, gdy tylko predykat zawiedzie lub fałsz, jeśli predykat jest zawsze spełniony.

20

reduce

Odwzorowuje pojedynczą sekwencję, stosując najpierw funkcję dwuargumentową do pierwszych dwóch elementów sekwencji, a następnie do wartości zwracanej przez funkcję i kolejne elementy sekwencji.

21

search

Przeszukuje sekwencję, aby zlokalizować jeden lub więcej elementów spełniających jakiś test.

22

remove

Pobiera element i sekwencję i zwraca sekwencję z usuniętymi wystąpieniami elementu.

23

delete

Pobiera również element i sekwencję i zwraca sekwencję tego samego rodzaju, co sekwencja argumentów, która ma te same elementy oprócz elementu.

24

substitute

Pobiera nowy element, istniejący element i sekwencję oraz zwraca sekwencję z wystąpieniami istniejącego elementu zastąpionymi nowym elementem.

25

nsubstitute

Pobiera nowy element, istniejący element i sekwencję i zwraca tę samą sekwencję z wystąpieniami istniejącego elementu zastąpionymi nowym elementem.

26

mismatch

Pobiera dwie sekwencje i zwraca indeks pierwszej pary niedopasowanych elementów.

Argumenty słów kluczowych funkcji sekwencji standardowej

Argument Znaczenie Domyślna wartość
:test Jest to dwuargumentowa funkcja używana do porównywania elementu (lub wartości wyodrębnionej przez: funkcja klucza) z elementem. EQL
:klucz Funkcja jednoargumentowa do wyodrębniania wartości klucza z rzeczywistego elementu sekwencji. NIL oznacza użycie elementu takiego, jaki jest. ZERO
:początek Początkowy indeks (włącznie) podciągu. 0
:koniec Indeks końcowy (wyłączny) podciągu. NIL oznacza koniec sekwencji. ZERO
: od końca Jeśli prawda, sekwencja będzie wykonywana w odwrotnej kolejności, od końca do początku. ZERO
:liczyć Liczba wskazująca liczbę elementów do usunięcia lub zastąpienia lub NIL, aby wskazać wszystkie (tylko USUŃ i PODSTAW). ZERO

Omówiliśmy właśnie różne funkcje i słowa kluczowe, które są używane jako argumenty w tych funkcjach pracujących na sekwencjach. W następnych sekcjach zobaczymy, jak korzystać z tych funkcji na przykładach.

Znajdowanie długości i elementu

Plik length funkcja zwraca długość sekwencji, a funkcja elt Funkcja umożliwia dostęp do poszczególnych elementów za pomocą indeksu liczb całkowitych.

Przykład

Utwórz nowy plik kodu źródłowego o nazwie main.lisp i wpisz w nim następujący kod.

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

Po wykonaniu kodu zwraca następujący wynik -

5
D

Modyfikowanie sekwencji

Niektóre funkcje sekwencyjne pozwalają na iterowanie sekwencji i wykonywanie pewnych operacji, takich jak wyszukiwanie, usuwanie, liczenie lub filtrowanie określonych elementów bez pisania jawnych pętli.

Poniższy przykład demonstruje to -

Przykład 1

Utwórz nowy plik kodu źródłowego o nazwie main.lisp i wpisz w nim następujący kod.

(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)))

Po wykonaniu kodu zwraca następujący wynik -

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

Przykład 2

Utwórz nowy plik kodu źródłowego o nazwie main.lisp i wpisz w nim następujący kod.

(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)

Po wykonaniu kodu zwraca następujący wynik -

(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)

Sortowanie i łączenie sekwencji

Funkcje sortujące pobierają sekwencję i predykat dwuargumentowy i zwracają posortowaną wersję sekwencji.

Przykład 1

Utwórz nowy plik kodu źródłowego o nazwie main.lisp i wpisz w nim następujący kod.

(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)

Po wykonaniu kodu zwraca następujący wynik -

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

Przykład 2

Utwórz nowy plik kodu źródłowego o nazwie main.lisp i wpisz w nim następujący kod.

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

Po wykonaniu kodu zwraca następujący wynik -

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

Predykaty sekwencji

Funkcje every, some, notany i notevery nazywane są predykatami sekwencji.

Te funkcje wykonują iterację po sekwencjach i testują predykat Boole'a.

Wszystkie te funkcje przyjmują predykat jako pierwszy argument, a pozostałe argumenty to sekwencje.

Przykład

Utwórz nowy plik kodu źródłowego o nazwie main.lisp i wpisz w nim następujący kod.

(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)

Po wykonaniu kodu zwraca następujący wynik -

T
T
NIL
NIL
T

Mapping Sequences

Omówiliśmy już funkcje mapowania. Podobniemap function umożliwia zastosowanie funkcji do kolejnych elementów jednej lub więcej sekwencji.

Plik map funkcja przyjmuje funkcję n-argumentową in sekwencji i zwraca nową sekwencję po zastosowaniu funkcji do kolejnych elementów sekwencji.

Przykład

Utwórz nowy plik kodu źródłowego o nazwie main.lisp i wpisz w nim następujący kod.

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

Po wykonaniu kodu zwraca następujący wynik -

#(6 15 16 40)