common format

Author: votroto

exams/convex-hull/index.md

@@ -111,6 +111,8 @@ Your file has to be called `convexhull.rkt` and must provide the function
 ; your code goes here
 ```
 
+### Hints
+
 _**Hint \#2 (Polar Angle)**_
 In Scheme, you can compute the polar angle of a vector $\vec v=(x,y)$ with
 ```racket
@@ -238,6 +240,7 @@ import Data.List -- for sortBy
 -- your code goes here
 ```
 
+### Hints
 
 _**Hint \#4 (Polar Angle):**_
 In Haskell, you can compute the polar angle of a vector `v = (x,y)` with

exams/fermat-primality/index.md

@@ -21,7 +21,7 @@ This probabilistic primality test is known as the *Fermat Primality Test*.  Note
 *Carmichael numbers*, which are composite yet pass the test for all $a$ relatively prime to the
 respective number, are avoided when testing your implementation of this task.
 
-## Pseudo-random Number Generation
+### Pseudo-random Number Generation
 
 To generate pseudorandom numbers in a given interval, use
 the *Linear Congruential Generator (LCG)*
@@ -35,11 +35,11 @@ $$
   b' = (b \ \texttt{mod}\, (b^\text{upper} - b^\text{lower})) + b^\text{lower}.
 $$
 
+## Haskell
 
-Your task is to implement the Fermat Primality Test in Haskell.
-There are two parts to this task: first, implement the LCG, and then the test itself.
+Your task is to implement the Fermat Primality Test in Haskell. Your file should be called `Fermat.hs`, and you should export the function `primality :: Int -> Int -> State LCG Bool`. There are two parts to this task: first, implement the LCG, and then the test itself.
 
-## Implementation
+### Implementation
 
 The LCG generator is represented as
 ```haskell
@@ -84,45 +84,40 @@ False
 True
 ```
 
-## Hint
+### Hint
 
 To prevent overflow of `Int`, compute $a^{p-1}\mod p$ sequentially using
 the identity $a^{k+1}\mod p = a\cdot (a^k\mod p)\mod p$, i.e.,
 sequentially multiplying by $a$ and applying modulo to each partial result.
 
 ::: details Exam Solution
 ```haskell
+module Fermat (LCG (..), primality) where
+
+import Control.Monad
 import Control.Monad.State
 
----- linear congruential generator
-data LCG = LCG  Int Int Int Int deriving Show -- A*x + C mod M
+-- Linear congruential generator
+-- A*x + C mod M
+data LCG = LCG Int Int Int Int deriving (Show)
+
+lcg (LCG a x c m) =
+  let y = (a * x + c) `mod` m
+   in (y, LCG a y c m)
 
-generate :: State LCG Int
-generate = do (LCG a x c m) <- get
-              let x' = (a * x + c) `mod` m
-              put (LCG a x' c m)
-              return x'
+generate = state lcg
 
-generate_range :: Int -> Int -> State LCG Int -- a <= x < b
-generate_range a b = do x <- generate
-                        let x' = (x `mod` (b-a)) + a
-                        return x'
+project low high num = (num `mod` (high - low)) + low
 
-modulo_power :: Int -> Int -> Int -> Int
-modulo_power a n m = iter a n where
-    iter b 1 = b
-    iter b nn = iter (b*a `mod` m) (nn-1)
+generateRange low high = project low high <$> generate
 
-fermat_comp :: Int -> Int -> Int
-fermat_comp p b = (modulo_power b (p-1) p)
+moduloPower a n m = iterate (\x -> x * a `mod` m) 1 !! n
 
-fermat_check :: Int -> Int -> Int -> State LCG Bool
-fermat_check p n 1 = primality p (n-1)
-fermat_check _ _ _ = return False
+fermatCheck p r = 1 == moduloPower r (p - 1) p
 
 primality :: Int -> Int -> State LCG Bool
-primality p 0 = return True
-primality p n = do b <- generate_range 1 p
-                   fermat_check p n (fermat_comp p b)
+primality x n = do
+  rs <- replicateM n (generateRange 1 x)
+  pure (all (fermatCheck x) rs)
 ```
 :::

exams/finite-automata/index.md

@@ -65,6 +65,7 @@ The particular automaton from  the figure is defined as follows.
    (list 2 3)))
 ```
 
+### accepts
 Implement the function
 ```racket
 (accepts automaton word)
@@ -79,7 +80,8 @@ The function is used as follows:
 > (accepts nfa "abab")
 #f
 ```
-\noindent
+
+### lwords
 
 Next, given the automaton, its alphabet, and a length, generate the list of all words of the given
 length that are accepted by the automaton. Implement the function
@@ -102,12 +104,11 @@ The function operates as follows:
 '("aaa" "aba" "abb")
 ```
 
-For testing purposes your file should be named `task3.rkt` and start with the following lines:
+Your file should be named `automata.rkt` and should export the functions `accepts` and `lwords`, and the structs `transition` and `automaton`:
 ```racket
 #lang racket
 
-(provide accepts
-         lwords)
+(provide accepts lwords (struct-out transition) (struct-out automaton))
 ```
 
 ::: details Exam Solution
@@ -202,7 +203,7 @@ nfa = NFA [Tr 1 'a' 2,
            [2,3]
 ```
 
-### `accepts`-function
+### accepts
 The first part of the task is to decide whether a particular word is accepted by a given automaton.
 To that end, implement the function
 ```haskell
@@ -244,7 +245,7 @@ One more example for `"ba"`:
 So the output is `False`.
 
 
-### `lwords`-function
+### lwords
 
 Next, given the automaton, its alphabet, and a length, generate the list of all words of the given
 length that are accepted by the automaton.  Implement the function
@@ -268,6 +269,16 @@ function operates as follows.
 _**Hint:**_ first, generate all possible words of the given length.  Then, filter the words using
 the function `accepts`.
 
+
+Your file should be named `Automata.hs` and should export the functions `accepts` and `lwords`, and the types `Transition` and `Automaton`:
+```haskell
+module Automata (accepts, lwords, Transition (..), Automaton (..)) where
+
+data Transition a b = Tr a b a deriving Show
+data Automaton a b = NFA [(Transition a b)] a [a] deriving Show
+```
+
+
 ::: details Exam Solution
 ```haskell
 import Control.Monad.State

exams/minesweeper/index.md

@@ -7,7 +7,7 @@ outline: deep
 # Minesweeper
 
 Implement a program to mark the number of mines directy adjacent (horizontally, vertically and
-diagonally) to squares on a Minesweeper field.
+diagonally) to squares on a rectangular Minesweeper field.
 
 
 Fields with `.` denote an empty field and `*` denote mines:
