trackler 2.2.1.46 → 2.2.1.47

data/tracks/fsharp/exercises/grains/Example.fs

@@ -2,5 +2,13 @@
 
 open System.Numerics
 
-let square (n:int) = 2I ** (n - 1)
-let total = [1..64] |> List.sumBy square
+let square (n:int) = 
+    if n <= 0 || n > 64 then 
+        Error "Invalid input"
+    else
+        Ok (2I ** (n - 1) |> uint64)
+
+let total = 
+    [1..64] 
+    |> List.map square
+    |> List.reduce (fun x y -> match x, y with Ok a, Ok b -> Ok (a + b) | _ -> Error "Invalid input")

data/tracks/fsharp/exercises/grains/Grains.fs

@@ -1,6 +1,4 @@
 module Grains
 
-open System.Numerics
-
-let square (n: int): BigInteger = failwith "You need to implement this function."
-let total: BigInteger = failwith "You need to implement this function."
+let square (n: int): Result<uint64,string> = failwith "You need to implement this function."
+let total: Result<uint64,string> = failwith "You need to implement this function."

data/tracks/fsharp/exercises/grains/GrainsTest.fs

@@ -1,37 +1,64 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 module GrainsTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
+
 open Grains
-    
+
 [<Fact>]
-let ``Test square 1`` () = 
-    square 1 |> should equal 1I
-    
+let ``Returns the total number of grains on the board`` () =
+    let expected: Result<uint64,string> = Ok 18446744073709551615UL
+    total |> should equal expected
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Test square 2`` () = 
-    square 2 |> should equal 2I
-    
+let ``1`` () =
+    let expected: Result<uint64,string> = Ok 1UL
+    square 1 |> should equal expected
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Test square 3`` () = 
-    square 3 |> should equal 4I
-    
+let ``2`` () =
+    let expected: Result<uint64,string> = Ok 2UL
+    square 2 |> should equal expected
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Test square 4`` () = 
-    square 4 |> should equal 8I
-    
+let ``3`` () =
+    let expected: Result<uint64,string> = Ok 4UL
+    square 3 |> should equal expected
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Test square 16`` () = 
-    square 16 |> should equal 32768I
-    
+let ``4`` () =
+    let expected: Result<uint64,string> = Ok 8UL
+    square 4 |> should equal expected
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Test square 32`` () = 
-    square 32 |> should equal 2147483648I
-    
+let ``16`` () =
+    let expected: Result<uint64,string> = Ok 32768UL
+    square 16 |> should equal expected
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Test square 64`` () = 
-    square 64 |> should equal 9223372036854775808I
-    
+let ``32`` () =
+    let expected: Result<uint64,string> = Ok 2147483648UL
+    square 32 |> should equal expected
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Test total grains`` () = 
-    total |> should equal 18446744073709551615I
+let ``64`` () =
+    let expected: Result<uint64,string> = Ok 9223372036854775808UL
+    square 64 |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Square 0 raises an exception`` () =
+    let expected: Result<uint64,string> = Error "Invalid input"
+    square 0 |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Negative square raises an exception`` () =
+    let expected: Result<uint64,string> = Error "Invalid input"
+    square -1 |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Square greater than 64 raises an exception`` () =
+    let expected: Result<uint64,string> = Error "Invalid input"
+    square 65 |> should equal expected
+

data/tracks/fsharp/exercises/phone-number/Example.fs

@@ -2,10 +2,18 @@
 
 open System
 
-let parsePhoneNumber (input: string) = 
+let private validate (input: string) =
+    let isStartDigit digit = List.contains digit ['2'..'9']
+
+    if isStartDigit input.[0] && isStartDigit input.[3] then
+        Some input
+    else 
+        None
+
+let clean (input: string) = 
     let digits = input.ToCharArray() |> Array.filter (Char.IsDigit) |> String
 
     match digits.Length with
