=), Haskell - rextester

=)

----------------Block mit Hilfsfunktionen---------------
maximum3 :: Int -> Int -> Int -> Int  ----Nimmt das groesste Element aus drei
---- maximum3 x y z = max x (max y z) ---aber---
maximum3 x y z
  | (x >= y)&&(x >= z) = x
  | (y >= x)&&(y >= z) = y
  | (z >= y)&&(z >= x) = z

minimum3 :: Int -> Int -> Int -> Int ----Nimmt das kleinste Element aus drei
---- minimum3 x y z = min x (min y z) ---aber---
minimum3 x y z
  | (x <= y)&&(x <= z) = x
  | (y <= x)&&(y <= z) = y
  | (z <= y)&&(z <= x) = z
  
testMaximum3 :: Int -> Int -> Int -> Int
testMaximum3 x y z
  | (x > y)&&(x > z) = x
  | (y > z) = y
  | otherwise = z

arithmit :: Int -> Int -> Int  ----Gibt das arithmetische Mittel von zwei ganzen Zahlen zurueck
arithmit x y = div (x + y) 2

xor :: Bool -> Bool -> Bool  --- Antivalenz
xor x y = (x || y) && (not x || not y)
-------------------------------------------------------

--------------AUFGABE 1--------------------------------

--------------Aufgabe 1.a------------------------------
avgIncluded3 :: Int -> Int -> Int -> Bool
avgIncluded3 a b c
  | ((mod sum 2 == 0) &&   ---Das arithmetische Mittel darf nicht ein Bruch sein
    (
      (div sum 2 == a) ||
      (div sum 2 == b) ||
      (div sum 2 == c)
    )) = True
  | otherwise = False
  where sum = maximum3 a b c + minimum3 a b c
  
  --meine Lösung ist ein bisschen anders:
avgIncluded3_1::Int->Int->Int->Bool
avgIncluded3_1 a b c 
    | 2*a == (b + c)|| 2*b == (a + c) || 2*c == (a + b) = True
    | otherwise = False

--------------Aufgabe 1.b------------------------------
avgOf2Included4 :: Int -> Int -> Int -> Int -> Bool
avgOf2Included4 a b c d
  | (mod (a + b) 2 == 0) &&  ---Das arithmetische Mittel darf nicht ein Bruch sein
    (
      (c == arithmit a b) || (d == arithmit a b)
    ) = True

| (mod (b + c) 2 == 0) &&
    (
      (a == arithmit b c) || (d == arithmit b c)
    ) = True

| (mod (c + d) 2 == 0) &&
    (
      (a == arithmit c d) || (b == arithmit c d)
    ) = True

| (mod (a + c) 2 == 0) &&
    (
      (b == arithmit a c) || (d == arithmit a c)
    ) = True

| (mod (a + d) 2 == 0) &&
    (
      (b == arithmit a d) || (c == arithmit a d)
    ) = True

| (mod (b + d) 2 == 0) &&
    (
      (a == arithmit b d) || (c == arithmit b d)
    ) = True

| otherwise = False
  
--hier habe ich: 
avgOf2Included4_1:: Int->Int->Int->Int->Bool
avgOf2Included4_1 a b c d 
    | (a+b+c+d == 3*a+b || a+b+c+d == 3*a+c || a+b+c+d == 3*a+d) = True
    | (a+b+c+d == 3*b+c || a+b+c+d == 3*b+d || a+b+c+d == 3*b+a) = True
    | (a+b+c+d == 3*c+b || a+b+c+d == 3*c+a || a+b+c+d == 3*c+d) = True 
    | (a+b+c+d == 3*d+b || a+b+c+d == 3*d+c || a+b+c+d == 3*d+a) = True
    | otherwise = False

--------------Aufgabe 1.c------------------------------
largestDifference :: Int -> Int -> Int -> Int
largestDifference a b c = maximum3 a b c - minimum3 a b c

--das habe ich auch so wie du... ich hab ein bisschen abgeschrieben, weil der ghci meinen Syntax nicht mag...

