import Test.QuickCheck
import Char

-- 1a.

f :: [Int] -> Int
f xs  =  maximum [ x | x <- 0 : xs, 0 <= x, x <= 100 ]

prop_f  =
    f [40,50,60]       	==  60  &&
    f [40,30,50,70,60] 	==  70  &&
    f [-10,20,80,110]  	==  80  &&
    f [-10,110]        	==   0  &&
    f []               	==   0

-- 1b.

g :: [Int] -> Int
g []                           =  0
g (x:xs) | 0 <= x && x <= 100  =  x `max` g xs
         | otherwise           =  g xs

prop_g  =
    g [40,50,60]       	==  60  &&
    g [40,30,50,70,60] 	==  70  &&
    g [-10,20,80,110]  	==  80  &&
    g [-10,110]        	==   0  &&
    g []               	==   0

-- 1c.

h :: [Int] -> Int
h xs  =  foldr max 0 (filter p xs)
  where
  p x  =  0 <= x && x <= 100

prop_h  =
    h [40,50,60]       	==  60  &&
    h [40,30,50,70,60] 	==  70  &&
    h [-10,20,80,110]  	==  80  &&
    h [-10,110]        	==   0  &&
    h []               	==   0

prop_fg xs  =  f xs == g xs
prop_gh xs  =  g xs == h xs

ok1 =
  quickCheck prop_f  >>      
  quickCheck prop_g  >>      
  quickCheck prop_h  >>      
  quickCheck prop_fg >>   
  quickCheck prop_gh   

-- 2a.

p :: Int -> Int -> [Int]

p x y | x < y      =  [x, x+1 .. y-1]
      | otherwise  =  [x, x-1 .. y+1]

prop_p  =
  p 3 7  ==  [3,4,5,6]  &&  p 7 3  ==  [7,6,5,4]


-- 2b.

r :: [Int] -> [Int]
r zs | not (null zs)  =
  concat [ p x y | (x,y) <- zip zs (tail zs) ] ++ [ last zs ]

prop_r  =
  r [3,7,4,8]      ==  [3,4,5,6,7,6,5,4,5,6,7,8]  &&
  r [1,3,5,3,5,7]  ==  [1,2,3,4,5,4,3,4,5,6,7]

-- 2c.

s :: [Int] -> [Int]
s [x]       =  [x]
s (x:y:zs)  =  p x y ++ s (y:zs)

prop_s  =
  s [3,7,4,8]      ==  [3,4,5,6,7,6,5,4,5,6,7,8]  &&
  s [1,3,5,3,5,7]  ==  [1,2,3,4,5,4,3,4,5,6,7]

prop_rs xs  =  
  not (null xs)  ==> 
    take 1000 (r xs) == take 1000 (s xs)

ok2 =
  quickCheck prop_p  >>     
  quickCheck prop_r  >>       
  quickCheck prop_s  >>     
  quickCheck prop_rs    

-- 3a.

t :: [Int] -> Int
t xs  =  sum [ 1 | (x,y) <- zip ([1]++xs) (xs++[1]), ok x y ]
  where
  ok x y  =  (x==0 && y/=0)

prop_t =
  t []                 ==  0  &&
  t [0,0,0]            ==  1  &&
  t [0,0,1,1,0,0]      ==  2  &&
  t [1,0,0,0,0,1]      ==  1  &&
  t [1,1,0,0,2,2,0,0]  ==  2


-- 3b.

u :: [Int] -> Int
u xs  =  nonzero xs
  where
  nonzero (0:xs)           =  1 + zero xs
  nonzero (x:xs) | x /= 0  =  nonzero xs
  nonzero []               =  0
  zero (x:xs) | x /= 0     =  nonzero xs
  zero (0:xs)              =  zero xs
  zero []                  =  0

prop_u =
  u []                 ==  0  &&
  u [0,0,0]            ==  1  &&
  u [0,0,1,1,0,0]      ==  2  &&
  u [1,0,0,0,0,1]      ==  1  &&
  u [1,1,0,0,2,2,0,0]  ==  2

prop_tu xs  =  t xs == u xs

ok3 =
  quickCheck prop_t  >>
  quickCheck prop_u  >>
  quickCheck prop_tu

ok_all =
  ok1 >>
  ok2 >>
  ok3