-    | 10 -> Some digits
-    | 11 when digits.Chars 0 = '1' ->  Some (digits.Substring(1))
+    | 10 -> validate digits
+    | 11 when digits.Chars 0 = '1' ->  validate (digits.Substring(1))
     | _ -> None

data/tracks/fsharp/exercises/phone-number/PhoneNumber.fs

@@ -1,3 +1,3 @@
 module PhoneNumber
 
-let parsePhoneNumber input = failwith "You need to implement this function."
+let clean input = failwith "You need to implement this function."

data/tracks/fsharp/exercises/phone-number/PhoneNumberTest.fs

@@ -1,46 +1,57 @@
+// This file was auto-generated based on version 1.2.0 of the canonical data.
+
 module PhoneNumberTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open PhoneNumber
 
 [<Fact>]
-let ``Cleans phone number`` () =
-    parsePhoneNumber "(123) 456-7890" |> should equal <| Some "1234567890"
+let ``Cleans the number`` () =
+    clean "(223) 456-7890" |> should equal <| Some "2234567890"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Cleans phone number with dots`` () =
-    parsePhoneNumber "123.456.7890" |> should equal <| Some "1234567890"
+let ``Cleans numbers with dots`` () =
+    clean "223.456.7890" |> should equal <| Some "2234567890"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Valid when 11 digits and first is 1`` () =
-    parsePhoneNumber "11234567890" |> should equal <| Some "1234567890"
+let ``Cleans numbers with multiple spaces`` () =
+    clean "223 456   7890   " |> should equal <| Some "2234567890"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Invalid when 11 digits`` () =
-    parsePhoneNumber "21234567890" |> should equal None
+let ``Invalid when 9 digits`` () =
+    clean "123456789" |> should equal <| None
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Invalid when 9 digits`` () =
-    parsePhoneNumber "123456789" |> should equal None
+let ``Invalid when 11 digits does not start with a 1`` () =
+    clean "22234567890" |> should equal <| None
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Invalid when 12 digits`` () =
-    parsePhoneNumber "123456789012" |> should equal None
+let ``Valid when 11 digits and starting with 1`` () =
+    clean "12234567890" |> should equal <| Some "2234567890"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Invalid when empty`` () =
-    parsePhoneNumber "" |> should equal None
+let ``Valid when 11 digits and starting with 1 even with punctuation`` () =
+    clean "+1 (223) 456-7890" |> should equal <| Some "2234567890"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Invalid when no digits present`` () =
-    parsePhoneNumber " (-) " |> should equal None
+let ``Invalid when more than 11 digits`` () =
+    clean "321234567890" |> should equal <| None
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Valid with leading characters`` () =
-    parsePhoneNumber "my parsePhoneNumber is 123 456 7890" |> should equal <| Some "1234567890"
+let ``Invalid with letters`` () =
+    clean "123-abc-7890" |> should equal <| None
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Valid with trailing characters`` () =
-    parsePhoneNumber "123 456 7890 - bob" |> should equal <| Some "1234567890"
+let ``Invalid with punctuations`` () =
+    clean "123-@:!-7890" |> should equal <| None
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Invalid if area code does not start with 2-9`` () =
+    clean "(123) 456-7890" |> should equal <| None
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Invalid if exchange code does not start with 2-9`` () =
+    clean "(223) 056-7890" |> should equal <| None
+

data/tracks/fsharp/exercises/prime-factors/Example.fs

@@ -2,19 +2,12 @@
 
 open System
 
-let possiblePrimes (number: int64): int64 list =
-    [2L; 3L] @ [for n in 6L..6L..number do
-                   for k in [-1L; 1L] do
-                      yield n + k ]
-
-let primeFactorsFor number =
-    let rec loop factors (remainder: int64) (possibleFactors: int64 list) =
-        match possibleFactors with
-        | [] -> factors |> List.rev
-        | factor::xs ->        
+let factors number =
+    let rec loop factors (remainder: int64) (factorToCheck: int64) =     
             match remainder with
             | _ when remainder <= 1L -> factors |> List.rev
