trackler 2.2.1.99 → 2.2.1.100

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

@@ -5,6 +5,6 @@ let rec private sieve remainder primes =
     | [] -> primes |> List.rev
     | p::xs -> sieve (xs |> List.filter (fun x -> x % p > 0)) (p :: primes)
     
-let primesUpTo limit = 
+let primes limit = 
     let possiblePrimes = [2 .. limit]    
     sieve possiblePrimes []

data/tracks/fsharp/exercises/sieve/Sieve.fs

@@ -1,3 +1,3 @@
 module Sieve
 
-let primesUpTo limit = failwith "You need to implement this function."
+let primes limit = failwith "You need to implement this function."

data/tracks/fsharp/exercises/sieve/SieveTest.fs

@@ -1,31 +1,29 @@
-// This file was created manually and its version is 1.0.0.
+// This file was auto-generated based on version 1.1.0 of the canonical data.
 
 module SieveTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open Sieve
 
 [<Fact>]
-let ``Finds first prime`` () =
-    primesUpTo 2 |> should equal [ 2 ]
-    
+let ``No primes under two`` () =
+    primes 1 |> should be Empty
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Finds primes up to 10`` () =
-    primesUpTo 10 |> should equal [ 2; 3; 5; 7 ]
-    
+let ``Find first prime`` () =
+    primes 2 |> should equal [2]
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Finds primes up to 1000`` () =
-    primesUpTo 1000 |> should equal 
-        [
-            2; 3; 5; 7; 11; 13; 17; 19; 23; 29; 31; 37; 41; 43; 47; 53; 59; 61; 67; 71; 73; 79; 83; 89; 97; 101;
-            103; 107; 109; 113; 127; 131; 137; 139; 149; 151; 157; 163; 167; 173; 179; 181; 191; 193; 197; 199;
-            211; 223; 227; 229; 233; 239; 241; 251; 257; 263; 269; 271; 277; 281; 283; 293; 307; 311; 313; 317;
-            331; 337; 347; 349; 353; 359; 367; 373; 379; 383; 389; 397; 401; 409; 419; 421; 431; 433; 439; 443;
-            449; 457; 461; 463; 467; 479; 487; 491; 499; 503; 509; 521; 523; 541; 547; 557; 563; 569; 571; 577;
-            587; 593; 599; 601; 607; 613; 617; 619; 631; 641; 643; 647; 653; 659; 661; 673; 677; 683; 691; 701;
-            709; 719; 727; 733; 739; 743; 751; 757; 761; 769; 773; 787; 797; 809; 811; 821; 823; 827; 829; 839;
-            853; 857; 859; 863; 877; 881; 883; 887; 907; 911; 919; 929; 937; 941; 947; 953; 967; 971; 977; 983;
-            991; 997
-        ]
+let ``Find primes up to 10`` () =
+    primes 10 |> should equal [2; 3; 5; 7]
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Limit is prime`` () =
+    primes 13 |> should equal [2; 3; 5; 7; 11; 13]
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Find primes up to 1000`` () =
+    primes 1000 |> should equal [2; 3; 5; 7; 11; 13; 17; 19; 23; 29; 31; 37; 41; 43; 47; 53; 59; 61; 67; 71; 73; 79; 83; 89; 97; 101; 103; 107; 109; 113; 127; 131; 137; 139; 149; 151; 157; 163; 167; 173; 179; 181; 191; 193; 197; 199; 211; 223; 227; 229; 233; 239; 241; 251; 257; 263; 269; 271; 277; 281; 283; 293; 307; 311; 313; 317; 331; 337; 347; 349; 353; 359; 367; 373; 379; 383; 389; 397; 401; 409; 419; 421; 431; 433; 439; 443; 449; 457; 461; 463; 467; 479; 487; 491; 499; 503; 509; 521; 523; 541; 547; 557; 563; 569; 571; 577; 587; 593; 599; 601; 607; 613; 617; 619; 631; 641; 643; 647; 653; 659; 661; 673; 677; 683; 691; 701; 709; 719; 727; 733; 739; 743; 751; 757; 761; 769; 773; 787; 797; 809; 811; 821; 823; 827; 829; 839; 853; 857; 859; 863; 877; 881; 883; 887; 907; 911; 919; 929; 937; 941; 947; 953; 967; 971; 977; 983; 991; 997]
+

