Главная / Программирование /
Функциональное программирование / Тест 11
Функциональное программирование - тест 11
Упражнение 1:
Номер 1
Как можно отделить голову и хвост списка?
Ответ:
 (1) с помощью сопоставления с образцом let
 
 (2) с помощью сопоставления с образцом match
 
 (3) с помощью функций hd
и tl
 
 (4) с помощью конструктора списков cons
 
Номер 2
Какой будет результат выполнения let x::y = [1;2;3;4]
?
Ответ:
 (1) Ошибка 
 (2) x=[1;2;3;4], y=[]
 
 (3) x=1, y=2
 
 (4) x=1, y=[2;3;4]
 
 (5) x=[1;2;3], y=4
 
Номер 3
Какой будет результат сопоставления let x::y::z = [1;2]
?
Ответ:
 (1) ошибка 
 (2) x=1, y=2, z=null
 
 (3) x=1, y=2, z=[]
 
 (4) x=[], y=1, z=2
 
 (5) x=null, y=1,z=2
 
Упражнение 2:
Номер 1
C помощью какой функции можно эффективно посчитать сумму элементов целочисленного списка?
Ответ:
 (1) iter
 
 (2) iteri
 
 (3) fold
 
 (4) Map
 
Номер 2
С помощью какой функции можно удалить из списка все элементы, стоящие на четных позициях?
Ответ:
 (1) iter
 
 (2) map
 
 (3) filter
 
 (4) ни одна из перечисленных 
Номер 3
Какая функция может быть использована для удаления из списка всех элементов, делящихся на 3?
Ответ:
 (1) fold
 
 (2) filter
 
 (3) map
 
 (4) ни одна из перечисленных 
Упражнение 3:
Номер 1
Какой тип имеет функция map
?
Ответ:
 (1) (‘a→’b) → ‘a list → ‘b list
 
 (2) (‘a → ‘a) → ‘a list → ‘a list
 
 (3) ‘a → ‘a → ‘a list → ‘a list
 
 (4) (‘a → bool) → ‘a list → ‘a list
 
Номер 2
Какой тип имеет функция filter
?
Ответ:
 (1) (‘a→’b) → ‘a list → ‘b list
 
 (2) ‘a → ‘b → ‘a list → ‘b list
 
 (3) ‘a → bool → ‘a list → bool list
 
 (4) (‘a → bool) → ‘a list → ‘a list
 
Номер 3
Какой тип имеет функция fold_left
?
Ответ:
 (1) (‘a → ‘a → ‘a) → ‘a → ‘a list → ‘a
 
 (2) (‘b → ‘a → ‘b) → b’ → ‘a list → ‘b
 
 (3) (‘a → ‘a) → ‘a → ‘a list → ‘a
 
 (4) ‘a → ‘a → ‘a → ‘a list
 
Упражнение 4:
Номер 1
Какой функции эквивалентна запись [ for x in L → x*2 ]
?
Ответ:
 (1) filter
 
 (2) map
 
 (3) reduce
 
 (4) fold
 
Номер 2
Какой список будет порожден конструкцией [1..2..10]
?
Ответ:
 (1) конструкция недопустима 
 (2) [1;2;3;4;5;6;7;8;9;10]
 
 (3) [1;3;5;7;9]
 
 (4) [2;4;6;8;10]
 
Номер 3
Какими способами можно создать список четных чисел от 1 до 10?
Ответ:
 (1) [2..2..10]
 
 (2) [ for x in 1..10 when x%2=0 → x ]
 
 (3) [ for x in 1..10 step 2 do x ]
 
 (4) [ 2..10 step 2]
 
Упражнение 5:
Номер 1
Какие условия являются необходимыми для хвостовой рекурсии?
Ответ:
 (1) линейная рекурсия 
 (2) косвенная рекурсия 
 (3) рекурсивный вызов является последним в теле функции 
Номер 2
Почему следует стараться использовать хвостовую рекурсию?
Ответ:
 (1) она всегда может быть сведена компилятором к итерации 
 (2) определения с хвостовой рекурсией получаются проще 
 (3) хвостовая рекурсия – единственный вид рекурсии, поддерживаемый F# 
 (4) при хвостовой рекурсии выделяемая для параметров память выделяется в регистрах 
Номер 3
При вычислении длины списка n с помощью хвостовой рекурсии, сколько памяти выделяется в стеке?
Ответ:
 (1) O(1)
 
 (2) O(n)
 
 (3) O(log n)
 
 (4) O(n2)
 
Упражнение 6:
Номер 1
В каком представлении матриц проще реализовать операцию транспонирования?
Ответ:
 (1) в виде списка списков 
 (2) в порядковом представлении 
 (3) сложность реализации при списковом и порядковом представлении примерно одинакова 
Номер 2
В каком представлении эффективнее хранить разреженные матрицы?
Ответ:
 (1) в виде списка списков 
 (2) в порядковом представлении 
 (3) в виде двумерного массива 
 (4) в виде массива переменной длины 
Номер 3
Разреженная матрица размерности nXn
с m
ненулевыми элементами представляется в виде функции int*int → float
. Какова будет сложность операции умножения всех элементов матрицы на 2?
Ответ:
 (1) O(1)
 
 (2) O(n)
 
 (3) O(m)
 
 (4) O(nXm)
 
Упражнение 7:
Номер 1
Какова сложность добавления элемента на первое место списка длины n
?
Ответ:
 (1) O(1)
 
 (2) O(n)
 
 (3) O(log n)
 
 (4) O(n2)
 
Номер 2
Какова сложность добавления элемента в конец списка длины n
?
Ответ:
 (1) O(1)
 
 (2) O(n)
 
 (3) O(log n)
 
 (4) O(n2)
 
Номер 3
Какова сложность проверки вхождения элемента в список длины n
?
Ответ:
 (1) O(1)
 
 (2) O(n)
 
 (3) O(log n)
 
 (4) O(n2)