trackler 2.2.1.88 → 2.2.1.89

data/tracks/fsharp/build.cake

@@ -68,13 +68,8 @@ Task("ReplaceStubWithExample")
 Task("AddPackagesUsedInExampleImplementations")
     .IsDependentOn("ReplaceStubWithExample")
     .Does(() => {
-        var fparsecProjects = 
-              GetFiles(buildDir + "/*/Alphametics.fsproj")
-            + GetFiles(buildDir + "/*/SgfParsing.fsproj");
-
-        foreach (var fparsecProject in fparsecProjects) {
-            DotNetCoreTool(fparsecProject, "add", "package FParsec");
-        }
+        var projects = GetFiles(buildDir + "/*/SgfParsing.fsproj");
+        Parallel.ForEach(projects, parallelOptions, (project) => DotNetCoreTool(project.FullPath, "add", "package FParsec"));
     });
 
 Task("TestUsingExampleImplementation")

data/tracks/fsharp/exercises/acronym/AcronymTest.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 AcronymTest
 

data/tracks/fsharp/exercises/all-your-base/AllYourBase.fs

@@ -1,3 +1,3 @@
 module AllYourBase
 
-let rebase inB inDigits outB = failwith "You need to implement this function."
+let rebase digits inputBase outputBase = failwith "You need to implement this function."

data/tracks/fsharp/exercises/all-your-base/AllYourBaseTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 2.0.1 of the canonical data.
+// This file was auto-generated based on version 2.1.0 of the canonical data.
 
 module AllYourBaseTest
 
@@ -9,169 +9,169 @@ open AllYourBase
 
 [<Fact>]
 let ``Single bit one to decimal`` () =
+    let digits = [1]
     let inputBase = 2
-    let inputDigits = [1]
     let outputBase = 10
     let expected = Some [1]
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Binary to single decimal`` () =
+    let digits = [1; 0; 1]
     let inputBase = 2
-    let inputDigits = [1; 0; 1]
     let outputBase = 10
     let expected = Some [5]
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Single decimal to binary`` () =
+    let digits = [5]
     let inputBase = 10
-    let inputDigits = [5]
     let outputBase = 2
     let expected = Some [1; 0; 1]
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Binary to multiple decimal`` () =
+    let digits = [1; 0; 1; 0; 1; 0]
     let inputBase = 2
-    let inputDigits = [1; 0; 1; 0; 1; 0]
     let outputBase = 10
     let expected = Some [4; 2]
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Decimal to binary`` () =
+    let digits = [4; 2]
     let inputBase = 10
-    let inputDigits = [4; 2]
     let outputBase = 2
     let expected = Some [1; 0; 1; 0; 1; 0]
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Trinary to hexadecimal`` () =
+    let digits = [1; 1; 2; 0]
     let inputBase = 3
-    let inputDigits = [1; 1; 2; 0]
     let outputBase = 16
     let expected = Some [2; 10]
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Hexadecimal to trinary`` () =
+    let digits = [2; 10]
     let inputBase = 16
-    let inputDigits = [2; 10]
     let outputBase = 3
     let expected = Some [1; 1; 2; 0]
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``15-bit integer`` () =
+    let digits = [3; 46; 60]
     let inputBase = 97
-    let inputDigits = [3; 46; 60]
     let outputBase = 73
     let expected = Some [6; 10; 45]
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Empty list`` () =
+    let digits = []
     let inputBase = 2
-    let inputDigits = []
     let outputBase = 10
     let expected = Some [0]
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Single zero`` () =
+    let digits = [0]
     let inputBase = 10
-    let inputDigits = [0]
     let outputBase = 2
     let expected = Some [0]
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Multiple zeros`` () =
+    let digits = [0; 0; 0]
     let inputBase = 10
-    let inputDigits = [0; 0; 0]
     let outputBase = 2
     let expected = Some [0]
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Leading zeros`` () =
+    let digits = [0; 6; 0]
     let inputBase = 7
-    let inputDigits = [0; 6; 0]
     let outputBase = 10
     let expected = Some [4; 2]
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Input base is one`` () =
+    let digits = []
     let inputBase = 1
-    let inputDigits = []
     let outputBase = 10
     let expected = None
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Input base is zero`` () =
+    let digits = []
     let inputBase = 0
-    let inputDigits = []
     let outputBase = 10
     let expected = None
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Input base is negative`` () =
+    let digits = [1]
     let inputBase = -2
-    let inputDigits = [1]
     let outputBase = 10
     let expected = None
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Negative digit`` () =
+    let digits = [1; -1; 1; 0; 1; 0]
     let inputBase = 2
-    let inputDigits = [1; -1; 1; 0; 1; 0]
     let outputBase = 10
     let expected = None
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Invalid positive digit`` () =
+    let digits = [1; 2; 1; 0; 1; 0]
     let inputBase = 2