data/tracks/fsharp/exercises/spiral-matrix/SpiralMatrixTest.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.1.0 of the canonical data.
 
 module SpiralMatrixTest
 

data/tracks/fsharp/exercises/sum-of-multiples/Example.fs

@@ -1,6 +1,6 @@
 module SumOfMultiples
 
-let sumOfMultiples numbers upperBound =
+let sum numbers upperBound =
     let isMultiple x = numbers |> List.exists (fun y -> x % y = 0) 
     
     [1 .. upperBound - 1] 

data/tracks/fsharp/exercises/sum-of-multiples/SumOfMultiples.fs

@@ -1,3 +1,3 @@
 module SumOfMultiples
 
-let sumOfMultiples (numbers: int list) (upperBound: int): int = failwith "You need to implement this function."
+let sum (numbers: int list) (upperBound: int): int = failwith "You need to implement this function."

data/tracks/fsharp/exercises/sum-of-multiples/SumOfMultiplesTest.fs

@@ -1,31 +1,61 @@
-// This file was created manually and its version is 1.0.0.
+// This file was auto-generated based on version 1.2.0 of the canonical data.
 
 module SumOfMultiplesTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
+
 open SumOfMultiples
 
 [<Fact>]
-let ``Sum to 1`` () =
-    sumOfMultiples [3; 5] 0 |> should equal 0
+let ``Multiples of 3 or 5 up to 1`` () =
+    sum [3; 5] 1 |> should equal 0
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Multiples of 3 or 5 up to 4`` () =
+    sum [3; 5] 4 |> should equal 3
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Multiples of 3 up to 7`` () =
+    sum [3] 7 |> should equal 9
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Multiples of 3 or 5 up to 10`` () =
+    sum [3; 5] 10 |> should equal 23
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Sum to 3`` () =
-    sumOfMultiples [3; 5] 3 |> should equal 0
+let ``Multiples of 3 or 5 up to 100`` () =
+    sum [3; 5] 100 |> should equal 2318
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Sum to 4`` () =
-    sumOfMultiples [3; 5] 4 |> should equal 3
+let ``Multiples of 3 or 5 up to 1000`` () =
+    sum [3; 5] 1000 |> should equal 233168
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Sum to 10`` () =
-    sumOfMultiples [3; 5] 10 |> should equal 23
+let ``Multiples of 7, 13 or 17 up to 20`` () =
+    sum [7; 13; 17] 20 |> should equal 51
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Sum to 20`` () =
-    sumOfMultiples [7; 13; 17] 20 |> should equal 51
+let ``Multiples of 4 or 6 up to 15`` () =
+    sum [4; 6] 15 |> should equal 30
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Sum to 10000`` () =
-    sumOfMultiples [43; 47] 10000 |> should equal 2203160
+let ``Multiples of 5, 6 or 8 up to 150`` () =
+    sum [5; 6; 8] 150 |> should equal 4419
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Multiples of 5 or 25 up to 51`` () =
+    sum [5; 25] 51 |> should equal 275
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Multiples of 43 or 47 up to 10000`` () =
+    sum [43; 47] 10000 |> should equal 2203160
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Multiples of 1 up to 100`` () =
+    sum [1] 100 |> should equal 4950
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Multiples of an empty list up to 10000`` () =
+    sum [] 10000 |> should equal 0
+

data/tracks/fsharp/exercises/twelve-days/TwelveDaysTest.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.1.0 of the canonical data.
 
 module TwelveDaysTest
 

data/tracks/fsharp/exercises/two-fer/Example.fs

@@ -1,6 +1,6 @@
 module TwoFer
 
-let name input =
+let twoFer input =
     input 
     |> Option.defaultValue  "you"
     |> sprintf "One for %s, one for me."

data/tracks/fsharp/exercises/two-fer/TwoFer.fs

@@ -1,3 +1,3 @@
 module TwoFer
 
-let name (input: string option): string = failwith "You need to implement this function."
+let twoFer (input: string option): string = failwith "You need to implement this function."

data/tracks/fsharp/exercises/two-fer/TwoFerTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.1.0 of the canonical data.
+// This file was auto-generated based on version 1.2.0 of the canonical data.
 
 module TwoFerTest
 
@@ -9,13 +9,13 @@ open TwoFer
 
 [<Fact>]
 let ``No name given`` () =
