FP Homework 1 extension - Revision history

Beh01: /* 5 - Ships */

2019-10-30T07:32:52Z

5 - Ships

Beh01: /* 4 - Minesweeper */

2019-10-30T07:22:17Z

4 - Minesweeper

Beh01: /* 4 - Minesweeper */

2019-10-30T07:19:46Z

4 - Minesweeper

Beh01: /* 4 - Minesweeper */

2019-10-29T15:10:01Z

4 - Minesweeper

Beh01: /* 3 - Maze */

2019-10-29T13:57:28Z

3 - Maze

Beh01: /* 2 - Ticktacktoe */

2019-10-29T13:54:48Z

2 - Ticktacktoe

Beh01: /* 2 - Ticktacktoe */

2019-10-29T13:53:04Z

2 - Ticktacktoe

Beh01 at 13:50, 29 October 2019

2019-10-29T13:50:49Z

Beh01 at 13:34, 29 October 2019

2019-10-29T13:34:06Z

Beh01: Created page with "== Basic notes == In all exercises you are required to write something to standard output. You can use the same strategy as in Laboratory 7. Lets def..."

2019-10-29T13:28:39Z

Created page with "== Basic notes == In all exercises you are required to write something to standard output. You can use the same strategy as in Laboratory 7. Lets def..."

New page

== Basic notes ==

In all exercises you are required to write something to standard output. You can use the same strategy as in [[FP_Laboratory_7 | Laboratory 7]].

Lets define a type for the result:
<syntaxhighlight lang="Haskell">type Result = [String]</syntaxhighlight>
Now, if you want to print this result nicely on the screen, you can use:
<syntaxhighlight lang="Haskell">
pp :: Result -> IO ()
pp x = putStr (concat (map (++"\n") x))
</syntaxhighlight>
== 1 - Chess position ==

Implement the function <code>chess</code> which has 2 arguments of the type <code>[String]</code>. Each of these strings in both lists contain 3 characters:
* first stands for chess piece ('K' - king, 'Q' - queen, 'R' - rook, 'B' - bishop, 'N' - knight, 'P' - pawn)
* second stands for column ('a'-'h')
* third is row ('1'-'8')
First list contains actual positions of white pieces and second list positions of black pieces. Print actual state of a chessboard in the way where '.' stands for empty square, capital letters mean white pieces and small letters mean black pieces. Each row and column should be labeled by its number or letter.
<syntaxhighlight lang="Haskell">
chess :: String -> String -> Result
</syntaxhighlight>

<syntaxhighlight lang="Haskell" class="myDark" >
Prelude> pp( chess["Ke1","Ra1","Rh1","Pa2","Be5"] ["Ke8","Ra8","Rh8","Pa7","Qd8","Bc8","Nb8"])
8rnbqk..r
7p.......
6........
5....B...
4........
3........
2P.......
1R...K..R
abcdefgh
</syntaxhighlight>
== 2 - Ticktacktoe ==

Implement the function <code>ticktack</code> which has 2 arguments. First argument is a tuple of natural numbers and defines the number of rows and columns of a play field. Second list contains a record of a match of ticktacktoe game given by coordinates on which played in turns player 'x' and player 'o'. Print actual state of the game in the way where play-field will be bordered by characters '-' and '|', empty squares ' ' and characters 'x' and 'o' will be on squares where the players have played.
<syntaxhighlight lang="Haskell">
ticktack::(Int,Int) -> [(Int,Int)] -> Result
</syntaxhighlight>
<syntaxhighlight lang="Haskell" class="myDark" >
Prelude>pp( ticktack (8,8) [(1,1),(8,8),(2,2,)(3,3)(4,2)(3,2)])
----------
| o|
| |
| |
| |
| |
| o |
| xox |
|x |
----------
</syntaxhighlight>

== 3 - Maze ==

Implement the function <code>maze</code> which has 2 arguments. First argument is a list of strings representing a maze row by row from top to bottom ('*' - wall, ' ' - empty square, 's' - starting position). At the beginning we are at position 's'. Second argument is list of directions ('d' - down, 'u' - up, 'l' - left, 'r' - right). Each letter means move by one square in the given direction and on this new square character '.' is placed. Print actual state of a maze.
<syntaxhighlight lang="Haskell">
maze :: Result -> String -> Result

