Question

count :: Eq a => a -> [a] -> Int
count n [] = 0
count n (x:xs) | n == x = 1 + count n xs
           | otherwise = count n xs



rmdups :: Eq a => [a] -> [a]
rmdups [ ] = [ ]
rmdups (x:xs) = x : rmdups (filter(/= x) xs)

using the 2 functions, a third needs to be created, called frequency:
it should count how many times each distinct value in a list occurs in that list. for example : frequency “ababc”, should return [(3,’a’),(2,’b’),(1,’c’)].
the layout for frequency is :

frequency :: Eq a => [a] -> [(Int, a)]

P.s rmdups, removes duplicates from list, so rmdups “aaabc” = abc
and count 2 [1,2,2,2,3] = 3.

so far i have:

frequency :: Eq a => [a] -> [(Int, a)]
frequency [] = []
frequency (x:xs) = (count x:xs, x) : frequency (rmdups xs)

but this is partly there, (wrong). thanks

Answer 1

frequency xs = map (\c -> (count c xs,c)) (rmdups xs)

or, with a list comprehension,

frequency xs = [(count c xs, c) | c <- rmdups xs]

is the shortest way to define it using your count and rmdups. If you need it sorted according to frequency (descending) as in your example,

frequency xs = sortBy (flip $ comparing fst) $ map (\c -> (count c xs,c)) (rmdups xs)

using sortBy from Data.List and comparing from Data.Ord.

If all you have is an Eq constraint, you cannot gain much efficiency, but if you only need it for types in Ord, you can get a much more efficient implementation using e.g. Data.Set or Data.Map.