-    name None |> should equal "One for you, one for me."
+    twoFer None |> should equal "One for you, one for me."
 
 [<Fact(Skip = "Remove to run test")>]
 let ``A name given`` () =
-    name (Some "Alice") |> should equal "One for Alice, one for me."
+    twoFer (Some "Alice") |> should equal "One for Alice, one for me."
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Another name given`` () =
-    name (Some "Bob") |> should equal "One for Bob, one for me."
+    twoFer (Some "Bob") |> should equal "One for Bob, one for me."
 

data/tracks/fsharp/exercises/word-count/Example.fs

@@ -1,8 +1,8 @@
-module Phrase
+module WordCount
 
 open System.Text.RegularExpressions
 
-let wordCount (phrase: string) = 
+let countwords (phrase: string) = 
     Regex.Matches(phrase.ToLowerInvariant(), @"\w+('\w+)*") 
     |> Seq.cast<Match> 
     |> Seq.countBy (fun m -> m.Value)

data/tracks/fsharp/exercises/word-count/WordCount.fs

@@ -1,3 +1,3 @@
-module Phrase
+module WordCount
 
-let wordCount phrase = failwith "You need to implement this function."
+let countwords phrase = failwith "You need to implement this function."

data/tracks/fsharp/exercises/word-count/WordCountTest.fs

@@ -1,131 +1,111 @@
-// This file was created manually and its version is 1.0.0.
+// This file was auto-generated based on version 1.1.0 of the canonical data.
 
 module WordCountTest
 
-open Xunit
 open FsUnit.Xunit
-open Phrase
+open Xunit
+
+open WordCount
 
 [<Fact>]
 let ``Count one word`` () =
