2 files changed, 122 insertions, 12 deletions

diff --git a/AufgabeFFP5.hs b/AufgabeFFP5.hs
index d84307c..c528be4 100644
--- a/AufgabeFFP5.hs
+++ b/AufgabeFFP5.hs
@@ -25,26 +25,75 @@ dynamic compute bnds = t
     t = newTable (map (\coord -> (coord, compute t coord)) (range bnds))
 
 -------------------------------------------------------------------------------
+-- 1.
+-------------------------------------------------------------------------------
 
 bndsAS :: Array Int Int -> ((Int, Int), (Int, Int))
 bndsAS a = ((l,l), (h,h))
   where
     (l,h) = bounds a 
 
+-- fill the table. Lower half below diagonal not necessary
+-- but filled with the symmetric value
 compAS :: Array Int Int -> Table Int (Int, Int) -> (Int, Int) -> Int
 compAS a t (i,j)
   | i == j = a ! j
   | i<j = compAS a t (j,i)
   | otherwise = findTable t (i-1, j) + a!i
-  
-asDyn :: Array Int Int -> (Int, Int) -> Int
-asDyn a (i,j) = findTable t (i,j)
-  where
-      t = dynamic (compAS a) (bndsAS a)
 
+-- computes table for array
+asTbl :: Array Int Int -> Table Int (Int, Int)
+asTbl a = dynamic (compAS a) (bndsAS a)
+  
 -- maximum function for tables
-tblMax :: Table Int (Int,Int) -> Int
+tblMax :: (Ord a, Ix b) => Table a b -> a
 tblMax (Tbl a) = maximum $ elems a
 
+-- maximum of the array's distance-sums
 mas :: Array Int Int -> Int
-mas a = tblMax $ dynamic (compAS a) (bndsAS a)
+mas a = tblMax $ asTbl a
+
+-------------------------------------------------------------------------------
+-- 2.
+-------------------------------------------------------------------------------
+
+-- all indices where the value equals to the maximum distance-sum
+amas :: Array Int Int -> [(Int, Int)]
+amas a = [(i,j) | ((i,j),v) <- (assocs array), i<=j, v>=m]
+  where
+    t@(Tbl array) = asTbl a
+    m = tblMax t
+
+-------------------------------------------------------------------------------
+-- 3.
+-------------------------------------------------------------------------------
+
+-- computes index with maximum index-difference
+maxL :: [(Int, Int)] -> (Int, Int)
+maxL [] = error "maximum of empty list"
+maxL [x] = x
+maxL (x:xs)
+  | l x >= l maxTail = x
+  | otherwise = maxTail
+  where
+    l (x,y) = y-x
+    maxTail = maxL xs
+
+-- index with maximum distance-sum and maximum index-difference 
+lmas :: Array Int Int -> (Int, Int)
+lmas a = maxL $ amas a
+
+-------------------------------------------------------------------------------
+
+divideAndConquer :: (p->Bool) -> (p->s) -> (p->[p]) -> (p->[s]->s) -> p -> s
+divideAndConquer indiv solve divide combine initPb = dAC initPb
+  where
+    dAC pb
+      | indiv pb = solve pb
+      | otherwise = combine pb (map dAC (divide pb))
+
+      
+-------------------------------------------------------------------------------
+-- 4.
+-------------------------------------------------------------------------------
+
diff --git a/TestAufgabeFFP5.hs b/TestAufgabeFFP5.hs
index 03cd00b..256c1ea 100644
--- a/TestAufgabeFFP5.hs
+++ b/TestAufgabeFFP5.hs
@@ -5,17 +5,78 @@ import Control.Monad
 import Data.Array
 import AufgabeFFP5
 
+a :: Array Int Int
+a = array (1,9) [(1,3),(2,(-5)),(3,0),(4,9),(5,2),(6,(-1)),(7,2),(8,(-5)),(9,1)]
+
+b :: Array Int Int
+b = array (1,9) [(1,3),(2,(-1)),(3,(-2)),(4,9),(5,2),(6,(-1)),(7,2),(8,0),(9,(-1))]
+
+c :: Array Int Int
+c = array (1,5) [(1,2),(2,3),(3,(-10)),(4,1),(5,4)]
+
+d :: Array Int Int
+d = array (1,6) [(1, (-3)), (2, 1), (3, 10), (4, (-5)), (5, 8), (6, 7)]
+
+minA :: Array Int Int
+minA = array (0,0) [(0,0)]
+
 cases1 = TestLabel "mas" $ TestList [
-  TestCase $ assertEqual "exercise example"
+  TestCase $ assertEqual "mas a"
     12
-    (mas $ array (1,9) [(1,3),(2,(-5)),(3,0),(4,9),(5,2),(6,(-1)),(7,2),(8,(-5)),(9,1)]),
-  TestCase $ assertEqual "short list"
+    (mas a),
+  TestCase $ assertEqual "mas b"
+    12
+    (mas b),
+  TestCase $ assertEqual "mas c"
+    5
+    (mas c),
+  TestCase $ assertEqual "mas d"
     21
-    (mas $ array (1,6) [(1, (-3)), (2, 1), (3, 10), (4, (-5)), (5, 8), (6, 7)])
+    (mas d),
+  TestCase $ assertEqual "mas minA"
+    0
+    (mas minA)
+  ]
+  
+cases2 = TestLabel "amas" $ TestList [
+  TestCase $ assertEqual "amas a"
+    [(3,7), (4,7)]
+    (amas a),
+  TestCase $ assertEqual "amas b"
+    [(1,7),(1,8),(4,7),(4,8)]
+    (amas b),
+  TestCase $ assertEqual "amas c"
+    [(1,2),(4,5)]
+    (amas c),
+  TestCase $ assertEqual "amas d"
+    [(2,6)]
+    (amas d),
+  TestCase $ assertEqual "amas minA"
+    [(0,0)]
+    (amas minA)
   ]
+  
+cases3 = TestLabel "lmas" $ TestList [
+  TestCase $ assertEqual "lmas a"
+    (3,7)
+    (lmas a),
+  TestCase $ assertEqual "lmas b"
+    (1,8)
+    (lmas b),
+  TestCase $ assertEqual "lmas c"
+    (1,2)
+    (lmas c),
+  TestCase $ assertEqual "lmas d"
+    (2,6)
+    (lmas d),
+  TestCase $ assertEqual "lmas minA"
+    (0,0)
+    (lmas minA)
+  ]
+
 
 tests :: [Test]
-tests = [cases1]
+tests = [cases1, cases2, cases3]
 
 main = do
   forM tests $ \test ->