-            | _ when remainder % factor = 0L -> loop (int factor :: factors) (remainder / factor |> int64) possibleFactors
-            | _ -> loop factors remainder xs
+            | _ when remainder % factorToCheck = 0L 
+                    -> loop (int factorToCheck :: factors) (remainder / factorToCheck |> int64) factorToCheck
+            | _ -> loop factors remainder (factorToCheck+1L)
 
-    loop [] number (possiblePrimes number)
+    loop [] number 2L

data/tracks/fsharp/exercises/prime-factors/PrimeFactors.fs

@@ -1,3 +1,3 @@
 module PrimeFactors
 
-let primeFactorsFor number = failwith "You need to implement this function."
+let factors number = failwith "You need to implement this function."

data/tracks/fsharp/exercises/prime-factors/PrimeFactorsTest.fs

@@ -1,46 +1,37 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 module PrimeFactorsTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open PrimeFactors
 
 [<Fact>]
-let ``Test 1`` () =
-    primeFactorsFor 1L |> should be Empty
-    
-[<Fact(Skip = "Remove to run test")>]
-let ``Test 2`` () =
-    primeFactorsFor 2L |> should equal [2]
-    
-[<Fact(Skip = "Remove to run test")>]
-let ``Test 3`` () =
-    primeFactorsFor 3L |> should equal [3]
+let ``No factors`` () =
+    factors 1L |> should be Empty
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Test 4`` () =
-    primeFactorsFor 4L |> should equal [2; 2]
-    
-[<Fact(Skip = "Remove to run test")>]
-let ``Test 6`` () =
-    primeFactorsFor 6L |> should equal [2; 3]
-    
+let ``Prime number`` () =
+    factors 2L |> should equal [2]
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Test 8`` () =
-    primeFactorsFor 8L |> should equal [2; 2; 2]
-    
+let ``Square of a prime`` () =
+    factors 9L |> should equal [3; 3]
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Test 9`` () =
-    primeFactorsFor 9L |> should equal [3; 3]
-    
+let ``Cube of a prime`` () =
+    factors 8L |> should equal [2; 2; 2]
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Test 27`` () =
-    primeFactorsFor 27L |> should equal [3; 3; 3]
-    
+let ``Product of primes and non-primes`` () =
+    factors 12L |> should equal [2; 2; 3]
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Test 625`` () =
-    primeFactorsFor 625L |> should equal [5; 5; 5; 5]
-    
+let ``Product of primes`` () =
+    factors 901255L |> should equal [5; 17; 23; 461]
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Test 901255`` () =
-    primeFactorsFor 901255L |> should equal [5; 17; 23; 461]
+let ``Factors include a large prime`` () =
+    factors 93819012551L |> should equal [11; 9539; 894119]
+

data/tracks/fsharp/exercises/rail-fence-cipher/RailFenceCipherTest.fs

@@ -1,42 +1,51 @@
+// This file was auto-generated based on version 1.0.1 of the canonical data.
+
 module RailFenceCipherTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open RailFenceCipher
 
 [<Fact>]
 let ``Encode with two rails`` () =
-    let actual = encode 2 "XOXOXOXOXOXOXOXOXO"
+    let rails = 2
+    let msg = "XOXOXOXOXOXOXOXOXO"
     let expected = "XXXXXXXXXOOOOOOOOO"
-    actual |> should equal expected
+    encode rails msg |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Encode with three rails`` () =
-    let actual = encode 3 "WEAREDISCOVEREDFLEEATONCE"
+    let rails = 3
+    let msg = "WEAREDISCOVEREDFLEEATONCE"
     let expected = "WECRLTEERDSOEEFEAOCAIVDEN"
-    actual |> should equal expected
+    encode rails msg |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Encode with ending in the middle`` () =
-    let actual = encode 4 "EXERCISES"
+    let rails = 4
+    let msg = "EXERCISES"
     let expected = "ESXIEECSR"