-    let inputDigits = [1; 2; 1; 0; 1; 0]
     let outputBase = 10
     let expected = None
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Output base is one`` () =
+    let digits = [1; 0; 1; 0; 1; 0]
     let inputBase = 2
-    let inputDigits = [1; 0; 1; 0; 1; 0]
     let outputBase = 1
     let expected = None
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Output base is zero`` () =
+    let digits = [7]
     let inputBase = 10
-    let inputDigits = [7]
     let outputBase = 0
     let expected = None
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Output base is negative`` () =
+    let digits = [1]
     let inputBase = 2
-    let inputDigits = [1]
     let outputBase = -7
     let expected = None
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Both bases are negative`` () =
+    let digits = [1]
     let inputBase = -2
-    let inputDigits = [1]
     let outputBase = -7
     let expected = None
-    rebase inputBase inputDigits outputBase |> should equal expected
+    rebase digits inputBase outputBase |> should equal expected
 

data/tracks/fsharp/exercises/all-your-base/Example.fs

@@ -19,12 +19,12 @@ let fromBase b nums =
 
     loop 0 nums
 
-let rebase inB inDigits outB =
-    match inB < 2 || outB < 2 with
+let rebase digits inputBase outputBase =
+    match inputBase < 2 || outputBase < 2 with
     | true ->
         None
     | false ->
-        inDigits
+        digits
         |> List.skipWhile ((=) 0)
-        |> fromBase inB
-        |> Option.bind (toBase outB)
+        |> fromBase inputBase
+        |> Option.bind (toBase outputBase)

data/tracks/fsharp/exercises/allergies/AllergiesTest.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 AllergiesTest
 

data/tracks/fsharp/exercises/alphametics/AlphameticsTest.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.2.0 of the canonical data.
 
 module AlphameticsTest
 
@@ -105,3 +105,21 @@ let ``Puzzle with ten letters`` () =
         |> Some
     solve puzzle |> should equal expected
 
+[<Fact(Skip = "Remove to run test")>]
+let ``Puzzle with ten letters and 199 addends`` () =
+    let puzzle = "THIS + A + FIRE + THEREFORE + FOR + ALL + HISTORIES + I + TELL + A + TALE + THAT + FALSIFIES + ITS + TITLE + TIS + A + LIE + THE + TALE + OF + THE + LAST + FIRE + HORSES + LATE + AFTER + THE + FIRST + FATHERS + FORESEE + THE + HORRORS + THE + LAST + FREE + TROLL + TERRIFIES + THE + HORSES + OF + FIRE + THE + TROLL + RESTS + AT + THE + HOLE + OF + LOSSES + IT + IS + THERE + THAT + SHE + STORES + ROLES + OF + LEATHERS + AFTER + SHE + SATISFIES + HER + HATE + OFF + THOSE + FEARS + A + TASTE + RISES + AS + SHE + HEARS + THE + LEAST + FAR + HORSE + THOSE + FAST + HORSES + THAT + FIRST + HEAR + THE + TROLL + FLEE + OFF + TO + THE + FOREST + THE + HORSES + THAT + ALERTS + RAISE + THE + STARES + OF + THE + OTHERS + AS + THE + TROLL + ASSAILS + AT + THE + TOTAL + SHIFT + HER + TEETH + TEAR + HOOF + OFF + TORSO + AS + THE + LAST + HORSE + FORFEITS + ITS + LIFE + THE + FIRST + FATHERS + HEAR + OF + THE + HORRORS + THEIR + FEARS + THAT + THE + FIRES + FOR + THEIR + FEASTS + ARREST + AS + THE + FIRST + FATHERS + RESETTLE + THE + LAST + OF + THE + FIRE + HORSES + THE + LAST + TROLL + HARASSES + THE + FOREST + HEART + FREE + AT + LAST + OF + THE + LAST + TROLL + ALL + OFFER + THEIR + FIRE + HEAT + TO + THE + ASSISTERS + FAR + OFF + THE + TROLL + FASTS + ITS + LIFE + SHORTER + AS + STARS + RISE + THE + HORSES + REST + SAFE + AFTER + ALL + SHARE + HOT + FISH + AS + THEIR + AFFILIATES + TAILOR + A + ROOFS + FOR + THEIR + SAFE == FORTRESSES"
+    let expected = 
+        [ ('A', 1);
+          ('E', 0);
+          ('F', 5);
+          ('H', 8);
+          ('I', 7);
+          ('L', 2);
+          ('O', 6);
+          ('R', 3);
+          ('S', 4);
+          ('T', 9) ]
+        |> Map.ofList
+        |> Some
+    solve puzzle |> should equal expected
+

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

@@ -2,24 +2,15 @@
 
 open System
 