--------------Aufgabe 1.d------------------------------
antiva14 :: Bool -> Bool -> Bool -> Bool -> Bool
antiva14 b1 b2 b3 b4 = xor (xor b1 b2) (xor b3 b4)  ---denn XOR ist kommutativ

-- ich hab einfach alles reingeschrieben. Ich weiß allerdings nicht, ob es funktioniert... ghci beschwert sich nicht, aber ich habe es noch nicht getestet.
antival4::Bool->Bool->Bool->Bool->Bool
antival4 a1 a2 a3 a4
    |( ( a1 && not(a2) ) || ( not(a1) && a2 ) ) && not( ( a3 && not(a4) ) || ( not(a3) && a4 ) ) || not( ( a1 && not(a2) ) || ( not(a1) && a2 ) ) && ( ( a3 && not(a4) ) || ( not(a3) && a4 ) ) = a1

--------------AUFGABE 2--------------------------------

---maxExp2 :: Int -> Int

--Aufgabe_2a: das groesste k sodass 2^k|n. Für n=0 --> k=0
maxExp2 :: Int->Int
maxExp2 n
  --  | n==0 = 0 --in Aufgabenstellung vorgegeben
    | n `mod` 2 == 1 = 0 --wenn n ungerade ist, ist die kleinste Zweierpotenz 1 = 2^0
    | ( n `mod` 2 == 0 ) = 1 + maxExp2 (n `div` 2) --wenn n gerade ist: immer wieder durch 2 teilen, (+1) zaehlt mit.

--Aufgabe_2a: das groesste k sodass 2^k|n. Für n=0 --> k=0
maxExp2_2 :: Int->Int
maxExp2_2 n
  --  | n==0 = 0 --in Aufgabenstellung vorgegeben
    | mod n 2 == 1 = 0 --wenn n ungerade ist, ist die kleinste Zweierpotenz 1 = 2^0
    | mod n 2 == 0 = 1 + maxExp2 (div n 2) --wenn n gerade ist: immer wieder durch 2 teilen, (+1) zaehlt mit.
    
 
--Aufgabe_2b: die groesste Dreierpotenz, also 3^k sodass 3^k<=n
maxExp3 :: Int ->Int --Hilfsfunktion, die den Exponenten für maxPow3 berechnet
maxExp3 k 
    | k < 0 = error"nur natuerliche Zahlen"
    | k < 3 = 0
    | k `div` 3 < 3 = 1
    | k `div` 3 >= 3 = 1 + maxExp3 (k `div` 3)

maxPow3 :: Int->Int --eigentliche Funktion, die die Dreierpotenz ausrechnet.
maxPow3 n = 3 ^ (maxExp3 n)

--Aufgabe_2d
sumOfOddSquares::Int->Int --Summe der Quadrate aller ungeraden Zahlen k mit 1<=k<=n
sumOfOddSquares n 
    | (n < 0) = error"nur natuerliche Zahlen" --nach Aufgabenstellung
    | (n == 0) = 0 --erster Rekursionsanker
    | (n == 1) = 1 --zweiter Rekursionsanker
    | (n `mod` 2 == 0) = (n-1)^2 + sumOfOddSquares (n-2) --wenn n gerade ist: (-1) um auf die naechste ungerade Zahl zu kommen
    | (n `mod` 2 == 1) = n^2 + sumOfOddSquares (n-2) --wenn n ungerade ist. (-2) um die geraden Zahlen zu ueberspringen.

main = do
    putStr "Aufgabe 1.a : " 
    print $ avgIncluded3 2 7 4
    putStr "Aufgabe 1.b : " 
    print $ avgOf2Included4 3 7 5 9
    putStr "Aufgabe 1.c : " 
    print $ largestDifference 3 7 5
    putStr "Aufgabe 1.d : " 
    print $ antiva14 False True False False
    putStr "Aufgabe 2.a : " 
    print $ maxExp2_2 8
    putStr "Aufgabe 2.b : " 
    print $ maxExp3 8


run \| edit \| history \| help	0