sampleInput = ["*********",
"*s* * *",
"* * * * *",
"* * * * *",
"* * *",
"******* *",
" *",
"*********"]
</syntaxhighlight>
<syntaxhighlight lang="Haskell" class="myDark" >
Prelude>pp(maze sampleInput "dddrruuurrdddrrddllllll")
*********
*s*...* *
*.*.*.* *
*.*.*.* *
*...*...*
*******.*
.......*
*********
</syntaxhighlight>

== 4 - Minesweeper ==

Implement the function <code>minesweeper</code> which has 1 argument of the type list of strings. The strings represent play field row by row from top to bottom ('*' - mine, ' ' - empty square). Print play field in a way where mines will be represented by '*' and on each square not containing a mine will be a number - count of all mines directly adjacent to this square (it can be adjacent vertically, horizontally or diagonally).
<syntaxhighlight lang="Haskell">
minesweeper :: Result -> Result
sampleInput = [" ",
" * ",
" * ",
" * ",
" *",
"*** ",
"* * ",
"*** "]
</syntaxhighlight>
<syntaxhighlight lang="Haskell" class="myDark" >
Prelude>pp(minesweeper sampleInput)
1110000
1*11110
1122*10
001*221
233211*
***2011
*8*3000
***2000
</syntaxhighlight>

== 5 - Ships ==

Implement the function <code>ships</code> which has 2 arguments. First argument is a list of strings representing play field of one player row by row from top to bottom ('o' - square containing a ship, ' ' - empty square). Second list contains coordinates of squares attacked by second player. Print actual state of a play in the way where every row and column will be labelled by its number or letter, 'o' will be square with ship not attacked yet, 'x' square with ship already attacked, '.' already attacked empty square, ' ' empty square not attacked yet. You can consider that the size of play-field is 10x10.
<syntaxhighlight lang="Haskell">
ships :: Result -> [(Char, Int)] -> Result
sampleInput = [" o o ",
" ooo ",
" oo ",
" ",
" ",
" o ",
" o ",
" o ",
" ",
" ",
" oooo "]
</syntaxhighlight>
<syntaxhighlight lang="Haskell" class="myDark" >
Prelude>pp(ships sampleInput [('a',1),('d',1),('d',2),('c',1),('b',1),('e',1),('f',1),('g',1),('c',7),('c',10)])
10 x o
9 ooo
8 oo
7 .
6
5 o
4 o
4 o
3
2 .
1..xxxx.
abcdefghij
</syntaxhighlight>

@@ Line 42: / Line 42: @@
 <syntaxhighlight lang="Haskell">
 minesweeper :: Result -> Result
-sampleInput = ["       ",
+sampleInput = ["1110000",
-                " *     ",
+                "1*11110",
-                "    *  ",
+                "1122*10",
-                "   *   ",
+                "001*221",
-                "      *",
+                "233211*",
-                "***    ",
+                "***2011",
-                "* *    ",
+                "*8*3000",
-                "***    "]
+                "***2000"]
 </syntaxhighlight>
 <syntaxhighlight lang="Haskell" class="myDark" >
-Prelude>pp( makeMove (minesweeper sampleInput) (0,7))
+Prelude>pp(makeMove sampleInput (0,7))
 ..10000
 ..11110

@@ Line 39: / Line 39: @@
 Implement the function <code>makeMove</code> which has 2 argument. First is <code>Result</code>. It will be a result from the function <code>minesweeper</code>.
-Second argument will be pair <code>(row,column)</code>, it will represent a position where player 'clicked'. The result will be a playground where just a part of the play-ground will be visible. The character <code>.</code> detonates a hidden field (initially all fields are hidden).
+Second argument will be pair <code>(row,column)</code>, it will represent a position where player 'clicked'. The result will be a playground where just a part of the play-ground will be visible. The character <code>.</code> detonates a hidden field (initially all fields are hidden). If player clicked in a mine, you can output the input. If he clicked on a number different then zero, just the number will be visible. If it is a zero, then the whole consecutive area of zeroes along with bordering numbers will be visible.
 <syntaxhighlight lang="Haskell">
 minesweeper :: Result -> Result