-open FParsec
-open System.Text.RegularExpressions
+let private foldMapBy mapping map1 map2 =
+    let helper acc key value = 
+        match Map.tryFind key acc with
+        | Some x -> Map.add key (mapping x value) acc
+        | None   -> Map.add key value acc
 
-let private plus = pstring " + "
-let private equal = pstring " == "
-let private operand = many1Satisfy isAsciiUpper
-let private expression = sepBy operand plus
-let private equation = expression .>> equal .>>. expression
+    map1 |> Map.fold helper map2
 
-let private parseToOption parser (input: string) =
-    match run parser input with
-    | Success(result, _, _)   -> Some result
-    | Failure(errorMsg, _, _) -> None
-
-let private parseEquation = parseToOption equation
-
-let private operandToInt (map: Map<char, int>) (operand: string) =
-    Seq.fold (fun acc x -> acc * 10 + Map.find x map) 0 operand
+let private tenToPower power = Math.Pow(10., float power) |> int
 
 let private generateCombinations length =
     let rec helper remaining options =
@@ -28,25 +19,53 @@ let private generateCombinations length =
                     for xs in helper (remaining - 1) (Set.remove x options) do
                         yield x::xs }
 
-    helper length ([0..9] |> Set.ofList)
+    helper length ([0..9] |> Set.ofList)    
+
+let private solutions parts = 
+    let letters = parts |> Seq.concat |> Seq.toList |> List.distinct
+    let nonZeroLetters = Array.map Seq.head parts |> Array.distinct
+    
+    letters
+    |> List.length
+    |> generateCombinations
+    |> Seq.map (fun combination -> Seq.zip letters combination |> Map.ofSeq)
+    |> Seq.filter (fun solution -> Array.forall (fun letter -> Map.find letter solution <> 0) nonZeroLetters)
+
+let private trySolve counts solution = 
+    let folder sum letter count =
+        let multiplier = Map.find letter solution
+        sum + count * multiplier
+
+    match Map.fold folder 0 counts with
+    | 0 -> Some solution
+    | _ -> None
+
+let private parseAddends (puzzle: string) =
+    puzzle
+        .Replace("==", "")
+        .Replace("+", "")
+        .Split([|" "|], StringSplitOptions.RemoveEmptyEntries)
 
-let private generateMaps (leftOperands, rightOperands) =
-    let operands = leftOperands @ rightOperands 
-    let chars = operands |> String.concat "" |> Set.ofSeq
-    let nonZeroChars = operands |> List.map Seq.head |> Set.ofList
-   
-    generateCombinations (Set.count chars)
-    |> Seq.map (Seq.zip chars >> Map.ofSeq)
-    |> Seq.filter (fun m -> Set.forall (fun x -> Map.find x m <> 0) nonZeroChars)
+let private addendToLetterCount multiplier word =
+    word
+    |> Seq.rev
+    |> Seq.mapi (fun i letter -> (letter, tenToPower i * multiplier))
+    |> Seq.groupBy fst
+    |> Seq.map (fun (letter, counts) -> (letter, counts |> Seq.sumBy snd))
+    |> Map.ofSeq
 
-let private sumOperands lettersToDigits = List.sumBy (operandToInt lettersToDigits)
+let private addendsToLetterCount addends =   
+    let mapAddend i addend = 
+        let multiplier = if i = Array.length addends - 1 then -1 else 1
+        addendToLetterCount multiplier addend
 
-let private trySolve (leftOperands, rightOperands) lettersToDigits =
-    let left = sumOperands lettersToDigits leftOperands
-    let right = sumOperands lettersToDigits rightOperands
-    left = right
+    addends
+    |> Array.mapi mapAddend
+    |> Array.reduce (foldMapBy (+))
 
-let solve input: Map<char, int> option = 
-    match parseEquation input with
-    | Some equation -> Seq.tryFind (trySolve equation) (generateMaps equation)
-    | None -> None
+let solve (puzzle: string) =
+    let addends = parseAddends puzzle
+    let letterCounts = addendsToLetterCount addends
+    
+    solutions addends
+    |> Seq.tryPick (trySolve letterCounts)

data/tracks/fsharp/exercises/anagram/AnagramTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.0.1 of the canonical data.
+// This file was auto-generated based on version 1.1.0 of the canonical data.
 
 module AnagramTest
 

data/tracks/fsharp/exercises/atbash-cipher/AtbashCipherTest.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 AtbashCipherTest
 

data/tracks/fsharp/exercises/beer-song/BeerSongTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 2.0.0 of the canonical data.
+// This file was auto-generated based on version 2.1.0 of the canonical data.
 
 module BeerSongTest
 

data/tracks/fsharp/exercises/binary-search/BinarySearchTest.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 BinarySearchTest
 

data/tracks/fsharp/exercises/bob/BobTest.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 BobTest
 

data/tracks/fsharp/exercises/book-store/BookStoreTest.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 BookStoreTest