trackler 2.2.1.68 → 2.2.1.69

data/tracks/fsharp/exercises/diamond/DiamondTest.fs

@@ -2,124 +2,121 @@ module DiamondTest
 
 open Diamond
 open System
-open Xunit
 open FsUnit.Xunit
+open Xunit
+open FsCheck
+open FsCheck.Xunit
 
-type DiamondTest() =
-    let split (x: string) = x.Split([| '\n' |], StringSplitOptions.None)
+let split (x: string) = x.Split([| '\n' |], StringSplitOptions.None)
 
-    let trim (x:string) = x.Trim()
+let trim (x:string) = x.Trim()
 
-    let leadingSpaces (x:string) = x.Substring(0, x.IndexOfAny [|'A'..'Z'|])
+let leadingSpaces (x:string) = x.Substring(0, x.IndexOfAny [|'A'..'Z'|])
 
-    let trailingSpaces (x:string) = x.Substring(x.LastIndexOfAny [|'A'..'Z'|] + 1)
-    
-    [<Theory>]
-    [<MemberData("Letters")>]
-    member this.``First row contains 'A'`` (letter:char) =
-        let actual = make letter
-        let rows = actual |> split
-        let firstRowCharacters = rows |> Seq.head |> trim
+let trailingSpaces (x:string) = x.Substring(x.LastIndexOfAny [|'A'..'Z'|] + 1)
+
+type Letters =
+    static member Chars () =
+        Arb.Default.Char()
+        |> Arb.filter (fun c -> 'A' <= c && c <= 'Z')
+
+type DiamondPropertyAttribute () =
+    inherit PropertyAttribute(Arbitrary = [| typeof<Letters> |])
+
+[<DiamondProperty>]
+let ``First row contains 'A'`` (letter:char) =
+    let actual = make letter
+    let rows = actual |> split
+    let firstRowCharacters = rows |> Seq.head |> trim
+
+    firstRowCharacters |> should equal "A"
+
+[<DiamondProperty(Skip = "Remove to run test")>]
+let ``All rows must have symmetric contour`` (letter:char) =
+    let actual = make letter
+    let rows = actual |> split
+    let symmetric (row:string) = leadingSpaces row = trailingSpaces row
+
+    rows |> Array.iter (fun x -> symmetric x |> should equal true)
+
+[<DiamondProperty(Skip = "Remove to run test")>]
+let ``Top of figure has letters in correct order`` (letter:char) =
+    let actual = make letter
+
+    let expected = ['A'..letter]
+    let rows = actual |> split
+    let firstNonSpaceLetters =
+        rows 
+        |> Seq.take expected.Length
+        |> Seq.map (trim >> Seq.head)
+        |> Seq.toList
+
+    expected |> should equal firstNonSpaceLetters
+
+[<DiamondProperty(Skip = "Remove to run test")>]
+let ``Figure is symmetric around the horizontal axis`` (letter:char) =
+    let actual = make letter
+
+    let rows = actual |> split
+    let top = 
+        rows
+        |> Seq.takeWhile (fun x -> not (x.Contains(string letter)))
+        |> List.ofSeq
     
