HELP NEEDED

I don't think this is worth commenting, but if you can't come up with an answer to those simple questions, or at least try it and post some code you used to try and find a solution, we are certainly not going to solve them for you.

Homework assignments are exactly that: stuff YOU should do, not the rest of the world.

Grr.

Here are some useful functions which you should know about while attempting these problems:

filter :: (a -> Bool) -> [a] -> [a]
Given a predicate and a list, return the list of elements satisfying the predicate.
For example: filter odd [1..10] = [1,3,5,7,9]

any :: (a -> Bool) -> [a] -> Bool
Given a predicate and a list of elements, return True if any of the elements of the list satisfy the predicate, and False otherwise. (cf. all)

foldr :: (a -> b -> b) -> b -> [a] -> b
foldr f z xs replaces each occurrence of (:) with f and [] with z in the list xs. That is:


foldr f z [] = z
foldr f z (x:xs) = f x (foldr f z xs)


You can use this to apply an operator "between" the elements of a list, for instance:
foldr (*) 1 [5..10] == 5 * (6 * (7 * (8 * (9 * (10 * 1))))) == 151200

foldr1 :: (a -> a -> a) -> [a] -> [a]
Works similarly to foldr, except that the types are more restrictive, it doesn't work on empty lists, and (this is the good part) it doesn't require the replacement for [].


foldr1 f [x] = x
foldr1 f (x:xs) = f x (foldr1 f xs)
foldr1 _ [] = error "Prelude.foldr1: empty list"


max, min :: (Ord a) => a -> a -> a
These take two values of some ordered type and return the maximum and minimum of the two respectively.

From the module Char:
isUpper :: Char -> Bool
Decides whether a character is uppercase. (cf. isLower)

Hope this helps.
- Cale

these are the coding that i have so far, some are incomplete you think that you could assist me with these?

question 2

fact :: Int -> Int
fact 0 = 1
fact n = n * fact (n-1)

question 6

Sum :: [Int] -> Int
Sum (x:xs)
|(xs == []) = x
|otherwise = x + sumlist xs

question 5

Isupper :: [Int] -> Bool
Isupper (x:xs)
|xs == []
|otherwise x = True
|otherwise = False

question 4

minlist :: [Int] -> Int
minlist (x:xs)
| x < minlist xs = True
| otherwise = False

question 7

getEven::[Int]->Int
getEven (x:xs)
|(mod x 2 == 0) =
|

question 3

getlarger :: Char -> char -> Char
getlarger 'a' 'b'
| 'a' > 'b' = 'a'
| otherwise = 'b'

question 1

sumAB :: Int -> Int -> Int
SumAB a b
|a==b = a
|a < b = a + sumAB (a + 1) b

Ok, for the first one, I think the following is a bit more hip.

sumAB :: Int -> Int -> Int
sumAB a b = sum $ filter (not . (== 0) . (`mod` 2)) [(a+1) .. (b-1)]

Good to have seen you try though.