Chessboard (exercism#835)

* Chessboard concept exercise

* moved solution to exemplar.jl

* Update chessboard.jl

Added new line to function skeletons

* Update introduction.md

Syncing with concept introduction.md

* Update instructions.md

Good catch! That was sloppy copy-paste from another language track.

* Update design.md

Nothing comes to mind at this stage, so I've removed that subsection. We may want to add it back later, when we get a better view of the advanced topics.

Luckily, the rules are non-prescriptive about the contends of this file. It's just a note to guide future maintainers.

* Update config.json

---------

Co-authored-by: Colin Leach <[email protected]>
Co-authored-by: depial <[email protected]>

Author: 3 people

config.json

@@ -56,6 +56,18 @@
         ],
         "status": "wip"
       },
+      {
+        "slug": "chessboard",
+        "name": "chessboard",
+        "uuid": "48977bc8-36e7-41be-8fd5-99c49de00f20",
+        "concepts": [
+          "ranges"
+        ],
+        "prerequisites": [
+          "vectors"
+        ],
+        "status": "wip"
+      },
       {
         "slug": "currency-exchange",
         "name": "currency-exchange",

exercises/concept/chessboard/.docs/hints.md

@@ -0,0 +1,22 @@
+# Hints
+
+This is a short and simple exercise, so it is best to avoid complicating it.
+
+## 1. Define the rank range
+
+- You need to return a range of integers
+
+## 2. Define the file range
+
+- You need to return a range of uppercase characters.
+- Characters use single-quotes, such as `'W'`,
+
+## 3. Transform the rank range into a list of ranks
+
+- The [`collect()`][collect] function is your friend here.
+
+## 4. Transform the file range into a list of files
+
+- See task 3.
+
+[collect]: https://docs.julialang.org/en/v1/base/collections/#Base.collect-Tuple{Any}

exercises/concept/chessboard/.docs/instructions.md

@@ -0,0 +1,46 @@
+# Instructions
+
+As a chess enthusiast, you would like to write your own version of the game. Yes, there maybe plenty of implementations of chess available online already, but yours will be unique!
+
+But before you can let your imagination run wild, you need to take care of the basics. Let's start by generating the board.
+
+Each square of the chessboard is identified by a letter-number pair. The vertical columns of squares, called files, are labeled A through H. The horizontal rows of squares, called ranks, are numbered 1 to 8.
+
+## 1. Define the rank range
+
+Implement the `rank_range()` function. It should return a range of integers, from 1 to 8.
+
+```julia-repl
+julia> rank_range()
+# output omitted
+```
+
+## 2. Define the file range
+
+Implement the `file_range()` function. 
+It should return a range of integers, from the uppercase letter A, to the uppercase letter H.
+
+```julia-repl
+julia> file_range()
+# output omitted
+```
+
+## 3. Transform the rank range into a vector of ranks
+
+Implement the `ranks()` function. It should return a vector of integers, from 1 to 8. 
+Do not write the vector by hand, generate it from the range returned by the `rank_range()` function.
+
+```julia-repl
+julia> ranks()
+[1, 2, 3, 4, 5, 6, 7, 8]
+```
+
+## 4. Transform the file range into a vector of files
+
+Implement the `files` function. It should return a vector of characters, from 'A' to 'H'. 
+Do not write the vector by hand, generate it from the range returned by the `file_range()` function.
+
+```julia-repl
+julia> files()
+['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
+```

exercises/concept/chessboard/.docs/introduction.md

@@ -0,0 +1,90 @@
+# Introduction
+
+Suppose you want all the non-negative integers up to 1000.
+It would be ridiculous if you had to type these into an array.
+
+For this we have the `range` type:
+
+```julia-repl
+julia> 0:1000
+0:1000
+
+julia> typeof(0:1000)
+UnitRange{Int64}
+```
+
+Ranges are very common: not just to save you typing, but also as return types from functions.
+
+Note that ranges are _not_ vectors.
+They are just a set of instructions to generate a sequence ("lazy" evaluation, or an "iterator").
+
+If you need a range as a vector, use the `collect()` function for conversion:
+
+```julia-repl
+julia> collect(0:5)
+6-element Vector{Int64}:
+ 0
+ 1
+ 2
+ 3
+ 4
+ 5
+```
+
+The step size can be specified, in this case 0.3:
+
+```julia-repl
+julia>  collect(1.0:0.3:2.0)
+4-element Vector{Float64}:
+ 1.0
+ 1.3
+ 1.6
+ 1.9
+```
+
+So the syntax is `start:stepsize:stop`.
+Both end limits are _inclusive_, as seen in the integer example.
+If the step size does not divide exactly into `stop - start`, the last element will avoid exceeding `stop`.
+
+## Letter ranges
+
+Non-numeric sequences can also be used in ranges.
+The simplest example is ASCII letters:
+
+```julia-repl
+julia> 'a':'d'
+'a':1:'d'
+
+julia> typeof('a':'d')
+StepRange{Char, Int64}
+
+julia> collect('a':'d')
+4-element Vector{Char}:
+ 'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)
+ 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
+ 'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)
+ 'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase)
+```
+
+The `Char` type will be covered in more detail in another Concept.
+For now, just treat these as single characters in single-quotes.
+
+## Functions and operators for ranges
+
+Check the limits of a range with `first()` and `last()`.
+
+```julia
+ r = 1:10  # => 1:10
+ first(r)  # => 1
+ last(r)   # => 10
+```
+
+## More on vector indexing
+
+Integer ranges and vectors can be used in vector indexing:
+
+```julia
+nums = collect(10.0:50.0)
+nums[3:2:7]  # gives [12.0, 14.0, 16.0]
+nums[ [3, 5, 7] ] # also gives [12.0, 14.0, 16.0]
+```

exercises/concept/chessboard/.meta/config.json

@@ -0,0 +1,20 @@
+{
+  "authors": [
+    "colinleach"
+  ],
+  "files": {
+    "solution": [
+      "chessboard.jl"
+    ],
+    "test": [
+      "runtests.jl"
+    ],
+    "exemplar": [
+      ".meta/exemplar.jl"
+    ]
+  },
+  "forked_from": [
+    "elixir/chessboard"
+  ],
+  "blurb": "Learn about ranges by building a chessboard."
+}

exercises/concept/chessboard/.meta/design.md

@@ -0,0 +1,17 @@
+# Design
+
+## Learning objectives
+
+- Know about ranges.
+  - They are structs.
+  - They are enumerable.
+  - How to transform them to a list.
+  - How to generate a list of letters from a range.
+
+## Prerequisites
+
+- `vectors`
+
+## Concepts
+
+- `ranges`

exercises/concept/chessboard/.meta/exemplar.jl

@@ -0,0 +1,7 @@
+rank_range() = 1:8
+
+file_range() = 'A':'H'
+
+ranks() = collect(rank_range())
+
+files() = collect(file_range())

exercises/concept/chessboard/chessboard.jl

@@ -0,0 +1,15 @@
+function rank_range()
+    
+end
+
+function file_range()
+    
+end
+
+function ranks()
+    
+end
+
+function files()
+    
+end

exercises/concept/chessboard/runtests.jl

@@ -0,0 +1,31 @@
+using Test
+
+include("chessboard.jl")
+
+@testset verbose = true "tests" begin
+
+    @testset "rank_range is a range from 1 to 8" begin
+        result = rank_range()
+        @test first(result) == 1
+        @test last(result) == 8
+        @test length(result) == 8
+        @test typeof(result) == UnitRange{Int}
+    end
+
+    @testset "file_range is a range from 'A' to 'H'" begin
+        result = file_range()
+        @test first(result) == 'A'
+        @test last(result) == 'H'
+        @test length(result) == 8
+        @test typeof(result) == StepRange{Char, Int}
+    end
+
+    @testset "ranks is a vector of integers from 1 to 8" begin
+        @test ranks() == [1, 2, 3, 4, 5, 6, 7, 8]
+    end
+
+    @testset "files is a vector of characters from 'A' to 'H'" begin
+        @test ranks() == [1, 2, 3, 4, 5, 6, 7, 8]
+    end
+
+end