Лабораторные работы / 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