Л.Р._Ш.И_2-6 / L5_LIST
.docAIS_LZ_LIST
ЛАБОРАТОРНАЯ РАБОТА
Обработка списков на Прологе
Цель работы:
Разработка и отладка программ обработки списков. Приобретение и закрепление практических навыков составления программ на языке Prolog.
Подготовка к работе:
Изучить правила описания списков и типовые приемы обработки списков.
Порядок выполнения работы:
1. Загрузить компилятор языка логического программирования PROLOG.
2. Отладить программу печати списка.
domains
list = integer*
predicates
print(list)
clauses
print([]). если список пуст, то ничего не делать.
print(H | T):- write(H), напечатай значение головы
nl, перейди на следующую строку
print(T). напечатай хвост списка
Переставить два последних оператора программы. Что получиться?
3. Отладить программу вычисления длины списка двумя способами – общей и хвостовой рекурсией.
Определение длины списка (общая рекурсия)
длина(списка) = Длина(хвоста списка) + 1:
длина([]) = 0.
domains
list = integer*
predicates
len(list, integer)
clauses
len([]), 0). длина пустого списка
len([_|Tail], N):- len(Tail, N1), вычисление длины хвоста
N=N1+1. вычисление общей длины списка
Определение длины списка методом хвостовой рекурсии.
Программа получается более экономичной, если рекурсивный вызов является последним предикатом правила. Для преобразования общей рекурсии в хвостовую введем вспомогательный предикат, содержащий дополнительную переменную, в которой будет накапливаться длина списка при каждом рекурсивном вызове. Как только список станет пустым, в переменной окажется значение длины списка.
domains
list = integer*
predicates
len(list, integer)
lenv(list, integer, integer)
clauses
len(L, N):- lenv(L,N,0),!. третий аргумент – начальная длина списка равная нулю.
lenv([], N, N). когда список станет пустым, накопленное значение NT копируется в переменную N
lenv([_|Tail], N,NT):- NT1=NT+1,
lenv(Tail, N, NT1). рекурсивный вызов.
4. Составить и отладить программу (самостоятельно) вычисления суммы элементов списка методом общей и хвостовой рекурсии.
5. Отладить программу определения принадлежности элемента списку.
Введем предикат member(X, L). Рассмотрим два случая.
Первый случай – элемент X является первым элементом списка. Тогда выделив голову списка и сравнив ее с элементом X, при совпадении даем положительный ответ.
Второй случай - элемент X не является первым элементом списка. Тогда решаем задачу определения принадлежности элемента для хвоста списка. Текст программы приведен ниже.
domains
list = integer*
predicates
member(integer, list)
clauses
member(X, [X | _ ]).
member(X, [ _ | T ]) :- member(X, T).
Каков результат работы программы, если задать цель в виде:
member(X, [1, 2, 5]) и member(2, [1, 3, N]) ?
6. Отладить программу удаления элемента X из списка L.
Если Х окажется первым элементом списка, то задача решена. Ее решением является хвост списка. В противном случае надо удалить элемент Х из хвоста и присоединить к полученному списку голову.
domains
list = integer*
predicates
delete(integer, list, list)
clauses
delete(X, [X | T ], T).
delete(X, [ H | T ],[H | L]) :- delete(X, T ,L).
Какой смысл имеют цели:
delete(Z, [1, 2, 5], [1, 5]) delete(4, U, [1, 5])?
Если в списке содержится несколько одинаковых элементов, подлежащих удалению, то данный вариант программы удаляет только первый встретившийся элемент. Модифицируйте программу так, чтобы она удаляла все одинаковые элементы.
7. Отладить программу слияния и объединения списков.
Слияние списков merge(L1, L2, L)
domains
list = integer*
predicates
merge(list, list, list)
clauses
merge([], L2, L2).
merge([H | T], L2, [H | L3]) :- merge(T, L2, L3).
Если первый список пустой, то результат – это второй список. В противном случае необходимо слить хвост первого списка со вторым списком и добавить к полученному списку голову первого списка.
Объединение списков (в теоретико–множественном смысле). Основное отличие заключается в том, что элементы списка не должны повторяться, как это подобает множествам. Поэтому, если голова первого множества содержится во втором множестве, то ее не надо добавлять к полученному списку.
domains
list = integer*
predicates
union(list, list, list)
clauses
union([], L2, L2).
union([H | T], L2, L3) :-
member(H, L2), проверяем, входит ли голова H во второй список L2
union(T, L2, L3),!.
union([H | T], L2, [H | L3]) :-
union(T, L2, L3).
-
Индивидуальные задания. В таблице приведены 40 вариантов задач, разбитых на 6 групп. Необходимо решить по одной задаче из 5 выбранных групп. Номер варианта в каждой группе определяется по формуле: N= (ZZ mod G) +1, где ZZ – две последние цифры номера студенческой зачетки, G – количество вариантов в группе.
Содержание отчета
Отчет содержит название и цель работы, тексты программ и результаты тестирования.
Контрольные вопросы
1. Как компилятор распознает списки (константы и переменные)?
2. Каким знаком обозначается операция выделения головы списка, хвоста списка?
3. Как обозначается пустой список?
4. Из каких частей состоит любое рекурсивное правило?
5. Когда заканчивается рекурсивный вызов правил?
Варианты заданий
|
№ |
Балл |
Выполняемая операция |
Предикат |
|
|
|
1 группа Теоретико-множественные операции над списками |
|
|
1 |
18 |
Объединение двух упорядоченных по возрастанию списков |
union(L1, L2, L3) |
|
2 |
18 |
Объединение двух упорядоченных по убыванию списков |
union(L1, L2, L3) |
|
3 |
15 |
Пересечение двух неупорядоченных списков |
cross(L1, L2, L3) |
|
4 |
18 |
Пересечение двух упорядоченных по убыванию списков |
cross(L1, L2, L3) |
|
5 |
18 |
Пересечение двух упорядоченных по возрастанию списков |
cross(L1, L2, L3) |
|
6 |
15 |
Вычитание двух неупорядоченных списков |
diflist(L1, L2, L3) |
|
7 |
18 |
Вычитание двух упорядоченных по убыванию списков |
diflist(L1, L2, L3) |
|
8 |
18 |
Вычитание двух упорядоченных по возрастанию списков |
diflist(L1, L2, L3) |
|
|
|
2 группа Вставка элемента в список |
|
|
1 |
10 |
Вставка элемента X в упорядоченный по возрастанию список |
insert(X, L1, L2) |
|
2 |
10 |
Вставка элемента X в упорядоченный по убыванию список |
insert(X, L1, L2) |
|
3 |
10 |
Вставка элемента X на N-тое место в неупорядоченном списке |
insert(X, N, L1, L2) |
|
4 |
12 |
Вставка элемента X в список перед элементом Y списка |
insert(X, Y, L1, L2) |
|
5 |
12 |
Вставка элемента X в список после элемента Y списка |
insert(X, Y, L1, L2) |
|
6 |
10 |
Вставка элемента X в список вместо элемента Y списка |
insert(X, Y, L1, L2) |
|
7 |
5 |
Выделение N-того элемента из списка |
member(N, L, X) |
|
|
|
3 группа Удаление элементов из списка |
|
|
1 |
5 |
Удаление N-того элемента из списка |
del(N, L1, L2) |
|
2 |
12 |
Удаление последнего элемента списка |
del(L1, L2) |
|
3 |
15 |
Удалить из списка элементы с четными номерами |
del(L1, L2) |
|
4 |
15 |
Удалить из списка отрицательные элементы |
del(L1, L2) |
|
5 |
15 |
Удалить из списка четные (N mod 2 = 0) элементы |
del(L1, L2) |
|
|
|
4 группа Слияние и разделение списка |
|
|
1 |
10 |
Слияние двух упорядоченных по возрастанию списков |
append(L1, L2, L3) |
|
2 |
10 |
Слияние двух упорядоченных по убыванию списков |
append(L1, L2, L3) |
|
3 |
10 |
Разделить список на два списка, отличающихся по длине не более чем одним элементом |
Split(L1, L2, L3) |
|
4 |
12 |
Разделение списка L1 на два списка по компаратору К: L2 содержит числа меньше чем К, L3 - больше чем К |
Split(K, L1, L2, L3) |
|
5 |
15 |
Разделение списка L1 на два списка: L2 содержит четные числа, L3 - нечетные |
Split(L1, L2, L3) |
|
6 |
14 |
Разделение списка L1 на два списка. L2 содержит положительные числа, L3 - отрицательные |
Split(L1, L2, L3) |
|
7 |
18 |
Разделение списка L1 на два списка: L2 содержит числа меньше чем первый элемент списка, L3 - большие чем первый элемент списка |
Split(L1, L2, L3) |
|
|
|
5 группа Вычисление характеристик списка |
|
|
1 |
8 |
Вычисление количества четных N1 и нечетных чисел - N2 в списке L |
count(L, N1, N2) |
|
2 |
6 |
Вычисление количества положительных - N1 и отрицательных чисел - N2 в списке L |
count(L, N1, N2) |
|
3 |
8 |
Вычисление суммы четных – S1 и нечетных чисел - S2 в списке L |
sum(L, N1, N2) |
|
4 |
6 |
Вычисление суммы положительных – S1 и отрицательных чисел - S2 в списке L |
sum(L, N1, N2) |
|
5 |
5 |
Вычисление порядкового номера N элемента X в списке L |
number(X, L, N) |
|
6 |
12 |
Является ли список L1 подсписком списка L2 |
sublist(L1, L2) |
|
7 |
14 |
Нахождение максимального элемента списка методом деления списка пополам. В каждой половинке найти максимум и сравнить их. |
max(L, X_max) |
|
8 |
10 |
Нахождение максимального элемента списка путем нахождения его в хвосте и сравнения с головой списка |
max(L, X_max) |
|
|
|
6 группа (дополнительная) Сортировка списка |
|
|
1 |
15 |
Сортировка методом простого включения (отсортировать хвост списка и вставить голову в нужное место) |
sort(L1, L2) |
|
2 |
20 |
Сортировка методом простого выбора (найти максимальный элемент списка и формировать отсортированный список восходящей рекурсией) |
sort(L1, L2) |
|
3 |
20 |
Сортировка методом простого обмена (пузырька) |
sort(L1, L2) |
|
4 |
25 |
Быстрая сортировка списка (разделить список на два подсписка: элементы первого подсписка меньше, в второго – больше первого элемента исходного списка; подсписки отсортировать и соединить) |
sort(L1, L2) |
|
5 |
12 |
Инверсия списка (расположение элементов списка в обратном порядке) |
invers(L1, L2) |
Справочный материал
Список это множество элементов одного типа (одного домена). Списки принято записывать в виде последовательности элементов, разделенных знаком запятая и заключенных в квадратные скобки:
[1,3,5], [a,b,e,f], [jem,apple,jin]. Список может содержать произвольное количество элементов, и их количество может изменяться в процессе работы программы. Поэтому списки относятся к динамическим структурам. Частными случаями списка являются список, состоящий из одного элемента - [х] и пустой список - [].
Для списков базовыми операциями являются:
- выделение головы списка car([1,3,5])=1,
- выделение хвоста списка cdr([1,3,5])=[3,5],
- добавление элемента в голову списка cons(1, [3,5])=[1,3,5].
Эти три операции подчиняются следующей аксиоме:
cons(car(L), cdr(L))=L
В языке Prolog описание списка осуществляется в секции domains. Признаком списка является наличие символа * после описания типа элемента.
Примеры
domains
list=integer* список целых чисел [3,5]
l_char=char* список символов [a, f, h, d]
l_col=color* список красок [red, green, yellow]
color=symbol
Все три базовые операции со списками в языке Prolog обозначаются одним символом – вертикальная черта ( | ): L=[Head | Tail].
В зависимости от ситуации, программы сопоставления и унификации самостоятельно выполняют операции разделения списка на голову Head и хвост Tail или добавления элемента Head к списку Tail.
Так как списки являются рекурсивными структурами, то для их обработки удобно использовать рекурсивные алгоритмы. Они получаются простыми и наглядными и состоят из двух ветвей:
- что делать с пустым списком?
- что делать со списком, у которого есть голова и хвост?