-        firstRowCharacters |> should equal "A"
-
-    [<Theory(Skip = "Remove to run test")>]
-    [<MemberData("Letters")>]
-    member this.``All rows must have symmetric contour`` (letter:char) =
-        let actual = make letter
-        let rows = actual |> split
-        let symmetric (row:string) = leadingSpaces row = trailingSpaces row
-
-        rows |> Array.iter (fun x -> symmetric x |> should equal true)
-
-    [<Theory(Skip = "Remove to run test")>]
-    [<MemberData("Letters")>]
-    member this.``Top of figure has letters in correct order`` (letter:char) =
-        let actual = make letter
-
-        let expected = ['A'..letter]
-        let rows = actual |> split
-        let firstNonSpaceLetters =
-            rows 
-            |> Seq.take expected.Length
-            |> Seq.map (trim >> Seq.head)
-            |> Seq.toList
-
-        expected |> should equal firstNonSpaceLetters
-
-    [<Theory(Skip = "Remove to run test")>]
-    [<MemberData("Letters")>]
-    member this.``Figure is symmetric around the horizontal axis`` (letter:char) =
-        let actual = make letter
-
-        let rows = actual |> split
-        let top = 
-            rows
-            |> Seq.takeWhile (fun x -> not (x.Contains(string letter)))
-            |> List.ofSeq
-        
-        let bottom = 
-            rows 
-            |> Array.rev
-            |> Seq.takeWhile (fun x -> not (x.Contains(string letter)))
-            |> List.ofSeq
-
-        top |> should equal bottom
+    let bottom = 
+        rows 
+        |> Array.rev
+        |> Seq.takeWhile (fun x -> not (x.Contains(string letter)))
+        |> List.ofSeq
+
+    top |> should equal bottom
+
+[<DiamondProperty(Skip = "Remove to run test")>]
+let ``Diamond has square shape`` (letter:char) =
+    let actual = make letter
+
+    let rows = actual |> split
+    let expected = rows.Length
+    let correctWidth (x:string) = x.Length = expected
+
+    rows |> Array.iter (fun x -> correctWidth x |> should equal true)
+
+[<DiamondProperty(Skip = "Remove to run test")>]
+let ``All rows except top and bottom have two identical letters`` (letter:char) =
+    let actual = make letter
+
+    let rows = 
+        actual 
+        |> split 
+        |> Array.filter (fun x -> not (x.Contains("A")))
+
+    let twoIdenticalLetters (row:string) = 
+        let twoCharacters = row.Replace(" ", "").Length = 2
+        let identicalCharacters = row.Replace(" ", "") |> Seq.distinct |> Seq.length = 1
+        twoCharacters && identicalCharacters
+
+    rows |> Array.iter (fun x -> twoIdenticalLetters x |> should equal true)
+
+[<DiamondProperty(Skip = "Remove to run test")>]
+let ``Bottom left corner spaces are triangle`` (letter:char) =
+    let actual = make letter
+
+    let rows = actual |> split
     
-    [<Theory(Skip = "Remove to run test")>]
-    [<MemberData("Letters")>]
-    member this.``Diamond has square shape`` (letter:char) =
-        let actual = make letter
-
-        let rows = actual |> split
-        let expected = rows.Length
-        let correctWidth (x:string) = x.Length = expected
-
-        rows |> Array.iter (fun x -> correctWidth x |> should equal true)
-
-    [<Theory(Skip = "Remove to run test")>]
-    [<MemberData("Letters")>]
-    member this.``All rows except top and bottom have two identical letters`` (letter:char) =
-        let actual = make letter
-
-        let rows = 
-            actual 
-            |> split 
-            |> Array.filter (fun x -> not (x.Contains("A")))
-
-        let twoIdenticalLetters (row:string) = 
-            let twoCharacters = row.Replace(" ", "").Length = 2
-            let identicalCharacters = row.Replace(" ", "") |> Seq.distinct |> Seq.length = 1
-            twoCharacters && identicalCharacters
-
-        rows |> Array.iter (fun x -> twoIdenticalLetters x |> should equal true)
-
-    [<Theory(Skip = "Remove to run test")>]
-    [<MemberData("Letters")>]
-    member this.``Bottom left corner spaces are triangle`` (letter:char) =
-        let actual = make letter
-
-        let rows = actual |> split
-        
-        let cornerSpaces = 
-            rows 
-            |> Array.rev
-            |> Seq.skipWhile (fun x -> not (x.Contains(string letter)))
-            |> Seq.map leadingSpaces
-            |> Seq.toList
-
-        let spaceCounts = 
-            cornerSpaces 
-            |> List.map (fun x -> x.Length)
-
-        let expected = 
-            Seq.initInfinite id
-            |> Seq.take spaceCounts.Length
-            |> Seq.toList
-
-        spaceCounts |> should equal expected
-
-    static member Letters = 
-        let theoryData = new TheoryData<char>()
-        [ 'A' .. 'Z' ] |> List.iter (fun c -> theoryData.Add(c))
-        theoryData
+    let cornerSpaces = 
+        rows 
+        |> Array.rev
+        |> Seq.skipWhile (fun x -> not (x.Contains(string letter)))
+        |> Seq.map leadingSpaces
+        |> Seq.toList
+
+    let spaceCounts = 
+        cornerSpaces 
+        |> List.map (fun x -> x.Length)
+
+    let expected = 
+        Seq.initInfinite id
+        |> Seq.take spaceCounts.Length
+        |> Seq.toList
+
+    spaceCounts |> should equal expected