-    actual |> should equal expected
+    encode rails msg |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Decode with three rails`` () =
-    let actual = decode 3 "TEITELHDVLSNHDTISEIIEA"
+    let rails = 3
+    let msg = "TEITELHDVLSNHDTISEIIEA"
     let expected = "THEDEVILISINTHEDETAILS"
-    actual |> should equal expected
+    decode rails msg |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Decode with five rails`` () =
-    let actual = decode 5 "EIEXMSMESAORIWSCE"
+    let rails = 5
+    let msg = "EIEXMSMESAORIWSCE"
     let expected = "EXERCISMISAWESOME"
-    actual |> should equal expected
+    decode rails msg |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Decode with six rails`` () =
-    let actual = decode 6 "133714114238148966225439541018335470986172518171757571896261"
+    let rails = 6
+    let msg = "133714114238148966225439541018335470986172518171757571896261"
     let expected = "112358132134558914423337761098715972584418167651094617711286"
-    actual |> should equal expected
+    decode rails msg |> should equal expected
+

data/tracks/fsharp/generators/Exercise.fs

@@ -204,11 +204,10 @@ type Exercise() =
 
     default this.RenderSutParameters canonicalDataCase =
         let sutParameterProperties = this.PropertiesUsedAsSutParameter canonicalDataCase
+        let renderSutParameter key = this.RenderSutParameter (canonicalDataCase, key, Map.find key canonicalDataCase.Properties)
 
-        canonicalDataCase.Properties
-        |> Map.filter (fun key value -> List.contains key sutParameterProperties)
-        |> Map.fold (fun acc key value  -> this.RenderSutParameter (canonicalDataCase, key, value) :: acc) [] 
-        |> List.rev
+        sutParameterProperties
+        |> List.map renderSutParameter
     
     default this.RenderSutParameter (canonicalDataCase, key, value) =
         this.RenderValueOrIdentifier (canonicalDataCase, key, value) 

data/tracks/fsharp/generators/Generators.fs

@@ -117,6 +117,18 @@ type Gigasecond() =
 
     override this.AdditionalNamespaces = [typeof<DateTime>.Namespace]
 
+type Grains() =
+    inherit Exercise()
+
+    override this.PropertiesWithIdentifier canonicalDataCase = ["expected"]
+
+    override this.IdentifierTypeAnnotation (canonicalDataCase, key, value) = Some "Result<uint64,string>"
+
+    override this.RenderExpected (canonicalDataCase, key, value) = 
+        match string value with
+        | "-1" -> "Error \"Invalid input\""
+        | x    -> sprintf "Ok %sUL" x
+
 type HelloWorld() =
     inherit Exercise()
 
@@ -167,9 +179,21 @@ type Minesweeper() =
 type Pangram() =
     inherit Exercise()
 
+type PhoneNumber() =
+    inherit Exercise()
+    
+    override this.RenderExpected (canonicalDataCase, key, value) =
+        value |> Option.ofObj |> formatValue |> backwardPipe
+
 type PigLatin() =
     inherit Exercise()
 
+type PrimeFactors() =
+    inherit Exercise()
+    
+    override this.RenderInput (canonicalDataCase, key, value) =
+        base.RenderInput (canonicalDataCase, key, value) |> sprintf "%sL"
+    
 type QueenAttack() =
     inherit Exercise()
 
@@ -189,6 +213,13 @@ type QueenAttack() =
 
     override this.PropertiesWithIdentifier canonicalDataCase = ["white_queen"; "black_queen"]
 
+type RailFenceCipher() =
+    inherit Exercise()
+
+    override this.PropertiesWithIdentifier canonicalDataCase = ["rails"; "msg"; "expected"]
+
+    override this.PropertiesUsedAsSutParameter canonicalDataCase = ["rails"; "msg"]
+
 type Raindrops() =
     inherit Exercise()