@@ -48,10 +48,6 @@ Your file should be called `minesweeper.rkt`. You may assume the input is rectan
 The functions `string->list` and `string-split` might be useful to parse the output of the function
 `port-lines` which reads from stdin. You can use the following skeleton.
 ```racket
-; for testing
-(define test-board
-  (map string->list (string-split ".*..\n..*.\n**..\n...*\n*...")))
-
 ; for converting ints to chars.
 (define (int->digit i) (integer->char (+ 48 i)))
 
@@ -64,12 +60,16 @@ The functions `string->list` and `string-split` might be useful to parse the out
     (newline)))
 ```
 
+### Example
+
+```racket
+(define board (map string->list (string-split "·*·*·\n··*··\n··*··\n·····")))
+```
+
 ::: details Exam Solution
 ```racket
 #lang racket
 
-(define board (map string->list (string-split "·*·*·\n··*··\n··*··\n·····")))
-
 (define (int->digit i)
   (integer->char (+ 48 i)))
 
@@ -109,34 +109,27 @@ The functions `string->list` and `string-split` might be useful to parse the out
 
 ## Haskell
 
-To read multiple lines of input in plain Haskell, we have to tell it how many lines to read.
-Assume that this will be done by first reading a number and then calling `getLine` the desired
-number of times. Implement a function `readInput :: IO [String]` with the following behaviour
-```haskell
-ghci> readInput
-3
-...
-...
-...
-["...","...","..."]  <-- this is the function output
-```
-
-Your file should have the extension `Minesweeper.hs`.
+Write a Haskell program called `Minesweeper.hs`, which reads the board from standard input. To get all data from standard input as a string, you can call `getContents`. The resulting string can then be split with the `lines` function.
 
 ```haskell
 -- for converting ints to chars
 import Data.Char (intToDigit)
 
+sweep :: [String] -> [String]
+sweep board = board -- implement me !
+
+main = do
+  input <- getContents
+  mapM_ putStrLn (sweep (lines input))
+```
+
+### Example
+
+```haskell
 -- for testing
 test_board = ["..."
              ,".**"
              ,"..."]
-
-main = do
-  lines <- readInput
-  putStrLn "\nSweep Result:"
-  let sw = sweep lines
-  mapM_ putStrLn sw
 ```
 
 ::: details Exam Solution
@@ -165,20 +158,8 @@ sweep board = mapi2d pretty board where
   mines x y = count (neighbours x y board)
   count xs = length $ filter (=='*') xs
 
-readInput :: IO [String]
-readInput = do
-  count <- readLn  -- type is infered because of the signature of replicateM
-  lines <- replicateM (count) getLine
-  return lines
-
-test_board = ["..."
-             ,".**"
-             ,"..."]
-
 main = do
-  lines <- readInput
-  putStrLn "\nSweep Result:"
-  let sw = sweep lines
-  mapM_ putStrLn sw
+  input <- getContents
+  mapM_ putStrLn (sweep (lines input))
 ```
 :::