data/tracks/fsharp/exercises/diamond/README.md

@@ -53,7 +53,8 @@ E·······E
 ```
 
 ## Hints
-- Testing this one can be tricky without simply hardcoding a bunch of inputs and outputs. [Property based testing](https://fsharpforfunandprofit.com/posts/property-based-testing/) is another way to think about testing that allows you to more easily test this type of algorithm.
+- Testing this one can be tricky without simply hardcoding a bunch of inputs and outputs. [Property based testing](https://fsharpforfunandprofit.com/posts/property-based-testing/) is another way to think about testing that allows you to more easily test this type of algorithm. The test suite uses the [FsCheck](https://fscheck.github.io/FsCheck/) property-based testing framework to define the tests.
+
 ## Source
 
 Seb Rose [http://claysnow.co.uk/recycling-tests-in-tdd/](http://claysnow.co.uk/recycling-tests-in-tdd/)

data/tracks/fsharp/exercises/dominoes/README.md

@@ -1,14 +1,11 @@
 # Dominoes
 
-Make a chain of dominoes.
-
-Compute a way to order a given set of dominoes in such a way that they form a
+Compute whether there exists a way to order a given set of dominoes in such a way that they form a
 correct domino chain (the dots on one half of a stone match the dots on the
 neighbouring half of an adjacent stone) and that dots on the halfs of the stones
 which don't have a neighbour (the first and last stone) match each other.
 
-For example given the stones `21`, `23` and `13` you should compute something
-like `12 23 31` or `32 21 13` or `13 32 21` etc, where the first and last numbers are the same.
+For example given the stones `21`, `23` and `13` you should declare that there exists a possible chain (for example, `12`, `23` and `31` is a possible chain).
 
 For stones 12, 41 and 23 the resulting chain is not valid: 41 12 23's first and last numbers are not the same. 4 != 3
 

data/tracks/fsharp/exercises/palindrome-products/Example.fs

@@ -1,4 +1,4 @@
-module Palindrome
+module PalindromeProducts
 
 let isPalindrome n = 
     let mutable current = n
@@ -10,24 +10,32 @@ let isPalindrome n =
     result = n
 
 let palindrome predicate minFactor maxFactor = 
-    let allPalindromes = 
-        [for y in minFactor..maxFactor do
-             for x in minFactor ..y do
-                 if isPalindrome (x * y) then
-                    yield x * y, (x, y)]
+    if minFactor > maxFactor then
+        None
+    else
+        let allPalindromes = 
+            [for y in minFactor..maxFactor do
+                 for x in minFactor ..y do
+                     if isPalindrome (x * y) then
+                        yield x * y, (x, y)]
 
-    let value = 
-        allPalindromes 
-        |> List.map fst 
-        |> predicate
-    
-    let factors = 
-        allPalindromes 
-        |> List.filter (fun x -> fst x = value) 
-        |> List.map snd 
-        |> List.sort
+        match List.isEmpty allPalindromes with
+        | true -> 
+            None
+        | false ->
+            let value = 
+                allPalindromes 
+                |> List.map fst 
+                |> predicate
+            
+            let factors = 
+                allPalindromes 
+                |> List.filter (fun x -> fst x = value) 
+                |> List.map snd 
+                |> List.sort
 
-    (value, factors)
+            Some (value, factors)
 
-let largestPalindrome minFactor maxFactor = palindrome List.max minFactor maxFactor
-let smallestPalindrome minFactor maxFactor = palindrome List.min minFactor maxFactor
+let largest minFactor maxFactor = palindrome List.max minFactor maxFactor
+
+let smallest minFactor maxFactor = palindrome List.min minFactor maxFactor

data/tracks/fsharp/exercises/palindrome-products/PalindromeProducts.fs

@@ -1,5 +1,5 @@
-module Palindrome
+module PalindromeProducts
 
-let largestPalindrome minFactor maxFactor = failwith "You need to implement this function."
+let largest minFactor maxFactor = failwith "You need to implement this function."
 
-let smallestPalindrome minFactor maxFactor = failwith "You need to implement this function."
+let smallest minFactor maxFactor = failwith "You need to implement this function."

data/tracks/fsharp/exercises/palindrome-products/PalindromeProductsTest.fs

@@ -1,54 +1,57 @@
-module PalindromeTest
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
+module PalindromeProductsTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
-open Palindrome
+open PalindromeProducts
 
 [<Fact>]
-let ``Largest palindrome from single digit factors`` () =
-    let (largest, factors) = largestPalindrome 1 9
-    largest |> should equal 9
-    factors |> should equal [(1, 9); (3, 3)]
-    
-[<Fact(Skip = "Remove to run test")>]
-let ``Smallest palindrome from single digit factors`` () =
-    let (smallest, factors) = smallestPalindrome 1 9
-    smallest |> should equal 1
-    factors |> should equal [(1, 1)]
-    
-[<Fact(Skip = "Remove to run test")>]
-let ``Largest palindrome from double digit actors`` () =
-    let (largest, factors) = largestPalindrome 10 99
-    largest |> should equal 9009
-    factors |> should equal [(91, 99)]
-    
-[<Fact(Skip = "Remove to run test")>]
-let ``Smallest palindrome from double digit factors`` () =
-    let (smallest, factors) = smallestPalindrome 10 99
-    smallest |> should equal 121
-    factors |> should equal [(11, 11)]
-    
-[<Fact(Skip = "Remove to run test")>]
-let ``Largest palindrome from triple digit factors`` () =
-    let (largest, factors) = largestPalindrome 100 999
-    largest |> should equal 906609
-    factors |> should equal [(913, 993)]
-    
-[<Fact(Skip = "Remove to run test")>]
-let ``Smallest palindrome from triple digit factors`` () =
-    let (smallest, factors) = smallestPalindrome 100 999
-    smallest |> should equal 10201
-    factors |> should equal [(101, 101)]
-    
-[<Fact(Skip = "Remove to run test")>]
-let ``Largest palindrome from four digit factors`` () =
-    let (largest, factors) = largestPalindrome 1000 9999
-    largest |> should equal 99000099
-    factors |> should equal [(9901, 9999)]
-    
-[<Fact(Skip = "Remove to run test")>]
-let ``Smallest palindrome from four digit factors`` () =
-    let (smallest, factors) = smallestPalindrome 1000 9999
-    smallest |> should equal 1002001
-    factors |> should equal [(1001, 1001)]
+let ``Finds the smallest palindrome from single digit factors`` () =
+    smallest 1 9 |> should equal (Some (1, [(1, 1)]))
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Finds the largest palindrome from single digit factors`` () =
+    largest 1 9 |> should equal (Some (9, [(1, 9); (3, 3)]))
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Find the smallest palindrome from double digit factors`` () =
+    smallest 10 99 |> should equal (Some (121, [(11, 11)]))
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Find the largest palindrome from double digit factors`` () =
+    largest 10 99 |> should equal (Some (9009, [(91, 99)]))
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Find smallest palindrome from triple digit factors`` () =
+    smallest 100 999 |> should equal (Some (10201, [(101, 101)]))
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Find the largest palindrome from triple digit factors`` () =
+    largest 100 999 |> should equal (Some (906609, [(913, 993)]))
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Find smallest palindrome from four digit factors`` () =
+    smallest 1000 9999 |> should equal (Some (1002001, [(1001, 1001)]))
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Find the largest palindrome from four digit factors`` () =
+    largest 1000 9999 |> should equal (Some (99000099, [(9901, 9999)]))
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Empty result for smallest if no palindrome in the range`` () =
+    smallest 1002 1003 |> should equal None
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Empty result for largest if no palindrome in the range`` () =
+    largest 15 15 |> should equal None
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Error result for smallest if min is more than max`` () =
+    smallest 10000 1 |> should equal None
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Error result for largest if min is more than max`` () =
+    largest 2 1 |> should equal None
+

data/tracks/fsharp/exercises/reverse-string/ReverseStringTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.0.0 of the canonical data.
+// This file was auto-generated based on version 1.0.1 of the canonical data.
 
 module ReverseStringTest
 
@@ -8,7 +8,7 @@ open Xunit
 open ReverseString
 
 [<Fact>]
-let ``Empty string`` () =
+let ``An empty string`` () =
     reverse "" |> should equal ""
 
 [<Fact(Skip = "Remove to run test")>]

data/tracks/fsharp/exercises/spiral-matrix/Example.fs

@@ -0,0 +1,35 @@
+module SpiralMatrix
+ 
+let array2DToList array = 
+  [ for x in Array2D.base1 array .. Array2D.length1 array - 1 ->
+    [ for y in Array2D.base2 array .. Array2D.length2 array - 1 -> array.[x, y] ] ]  
+
+let spiralMatrix size = 
+    let numbersToPlace = size * size
+
+    let mutable spiral = Array2D.create size size 0
+    let mutable currentSpiralValue = 1
+    let mutable firstPivot = 0
+    let mutable secondPivot = size - 1
+
+    let setValue x y = 
+        spiral.[x, y] <- currentSpiralValue
+        currentSpiralValue <- currentSpiralValue + 1
+
+    while currentSpiralValue <= numbersToPlace do
+        [firstPivot .. secondPivot] 
+        |> List.iter (fun i -> setValue firstPivot i)
+
+        [firstPivot + 1.. secondPivot] 
+        |> List.iter (fun i -> setValue i secondPivot)
+
+        [secondPivot - 1 .. -1 .. firstPivot] 
+        |> List.iter (fun i -> setValue secondPivot i)
+
+        [secondPivot - 1 .. -1 .. firstPivot + 1] 
+        |> List.iter (fun i -> setValue i firstPivot)
+
+        firstPivot <- firstPivot + 1
+        secondPivot <- secondPivot - 1
+
+    array2DToList spiral

data/tracks/fsharp/exercises/spiral-matrix/Program.fs

@@ -0,0 +1 @@
+module Program = let [<EntryPoint>] main _ = 0

data/tracks/fsharp/exercises/spiral-matrix/README.md

@@ -0,0 +1,25 @@
+Given the size, return a square matrix of numbers in spiral order.
+
+The matrix should be filled with natural numbers, starting from 1
+in the top-left corner, increasing in an inward, clockwise spiral order,
+like these examples:
+
+###### Spiral matrix of size 3
+
+```text
+1 2 3
+8 9 4
+7 6 5
+```
+
+###### Spiral matrix of size 4
+
+```text
+ 1  2  3 4
+12 13 14 5
+11 16 15 6
+10  9  8 7
+```
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/fsharp/exercises/spiral-matrix/SpiralMatrix.fs

@@ -0,0 +1,3 @@
+module SpiralMatrix
+
+let spiralMatrix size = failwith "You need to implement this function."

data/tracks/fsharp/exercises/spiral-matrix/SpiralMatrix.fsproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="SpiralMatrix.fs" />
+    <Compile Include="SpiralMatrixTest.fs" />
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" />
+    <PackageReference Include="xunit" Version="2.3.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
+    <PackageReference Include="FsUnit.xUnit" Version="3.0.0" />
+    <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.1" />
+  </ItemGroup>
+
+</Project>

data/tracks/fsharp/exercises/spiral-matrix/SpiralMatrixTest.fs

@@ -0,0 +1,47 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
+module SpiralMatrixTest
+
+open FsUnit.Xunit
+open Xunit
+
+open SpiralMatrix
+
+[<Fact>]
+let ``Empty spiral`` () =
+    spiralMatrix 0 |> should be Empty
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Trivial spiral`` () =
+    spiralMatrix 1 |> should equal [[1]]
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Spiral of size 2`` () =
+    spiralMatrix 2 |> should equal 
+        [ [1; 2];
+          [4; 3] ]
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Spiral of size 3`` () =
+    spiralMatrix 3 |> should equal 
+        [ [1; 2; 3];
+          [8; 9; 4];
+          [7; 6; 5] ]
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Spiral of size 4`` () =
+    spiralMatrix 4 |> should equal 
+        [ [1; 2; 3; 4];
+          [12; 13; 14; 5];
+          [11; 16; 15; 6];
+          [10; 9; 8; 7] ]
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Spiral of size 5`` () =
+    spiralMatrix 5 |> should equal 
+        [ [1; 2; 3; 4; 5];
+          [16; 17; 18; 19; 6];
+          [15; 24; 25; 20; 7];
+          [14; 23; 22; 21; 8];
+          [13; 12; 11; 10; 9] ]
+