Лабораторные работы / 2

-----------------------------------------------------------------------------------------------
--2.9 Список всех простых делителей.
primeDivList n
| n <= 0 = error ("Chislo menshe 1")
| n == 1 = [1]
| otherwise = primelist n 2
primelist n k
| k > n = []
| mod n k == 0 && prime k = k:primelist n (k+1)
| otherwise = primelist n (k+1)

-- Предикат для определения простых чисел
prime::Integer-> Bool
prime n = primef n (n-1)

primef n 2= True
primef n k = if (mod n k==0)
then False
else (primef n (k-1))

-----------------------------------------------------------------------------------------------
--2.12 Число различных элементов в списке.
difElemNum list= length (withoutReiteration list);

withoutReiteration []=[];
withoutReiteration (x:xs)=x:withoutReiteration(delete x xs);

-- Удаление в списке всех элементов со значением toDel
delete toDel []=[];
delete toDel (x:xs)
| toDel == x = delete toDel xs
| otherwise = x:(delete toDel xs)

-----------------------------------------------------------------------------------------------
--2.5 Список, получаемый следующими правилами:
----- 1)порядок элементов на нечётных позициях сохраняется;
----- 2)порядок элементов на чётных позициях меняется на обратный.
evenReverse (x:[]) = [x]
evenReverse l = takesameindex (halflist l True) (reverse (halflist l False))

--Разделение списка на две половины:
--1) True - элементы с нечётными индексами;
--1) False - элементы с чётными индексами.
halflist (x1:x2:[]) True = x1:[]
halflist (x1:x2:[]) False = x2:[]
halflist (x1:[]) True =x1:[]
halflist (x1:[]) False =[]
halflist (x1:x2:xs) True = x1:halflist xs True
halflist (x1:x2:xs) False = x2:halflist xs False

--Соединение двух списков.
takesameindex (x:[]) (y:[]) = [x,y]
takesameindex (x:[]) _ = [x]
takesameindex (x:xs) (y:ys) = x:y:takesameindex xs ys

-----------------------------------------------------------------------------------------------
--2.6 Список, получаемый следующими правилами:
----- 1)порядок элементов на позициях, не кратных n, сохраняется;
----- 2)порядок элементов на позициях, кратных n, меняется на обратный.
nReverse k (x:[]) = [x]
nReverse k l = combination l (reverse (npartlist l k 1)) (k-1) k

--Создание списка с элементами, индекс которых делится на k в исходном списке.
npartlist (x:[]) k counter
| mod counter k == 0 = x:[]
| otherwise = []
npartlist (x:xs) k counter
| mod counter k == 0 = x:npartlist xs k (counter+1)
| otherwise = npartlist xs k (counter+1)

--Соединение двух списков.
combination [] _ _ _ = []
combination (x:xs) [] _ _ = x:combination xs [] 0 0
combination (x:xs) (npart:[]) counter k
| counter == 0 = npart:combination xs [] (k-1) k
| otherwise = x:combination xs (npart:[]) (counter-1) k
combination (x:xs) (npart:nparts) counter k
| counter == 0 = npart:(combination xs nparts (k-1) k)
| otherwise = x:combination xs (npart:nparts) (counter-1) k
-------------------------------------------------------------------
--2.18 Сортировка вставками
insertSort whatOrder [] = []
insertSort whatOrder (x:xs) = insert whatOrder x (insertSort whatOrder xs)

insert whatOrder x [] = x:[]
insert whatOrder x (y:ys)
| whatOrder x y ==True = x : y : ys
| otherwise = y : insert whatOrder x ys

-------------------------------------------------------------------------
--2.16 Сортировка пузырьком
bubbleSort::(a->a->Bool)->[a]->[a]
bubbleSort whatOrder [] = []
bubbleSort whatOrder x
| ifRightOrder (whatOrder) x == True = x
| otherwise = bubbleSort whatOrder (bubble1 whatOrder x)

bubble1 _ [x] = x:[]
bubble1 whatOrder (x:y:xs)
| whatOrder x y ==True = x:bubble1 whatOrder (y:xs)
| otherwise = y:bubble1 whatOrder (x:xs)

ifRightOrder _ [x] = True
ifRightOrder whatOrder (x1:x2:xs)
| whatOrder x1 x2 ==True = ifRightOrder whatOrder (x2:xs)
| otherwise = False