LISP - Последовательности

Последовательность - это абстрактный тип данных в LISP. Векторы и списки - это два конкретных подтипа этого типа данных. Все функции, определенные для типа данных последовательности, фактически применяются ко всем векторам и типам списков.

В этом разделе мы обсудим наиболее часто используемые функции для последовательностей.

Прежде чем приступить к различным способам управления последовательностями (т. Е. Векторами и списками), давайте взглянем на список всех доступных функций.

Создание последовательности

Функция make-sequence позволяет создавать последовательность любого типа. Синтаксис этой функции -

make-sequence sqtype sqsize &key :initial-element

Он создает последовательность типа sqtype и длины sqsize.

При желании вы можете указать какое-то значение с помощью аргумента : initial-element , тогда каждый из элементов будет инициализирован этим значением.

Например, создайте новый файл исходного кода с именем main.lisp и введите в него следующий код.

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

Когда вы выполняете код, он возвращает следующий результат -

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

Общие функции на последовательностях

Sr. No. Описание функции
1

elt

Он позволяет получить доступ к отдельным элементам через целочисленный индекс.

2

length

Возвращает длину последовательности.

3

subseq

Он возвращает подпоследовательность, извлекая подпоследовательность, начиная с определенного индекса и продолжая до определенного конечного индекса или конца последовательности.

4

copy-seq

Он возвращает последовательность, содержащую те же элементы, что и его аргумент.

5

fill

Он используется для установки одного значения для нескольких элементов последовательности.

6

replace

Он принимает две последовательности, и первая последовательность аргументов деструктивно модифицируется путем копирования в нее последовательных элементов из второй последовательности аргументов.

7

count

Он принимает элемент и последовательность и возвращает количество раз, когда элемент встречается в последовательности.

8

reverse

Он возвращает последовательность, содержащую те же элементы аргумента, но в обратном порядке.

9

nreverse

Он возвращает ту же последовательность, содержащую те же элементы, что и последовательность, но в обратном порядке.

10

concatenate

Он создает новую последовательность, содержащую конкатенацию любого количества последовательностей.

11

position

Он принимает элемент и последовательность и возвращает индекс элемента в последовательности или ноль.

12

find

Требуется элемент и последовательность. Он находит элемент в последовательности и возвращает его, если не найден, возвращает ноль.

13

sort

Он принимает последовательность и предикат с двумя аргументами и возвращает отсортированную версию последовательности.

14

merge

Он принимает две последовательности и предикат и возвращает последовательность, полученную путем слияния двух последовательностей в соответствии с предикатом.

15

map

Он принимает функцию с n аргументами и n последовательностей и возвращает новую последовательность, содержащую результат применения функции к последующим элементам последовательностей.

16

some

Он принимает предикат в качестве аргумента и выполняет итерацию по последовательности аргументов и возвращает первое значение, отличное от NIL, возвращаемое предикатом, или возвращает false, если предикат никогда не удовлетворяется.

17

every

Он принимает предикат в качестве аргумента и перебирает последовательность аргументов, он завершается, возвращая false, как только предикат терпит неудачу. Если предикат всегда выполняется, он возвращает истину.

18

notany

Он принимает предикат в качестве аргумента и выполняет итерацию по последовательности аргументов и возвращает false, как только предикат удовлетворяется, или true, если это не так.

19

notevery

Он принимает предикат в качестве аргумента и выполняет итерацию по последовательности аргументов и возвращает истину, если предикат не срабатывает, или ложь, если предикат всегда выполняется.

20

reduce

Он отображает одну последовательность, применяя функцию с двумя аргументами сначала к первым двум элементам последовательности, а затем к значению, возвращаемому функцией, и последующим элементам последовательности.

21 год

search

Он ищет последовательность, чтобы найти один или несколько элементов, удовлетворяющих некоторому тесту.

22

remove

Он принимает элемент и последовательность и возвращает последовательность с удаленными экземплярами элемента.

