hej labb4

Author: matteB10

Sudoku.hs

@@ -151,8 +151,6 @@ isOkay sud = all isOkayBlock $ blocks sud
 
 -- | Positions are pairs (row,column),
 -- (0,0) is top left corner, (8,8) is bottom left corner
-type Pos = (Int,Int)
-
 -- * E1
 
 blanks :: Sudoku -> [Pos]
@@ -209,6 +207,7 @@ solve' sudoku blank | (not $ isSudoku sudoku) || (not $ isOkay sudoku) = []
                     | otherwise                                        = filter (\x -> isOkay x && isFilled x) solution
         where solution = concat [solve' (update sudoku (head blank) (Just c)) (drop 1 blank) | c <- [1..9]]
 
+
 -- * F2
 -- | Reads a sudoku from a file, solves it and prints the solution if found
 readAndSolve :: FilePath -> IO ()
@@ -227,8 +226,10 @@ isSolutionOf sud1 sud2 = isOkay sud1 && isFilled sud1
 prop_SolveSound :: Sudoku -> Property
 prop_SolveSound sudoku = isSudoku sudoku && isOkay sudoku ==> solveSound (solve sudoku) sudoku
     where solveSound :: Maybe Sudoku -> Sudoku -> Bool
-          solveSound (Just sudoku) sud = isSolutionOf (fromJust $ Just sudoku) sud
+          solveSound (Just sudoku) sud = isSolutionOf sudoku sud
           solveSound Nothing _         = False
 
 -- | Fewer checks that can be used instead of quickChecks standard 100 test's
 fewerChecks prop = quickCheckWith stdArgs{maxSuccess=30 } prop
+
+

SudokuMB.hs

@@ -212,6 +212,12 @@ module Sudoku where
       where blank = findIndices (== Nothing) r 
             iList = replicate (length blank) i  
 
+  blankRow' :: Row -> Int -> [Pos]
+  blankRow' [] _     = []
+  blankRow' (c:cs) i = zip iList blank ++ blankRow rs (i + 1)
+      where blank = findIndices (== Nothing) r 
+            iList = replicate (length blank) i  
+          
 
   -- | Check that all elements in the list of blanks actually is blank
   --   by filtering out all 'Nothing' elements and see if something is left
@@ -261,7 +267,24 @@ module Sudoku where
                       | isFilled sudoku && isOkay sudoku                 = [sudoku] 
                       | otherwise                                        = filter (\x -> isOkay x && isFilled x) solution
        where solution = concat [solve' (update sudoku (head blank) (Just c)) (drop 1 blank) | c <- [1..9]]
-                      
+           
+       
+  -- | extra assignments
+  solve'' :: Sudoku -> [Pos] -> [Sudoku] 
+  solve'' sudoku blank | (not $ isSudoku sudoku) || (not $ isOkay sudoku) = []
+                     | isFilled sudoku && isOkay sudoku                 = [sudoku] 
+                     | otherwise                                        = filter (\x -> isOkay x && isFilled x) solution
+        where solution = concat [solve'' (update sudoku pos (Just c)) (drop 1 blank) | c <- [1..9]]
+              pos      = take 1 $ getMax $ map noOfBlanks (rows sudoku)
+
+  noOfBlanks :: Row -> Int 
+  noOfBlanks []     = []
+  noOfBlanks (r:rs) = (length $ blankRow' r):noOfBlanks rs
+
+  getMax :: [Int] -> [Int]
+  getMax []     = []
+  getMax (x:xs) = if x < (head xs) then getMax xs else getMax (x:tail xs)
+
   -- * F2 
   -- | Reads a sudoku from a file, solves it and prints the solution if found
   readAndSolve :: FilePath -> IO ()

testHaskell.hs

@@ -1,8 +1,34 @@
 import Data.List
+
+{-
 sortFile :: FilePath -> IO ()
 
 sortFile filename =
   do input <- readFile filename
      l <- lines input
      sortedString <- sort l
-     writeFile filename sortedString
+     writeFile filename sortedString
+-}
+
+
+data Expr = Val Int | Div Expr Expr
+
+eval :: Expr -> Maybe Int
+eval (Val i)   = Just i
+eval (Div x y) = cases (eval x) (\n -> cases (eval y) (\m -> safeDiv n m))
+
+eval' :: Expr -> Maybe Int
+eval' (Val i)   = Just i
+eval' (Div x y) = do
+                    n <- eval x
+                    m <- eval y
+                    n `safeDiv` m
+                    
+-- | Cases used as binding operator >>= 
+cases :: Maybe Int -> (Int -> Maybe Int) -> Maybe Int
+cases m f = case m of
+                Nothing -> Nothing
+                Just x -> f x 
+
+safeDiv :: Int -> Int -> Maybe Int
+safeDiv m n = if n == 0 then Nothing else Just $ div m n