module Sol_Exercise_1 where
import Test.QuickCheck
import Data.List

{- G1.1 -}
threeDifferent :: Integer -> Integer -> Integer -> Bool
threeDifferent x y z = x /= y && x /= z && y /= z

fourEqual :: Integer -> Integer -> Integer -> Integer -> Bool
fourEqual w x y z = w == x && x == y && y == z

{-
 - threeDifferent (2 + 3) 5 (11 `div` 2)
 - = (2 + 3) /= 5 && (2 + 3) /= (11 `div` 2) && 5 /= (11 `div` 2)
 - = 5 /= 5 && 5 /= (11 `div` 2) && 5 /= (11 `div` 2)
 - = False && 5 /= (11 `div` 2) && 5 /= (11 `div` 2)
 - = False
 -
 - fourEqual (2 + 3) 5 (11 `div` 2) (21 `mod` 11)
 - = (2 + 3) == 5 && 5 == (11 `div` 2) && (11 `div 2) == (21 `mod` 11)
 - = 5 == 5 && 5 == (11 `div` 2) && (11 `div 2) == (21 `mod` 11)
 - = True && 5 == (11 `div` 2) && (11 `div 2) == (21 `mod` 11)
 - = 5 == (11 `div` 2) && (11 `div 2) == (21 `mod` 11)
 - = 5 == 5 && 5 == (21 `mod` 11)
 - = True && 5 == (21 `mod` 11)
 - = 5 == (21 `mod` 11)
 - = 5 == 10
 - = False
 -}



{- G1.2 -}
fac :: Integer -> Integer
fac n | n > 0 = n * fac (n - 1)
      | otherwise = 1

sum_eleven :: Integer -> Integer
sum_eleven n = sum_eleven' n 10

sum_eleven' :: Integer -> Integer -> Integer
sum_eleven' n 0 = n
sum_eleven' n m = n + m + sum_eleven' n (m - 1)



{- G1.3 -}
g :: Integer -> Integer
g n = if n < 10 then n*n else n

max_g :: Integer -> Integer
max_g 0 = 0
max_g n | n > 0 = if (g mg > g n) then mg else n
        | otherwise = 0
            where mg = max_g (n - 1)

max_g' :: Integer -> Integer
max_g' n | n < 0 = 0
         | n >= 10 && n < 81 = 9
         | otherwise = n

prop_max_g n = max_g n == max_g' n



{- H1.1 -}

{-WETT-}
{- 44 tokens -}
f124 :: Integer -> Integer -> Integer -> Integer
f124 x y z = if x > y then f124 y x z
             else if x > z then f124 z y x
             else if y > z then f124 x z y
             else x + 2 * y + 4 * z
{-TTEW-}

{-WETT-}
{- 43 tokens -}
g124 :: Integer -> Integer -> Integer -> Integer
g124 x y z | x > y = g124 y x z
           | x > z = g124 z y x
           | y > z = g124 x z y
           | otherwise = x + 2 * y + 4 * z
{-TTEW-}

{-WETT-}
{- 32 tokens -}
sum_up :: [Integer] -> Integer
sum_up (x : xs) = x + 2 * sum_up xs
sum_up _ = 0

h124 :: Integer -> Integer -> Integer -> Integer
h124 x y z = sum_up $ sort [x, y, z]
{-TTEW-}

{-WETT-}
{- 31 tokens -}
i124 :: Integer -> Integer -> Integer -> Integer
i124 x y z =
  a + 2 * b + 4 * c
  where [a, b, c] = sort [x, y, z]
{-TTEW-}

{-WETT-}
{- 26 tokens -}
iHorner_helper :: Integer -> Integer -> Integer
iHorner_helper v a = 2 * a + v

iHorner :: Integer -> Integer -> Integer -> Integer
iHorner x y z = foldr iHorner_helper 0 $ sort [x, y, z]
{-TTEW-}

-- f124_test1 = quickCheck (\x y z -> f124 x y z == i124 x y z)
-- g124_test1 = quickCheck (\x y z -> g124 x y z == i124 x y z)
-- h124_test1 = quickCheck (\x y z -> h124 x y z == i124 x y z)

{- H1.2 -}

f :: Integer -> Integer
f n
  | n > 100 = n - 10
  | otherwise = f (f (n + 11))

f' :: Integer -> Integer
f' n = if n > 101 then n - 10 else 91

f'_wrong :: Integer -> Integer
f'_wrong n = 91

-- f_test1 = quickCheckWith stdArgs { maxSize = 1000 } (\n -> f n == f' n)
-- f_test2 = quickCheckWith stdArgs { maxSize = 1000 } (\n -> f n == f'_wrong n)

{- H1.3 -}

ld :: Integer -> Integer
ld 1 = 0
ld n = 1 + ld (n `div` 2)

-- ld_test1 = quickCheck (\n -> n > 0 ==> let x = ld n in 2 ^ x <= n && n < 2 ^ (x + 1))