Declaratieve Talen/Oplossing haskell buurgraden

--een mogelijke oplossing (zeker niet de beste!)

import List

data Edge a = Boog a a deriving Show
data Graph a = Graaf [a][Edge a] deriving Show

geefBuren :: (Eq a) => Graph a -> a -> [a]
------------------------------------------
geefBuren (Graaf x y) knoop = 
	[b | b <- x, (heeftBoog knoop b y)];


heeftBoog :: (Eq a) => a -> a -> [Edge a] -> Bool
-------------------------------------------------
heeftBoog a b [] = False

heeftBoog a b ((Boog x y):rest) = 
	if ((a == x && b == y) || (b == x && a == y)) then
		True
	else
		heeftBoog a b rest


geefGraad :: (Eq a) => Graph a -> a -> Int
------------------------------------------
geefGraad (Graaf x y) a =
	telgraden y a


telgraden :: (Eq a) => [Edge a] -> a -> Int
-------------------------------------------
telgraden [] a = 0
telgraden ((Boog p q):rest) x =
	if(p == x || q == x) then
		1 + telgraden rest x
	else
		telgraden rest x


buurgraadVanKnoop :: (Eq a) => Graph a -> a -> [Int]
----------------------------------------------------
buurgraadVanKnoop x y = 
	reverse (sort (buurgraadVanBuren x (geefBuren x y)))


buurgraadVanBuren :: (Eq a) => Graph a -> [a] -> [Int]
------------------------------------------------------
buurgraadVanBuren x [] = []
buurgraadVanBuren x (buur:rest) =
	((geefGraad x buur):(buurgraadVanBuren x rest))


buurgraad :: (Eq a) => Graph a -> [([Int], [a])]
------------------------------------------------
buurgraad (Graaf x y) = voegsamen (geefBuurGraden (Graaf x y) x)


geefBuurGraden :: (Eq a) => Graph a -> [a] -> [([Int],[a])]
----------------------------------------------------------
geefBuurGraden a [] = []
geefBuurGraden a (knoop:rest) =
	(((buurgraadVanKnoop a knoop),[knoop]):(geefBuurGraden a rest))


voegsamen :: [([Int], [a])] -> [([Int], [a])]
---------------------------------------------
voegsamen [] = []
voegsamen ( (x, y) : rest) =
	((voegbij (x,y) rest) : voegsamen (verwijder (x,y) rest rest))


voegbij :: ([Int], [a]) -> [([Int], [a])] -> ([Int], [a])
---------------------------------------------------------
voegbij a [] = a
voegbij (x, y) ((a,[b]):rest) =
	if(x == a) then
		voegbij (x,(b:y)) rest
	else
		voegbij (x,y) rest


verwijder :: ([Int], [a]) -> [([Int], [a])] -> [([Int], [a])] -> [([Int], [a])]
---------------------------------------------------------
verwijder a [] b = b
verwijder (x, y) ((a,[b]):rest) ((i,j):rij) =
	if(x == a) then
		verwijder (x,y) rest rij
	else
		verwijder (x,y) rest ((i,j):rij)

Een alternatief

Merk op dat deze oplossing de uitkomst niet sorteert ...

import List

-- Graaf ['a','b','c','d','e','f','g','h'] [Boog 'a' 'b', Boog 'b' 'c', Boog 'e' 'f', Boog 'f' 'g', Boog 'g' 'h', Boog 'h' 'a', Boog 'd' 'g', 
-- Boog 'c' 'd', Boog 'd' 'e', Boog 'a' 'd']

data Graaf a = Graaf [a] [Boog a] deriving Show
data Boog a = Boog a a deriving Show

geef_buren::(Eq a)=>a->Graaf a->[a]
geef_buren knoop (Graaf _ bogen) = [y | (Boog y z) <- bogen, z==knoop] ++ [y | (Boog z y) <- bogen, z==knoop]


graad_knopen::(Eq a)=>[a]->Graaf a->[Int]
graad_knopen [] graaf = []
graad_knopen (knoop:xs) graaf = length (geef_buren knoop graaf) : (graad_knopen xs graaf)

buurgraad::(Eq a)=>a->Graaf a->([Int],[a])
buurgraad knoop graaf =
	let
		buren = geef_buren knoop graaf
	in 	(reverse (sort (graad_knopen buren graaf)) , [knoop])

buurgraad_graaf::(Eq a)=>Graaf a->[([Int],[a])]
buurgraad_graaf (Graaf knopen bogen) = 
	[(buurgraad knoop (Graaf knopen bogen)) | knoop <- knopen]

--Thomas Vochten