23

delete

Он также принимает элемент и последовательность и возвращает последовательность того же типа, что и последовательность аргументов, которая имеет те же элементы, за исключением элемента.

24

substitute

Он принимает новый элемент, существующий элемент и последовательность и возвращает последовательность, в которой экземпляры существующего элемента заменены новым элементом.

25

nsubstitute

Он берет новый элемент, существующий элемент и последовательность и возвращает ту же последовательность с экземплярами существующего элемента, замененными новым элементом.

26

mismatch

Он принимает две последовательности и возвращает индекс первой пары несовпадающих элементов.

Аргументы ключевого слова функции стандартной последовательности

Аргумент Имея в виду Значение по умолчанию
:контрольная работа Это функция с двумя аргументами, используемая для сравнения элемента (или значения, извлеченного функцией: key) с элементом. EQL
: ключ Функция с одним аргументом для извлечения ключевого значения из фактического элемента последовательности. NIL означает использование элемента как есть. Ноль
:Начало Начальный индекс (включительно) подпоследовательности. 0
:конец Конечный индекс (исключая) подпоследовательности. NIL означает конец последовательности. Ноль
: от конца Если true, последовательность будет проходить в обратном порядке, от конца до начала. Ноль
: count Число, указывающее количество элементов, которые нужно удалить или заменить, или NIL, чтобы указать все (только REMOVE и SUBSTITUTE). Ноль

Мы только что обсудили различные функции и ключевые слова, которые используются в качестве аргументов в этих функциях, работающих с последовательностями. В следующих разделах мы увидим, как использовать эти функции на примерах.

Поиск длины и элемента

В length функция возвращает длину последовательности, а функция elt Функция позволяет получить доступ к отдельным элементам с помощью целочисленного индекса.

пример

Создайте новый файл исходного кода с именем main.lisp и введите в него следующий код.

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

Когда вы выполняете код, он возвращает следующий результат -

5
D

Модификация последовательностей

Некоторые функции последовательности позволяют перебирать последовательность и выполнять некоторые операции, такие как поиск, удаление, подсчет или фильтрация определенных элементов, без написания явных циклов.

Следующий пример демонстрирует это -

Пример 1

Создайте новый файл исходного кода с именем main.lisp и введите в него следующий код.

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

Когда вы выполняете код, он возвращает следующий результат -

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

Пример 2

Создайте новый файл исходного кода с именем main.lisp и введите в него следующий код.

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

Когда вы выполняете код, он возвращает следующий результат -

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

Сортировка и объединение последовательностей

Функции сортировки принимают последовательность и предикат с двумя аргументами и возвращают отсортированную версию последовательности.

Пример 1

Создайте новый файл исходного кода с именем main.lisp и введите в него следующий код.

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

Когда вы выполняете код, он возвращает следующий результат -

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

Пример 2

Создайте новый файл исходного кода с именем main.lisp и введите в него следующий код.

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

Когда вы выполняете код, он возвращает следующий результат -

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

Предикаты последовательности

Функции every, some, notany и notevery называются предикатами последовательности.

Эти функции перебирают последовательности и проверяют логический предикат.

Все эти функции принимают предикат в качестве первого аргумента, а остальные аргументы представляют собой последовательности.

пример

Создайте новый файл исходного кода с именем main.lisp и введите в него следующий код.

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

Когда вы выполняете код, он возвращает следующий результат -

T
T
NIL
NIL
T

Отображение последовательностей

Мы уже обсуждали функции отображения. Аналогичным образомmap Функция позволяет вам применять функцию к последующим элементам одной или нескольких последовательностей.

В map Функция принимает функцию с n аргументами и n последовательностей и возвращает новую последовательность после применения функции к последующим элементам последовательностей.

пример

Создайте новый файл исходного кода с именем main.lisp и введите в него следующий код.

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

Когда вы выполняете код, он возвращает следующий результат -

#(6 15 16 40)