-    let phrase = "word"
-    let counts = Map.ofSeq [("word", 1)]
-
-    wordCount phrase |> should equal counts
+    let expected = [("word", 1)] |> Map.ofList
+    countwords "word" |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Count one of each`` () =
-    let phrase = "one of each"
-    let counts = Map.ofSeq [("one",  1);
-                            ("of",   1);
-                            ("each", 1)]
-
-    wordCount phrase |> should equal counts
+let ``Count one of each word`` () =
+    let expected = 
+        [ ("one", 1);
+          ("of", 1);
+          ("each", 1) ]
+        |> Map.ofList
+    countwords "one of each" |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Count multiple occurrences`` () =
-    let phrase = "one fish two fish red fish blue fish"
-    let counts = Map.ofSeq [("one",  1);
-                            ("fish", 4);
-                            ("two",  1);
-                            ("red",  1);
-                            ("blue", 1)]
-
-    wordCount phrase |> should equal counts
+let ``Multiple occurrences of a word`` () =
+    let expected = 
+        [ ("one", 1);
+          ("fish", 4);
+          ("two", 1);
+          ("red", 1);
+          ("blue", 1) ]
+        |> Map.ofList
+    countwords "one fish two fish red fish blue fish" |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Count everything just once`` () =
-    let phrase = "all the kings horses and all the kings men"
-    let counts = Map.ofSeq [("all",    2);
-                            ("the",    2);
-                            ("kings",  2);
-                            ("horses", 1);
-                            ("and",    1);
-                            ("men",    1)]
-
-    wordCount phrase |> should equal counts
+let ``Handles cramped lists`` () =
+    let expected = 
+        [ ("one", 1);
+          ("two", 1);
+          ("three", 1) ]
+        |> Map.ofList
+    countwords "one,two,three" |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Ignore punctuation`` () =
-    let phrase = "car : carpet as java : javascript!!&@$%^&"
-    let counts = Map.ofSeq [("car",        1);
-                            ("carpet",     1);
-                            ("as",         1);
-                            ("java",       1);
-                            ("javascript", 1)]
-
-    wordCount phrase |> should equal counts
+let ``Handles expanded lists`` () =
+    let expected = 
+        [ ("one", 1);
+          ("two", 1);
+          ("three", 1) ]
+        |> Map.ofList
+    countwords "one,\ntwo,\nthree" |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Handles cramped list`` () =
-    let phrase = "one,two,three"
-    let counts = Map.ofSeq [("one",   1);
-                            ("two",   1);
-                            ("three", 1)]
-
-    wordCount phrase |> should equal counts
+let ``Ignore punctuation`` () =
+    let expected = 
+        [ ("car", 1);
+          ("carpet", 1);
+          ("as", 1);
+          ("java", 1);
+          ("javascript", 1) ]
+        |> Map.ofList
+    countwords "car: carpet as java: javascript!!&@$%^&" |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Include numbers`` () =
-    let phrase = "testing, 1, 2 testing"
-    let counts = Map.ofSeq [("testing", 2);
-                            ("1",       1);
-                            ("2",       1)]
-
-    wordCount phrase |> should equal counts
+    let expected = 
+        [ ("testing", 2);
+          ("1", 1);
+          ("2", 1) ]
+        |> Map.ofList
+    countwords "testing, 1, 2 testing" |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Normalize case`` () =
-    let phrase = "go Go GO"
-    let counts = Map.ofSeq [("go", 3)]
-
-    wordCount phrase |> should equal counts
+    let expected = 
+        [ ("go", 3);
+          ("stop", 2) ]
+        |> Map.ofList
+    countwords "go Go GO Stop stop" |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``With apostrophes`` () =
-    let phrase = "First: don't laugh. Then: don't cry."
-    let counts = Map.ofSeq [("first", 1);
-                            ("don't", 2);
-                            ("laugh", 1);
-                            ("then",  1);
-                            ("cry",   1)]
-
-    wordCount phrase |> should equal counts
+    let expected = 
+        [ ("first", 1);
+          ("don't", 2);
+          ("laugh", 1);
+          ("then", 1);
+          ("cry", 1) ]
+        |> Map.ofList
+    countwords "First: don't laugh. Then: don't cry." |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``With free standing apostrophes`` () =
-    let phrase = "go ' Go '' GO"
-    let counts = Map.ofSeq [("go", 3)]
-
-    wordCount phrase |> should equal counts
-
-[<Fact(Skip = "Remove to run test")>]
-let ``With apostrophes as quotes`` () =
-    let phrase = "She said, 'let's meet at twelve o'clock'"
-    let counts = Map.ofSeq [("she",     1);
-                            ("said",    1);
-                            ("let's",   1);
-                            ("meet",    1);
-                            ("at",      1);
-                            ("twelve",  1);
-                            ("o'clock", 1)]
-
-    wordCount phrase |> should equal counts
+let ``With quotations`` () =
+    let expected = 
+        [ ("joe", 1);
+          ("can't", 1);
+          ("tell", 1);
+          ("between", 1);
+          ("large", 2);
+          ("and", 1) ]
+        |> Map.ofList
+    countwords "Joe can't tell between 'large' and large." |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``With multiple lines`` () =
-    let phrase = "Your time will come. You will face the same Evil, and you will defeat it."
-    let counts = Map.ofSeq [("and",    1);
-                            ("come",   1);
-                            ("defeat", 1);
-                            ("evil",   1);
-                            ("face",   1);
-                            ("it",     1);
-                            ("same",   1);
-                            ("the",    1);
-                            ("time",   1);
-                            ("will",   3);
-                            ("you",    2);
-                            ("your",   1)]
+let ``Multiple spaces not detected as a word`` () =
+    let expected = 
+        [ ("multiple", 1);
+          ("whitespaces", 1) ]
+        |> Map.ofList
+    countwords " multiple   whitespaces" |> should equal expected
 
-    wordCount phrase |> should equal counts

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

@@ -1,12 +1,11 @@
 module Wordy
 
-open System
 open System.Text.RegularExpressions
 
 type Operation = int -> int
 type Equation = int * (Operation list)
 
-let equationRegex = new Regex(@"(?<left>-?\d+) (?<operation>-?plus|minus|divided by|multiplied by) (?=(?<right>-?\d+))", RegexOptions.Compiled)
+let equationRegex = Regex(@"(?<left>-?\d+) (?<operation>-?plus|minus|divided by|multiplied by) (?=(?<right>-?\d+))", RegexOptions.Compiled)
 
 let regexGroupStr (group: string) (m: Match) = m.Groups.[group].Value
 let regexGroupNumber (group: string) (m: Match) = regexGroupStr group m |> int
@@ -43,7 +42,7 @@ let parse (question: string): Equation option =
     | m when m.Count = 0 -> None
     | m -> Some (parseLeft m, parseOperations m)
 
-let solve (question: string): int option =  
+let answer (question: string): int option =  
     question 
     |> parse 
     |> Option.map calculate