module Exercise_1 where
import Test.QuickCheck

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


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) && (5 /= (11 ` div ` 2)) && ((11 ` div ` 2) /= (2+3))
        (5 /= 5) && ((5 /= (11 ` div ` 2)) && ((11 ` div ` 2) /= (2+3)))
        False && ((5 /= (11 ` div ` 2)) && ((11 ` div ` 2) /= (2+3)))
        False

        Schritte von oben nach unten:
        threeDifferent ersetzen
        Linke Seite des ersten &&
        5 /= 5 auswerten
        False && x = False (&& ist rechtsassoizativ)


        ---


        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) && ((11 ` div ` 2) == (21 ` mod ` 11))
        True && ((11 ` div ` 2) == (21 ` mod ` 11))
        ((11 ` div ` 2) == (21 ` mod ` 11))
        (5 == (21 ` mod ` 11))
        (5 == 10)
        False

        Schritte von oben nach unten:
        fourEqual ersetzen
        Linke Seite des ersten &&
        5 == 5 auswerten
        True && x = x
        Linke Seite des zweiten && (div ist Ganzzahldivision)
        5 == 5 auswerten
        True && x = x
        Links nach rechts
        5 == 10 auswerten
-}



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


sum_ten :: Integer -> Integer
sum_ten n = sum_ten' n 9
        where
        sum_ten' :: Integer -> Integer -> Integer
        sum_ten' n 0 = n
        sum_ten' n x = n + x + sum_ten' n (x-1)


sum_ten_gauss :: Integer -> Integer
sum_ten_gauss n = 10 * n + 45



{---------------------------------------------------------------------}
{- G1.3 -}
{- 
        g ist leicht veraendert, um Mehrdeutigkeiten zu vermeiden.
        Original:
        g :: Integer -> Integer
        g n = if n < 10 then n*n else n
-}

g :: Integer -> Integer
g n = if n < 10 then n*n else 2*n


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


max_g' :: Integer -> Integer
max_g' n
        | n < 0 = 0
        | n <= 9 = n
        -- Siehe Aenderung von g
        | n < 41 = 9
        | otherwise = n


prop_max_g :: Integer -> Bool
prop_max_g n =
        max_g n == max_g' n



{---------------------------------------------------------------------}
{- Aufgabe H1.1 -}
{-WETT-} {- Diese Zeile nicht entfernen -}
sum_max_sq :: Integer -> Integer -> Integer -> Integer
sum_max_sq x y z = max x y ^ 2 + min x y `max` z ^ 2
{-TTEW-} {- Diese Zeile nicht enfernen! -}



{---------------------------------------------------------------------}
{- Aufgabe H1.2 -}
{- Teil 1 -}
f :: Integer -> Integer
f n
  | n > 100 = n - 10
  | otherwise = f (f (n + 11))


{- Teil 2 -}
{-
 - [(x, f x) | x <- [0,1,2,3,42,101,1001,-10]]
 -
 - (   x, f x)
 - -----------
 - (   0,  91)
 - (   1,  91)
 - (   2,  91)
 - (   3,  91)
 - (  42,  91)
 - ( 101,  91)
 - (1001, 991)
 - ( -10,  91)
 -}


{- Teil 3 -}
f' :: Integer -> Integer
f' n = if n > 101 then n - 10 else 91


{- Quickcheck test -}
prop_f n = f n == f' n



{---------------------------------------------------------------------}
{- Aufgabe H1.3 -}
{- Teil 1 -}
is_square' :: Integer -> Integer -> Bool
is_square' n 0 = n == 0
is_square' n m
        | m < 0 = False
        | otherwise = m * m == n || is_square' n (m-1)


{- Teil 2 -}
is_square :: Integer -> Bool
is_square n
        | n < 0 = False
        | otherwise = is_square' n n