@@ Line 54: / Line 54: @@
 Prelude>pp( makeMove (minesweeper sampleInput) (0,7))
 ..10000
-*11110
+..11110
-*10
+.....10
-*221
+.....21
-*
+.......
-***2011
+.......
-*8*3000
+.......
-***2000
+.......
 </syntaxhighlight>

@@ Line 11: / Line 11: @@
 == 2 - Ticktacktoe ==
-Implement the function <code>winner</code> which has 1 argument - play-filed. It will return <code>Bool</code> indicating that on of the player have more then 4 pieces in a row, column or diagonally.
+Implement the function <code>winner</code> which has 2 arguments, the same description of a play-filed as before. It will return <code>Bool</code> indicating that one of the players have more then 4 pieces in a row, column or diagonally.
 <syntaxhighlight lang="Haskell">
-winner:: Result ->
+winner:: (Int,Int) -> [(Int,Int)] -> Bool
 </syntaxhighlight>
 <syntaxhighlight lang="Haskell" class="myDark" >

@@ Line 2: / Line 2: @@
 == 1 - Chess position ==
-Implement the function <code>move</code> which has 2 arguments of the type <code>Result</code> (position A and position B). Function result type is  <code>Bool</code>, It is <code>True<code> if it is possible with one chess piece move get from position A to B, <code>false</code> otherwise.
+Implement the function <code>move</code> which has 2 arguments of the type <code>Result</code> (position A and position B). Function result type is  <code>Bool</code>, It is <code>True</code> if it is possible with one chess piece move get from position A to B, <code>false</code> otherwise.
 <syntaxhighlight lang="Haskell">
 move :: Result-> Result -> Bool

@@ Line 65: / Line 65: @@
 == 5 - Ships ==
-Implement the function <code>ships</code> which has 2 arguments. First argument is a list of strings representing play field of one player row by row from top to bottom ('o' - square containing a ship, ' ' - empty square). Second list contains coordinates of squares attacked by second player. Print actual state of a play in the way where every row and column will be labelled by its number or letter, 'o' will be square with ship not attacked yet, 'x' square with ship already attacked, '.' already attacked empty square, ' ' empty square not attacked yet. You can consider that the size of play-field is 10x10.
+Implement the function <code>checkOverlap</code> which has 2 arguments. First is a pair <code>(columns, rows)</code> which defines size of the playground. Second argument is a list of list containing coordinates of squares taken by ships. Each of the inner lists represents one ship. Ship is defined as a set of coordinates <code>(column, row)</code>, where column is given using small English alphabet. You can consider that the size of play-field will be smaller then 25x25. Output <code>Bool</code> indicating that the game description is valid. It is valid when no ships overlap or touch each other.
 <syntaxhighlight lang="Haskell">
-ships :: Result -> [(Char, Int)] -> Result
+checkOverlap:: -> (Int, Int) -> [[(Char, Int)]] -> Bool
 </syntaxhighlight>
 <syntaxhighlight lang="Haskell" class="myDark" >
 </syntaxhighlight>

@@ Line 20: / Line 20: @@
 == 3 - Maze ==
-Implement the function <code>maze</code> which has 2 arguments. First argument is a list of strings representing a maze row by row from top to bottom ('*' - wall, ' ' - empty square, 's' - starting position). At the beginning we are at position 's'. Second argument is list of directions ('d' - down, 'u' - up, 'l' - left, 'r' - right). Each letter means move by one square in the given direction and on this new square character '.' is placed. Print actual state of a maze.
+Implement the function <code>length</code> which has 2 arguments. First argument is a list of strings representing a maze row by row from top to bottom ('*' - wall, ' ' - empty square, 's' - starting position). At the beginning we are at position 's'. Second argument is a position in the maze. Find the length of a shortest path from start to this position.
 <syntaxhighlight lang="Haskell">
-maze :: Result -> String -> Result
+length :: Result -> (Int,Int) -> Int
 sampleInput = ["*********",
@@ Line 34: / Line 34: @@
 </syntaxhighlight>
 <syntaxhighlight lang="Haskell" class="myDark" >
 </syntaxhighlight>