trackler 2.0.5.9 → 2.0.5.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d1f9e78737566c55c139024513a73f38029f2a0c
-  data.tar.gz: 853360aad86762df2a9279f3ad209e4497c739ad
+  metadata.gz: 3a4a09d238b30d68369e40d493a03b8f095a1803
+  data.tar.gz: f5e9f063daeaf6f628c06eaa82147898c68ef380
 SHA512:
-  metadata.gz: 1517522938b3420f81dd931fb53458a99858c61e4673ec0413c120fc9aff827306e257fb5a316a21a2b771c12ae8a859ea943b53967ade8471031c9761e139e6
-  data.tar.gz: 527684182f9afe7b3e1e4a8b9fbc0a07e1a60dc0272d1188efb311678f065d4eb49118f5c059a87bb6d8a6daf0158a20e06dea9d45c69c746b01effb5541c3ed
+  metadata.gz: 5428931a7a5b48c186986179706882feeb43c2f422e20d177bd132256888b0caa72ec7a8a22679ba178b85dd629a8487889856875bcdd5dd1dceb307864c9618
+  data.tar.gz: a63b460b8a05caff7fd55f4e4310b933188426ef3e685dbbd08cbae30c58bdaa12d1b8e0eb69b548c93623c4edce95c3bd88575394ffe3d7a891f4cd640367b8

data/common/TOPICS.txt

@@ -46,6 +46,7 @@ Problem areas
 -------------
 Algorithms
 Bitwise operations
+Concurrency
 Domain-specific languages
 Files
 Filtering

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.5.9"
+  VERSION = "2.0.5.10"
 end

data/tracks/csharp/config.json

@@ -747,6 +747,15 @@
         "Algorithms"
       ]
     },
+    {
+      "slug": "go-counting",
+      "difficulty": 9,
+      "topics": [
+        "Parsing",
+        "Tuples",
+        "Optional values"
+      ]
+    },
     {
       "slug": "sgf-parsing",
       "difficulty": 9,

data/tracks/csharp/exercises/go-counting/Example.cs

@@ -0,0 +1,147 @@
+using System;
+using System.Drawing;
+using System.Collections.Generic;
+using System.Linq;
+
+public class GoCounting
+{
+    public enum Player
+    {
+        None,
+        Black,
+        White
+    }
+
+    private readonly Player[][] board;
+
+    public GoCounting(string input)
+    {
+        board = ParseBoard(input);
+    }
+
+    private static Player CharToPlayer(char c)
+    {
+        switch (c)
+        {
+            case 'B': return Player.Black;
+            case 'W': return Player.White;
+            default: return Player.None;
+        }
+    }
+
+    private static Player[][] ParseBoard(string input)
+    {
+        var split = input.Split('\n');
+        var rows = split.Length;
+        var cols = split[0].Length;
+
+        return split.Select(row => row.Select(CharToPlayer).ToArray()).ToArray();
+    }
+
+    private int Cols => board[0].Length;
+    private int Rows => board.Length;
+
+    private bool IsValidCoordinate(Point coordinate) =>
+        coordinate.Y >= 0 && coordinate.Y < Rows &&
+        coordinate.X >= 0 && coordinate.X < Cols;
+
+    private Player GetPlayer(Point coordinate) => board[coordinate.Y][coordinate.X];
+
+    private bool IsEmpty(Point coordinate) => GetPlayer(coordinate) == Player.None;
+    private bool IsTaken(Point coordinate) => !IsEmpty(coordinate);
+
+    private IEnumerable<Point> EmptyCoordinates()
+    {
+        return Enumerable.Range(0, Cols).SelectMany(col =>
+               Enumerable.Range(0, Rows).Select(row => new Point(col, row)))
+                .Where(IsEmpty);
+    }
+
+    private IEnumerable<Point> NeighborCoordinates(Point coordinate)
+    {
+        var row = coordinate.Y;
+        var col = coordinate.X;
+
+        var coords = new[]
+        {
+            new Point(col, row - 1),
+            new Point(col-1, row),
+            new Point(col+1, row),
+            new Point(col, row+1)
+        };
+
+        return coords.Where(IsValidCoordinate);
+    }
+
+    private IEnumerable<Point> TakenNeighborCoordinates(Point coordinate) =>
+        NeighborCoordinates(coordinate).Where(IsTaken);
+
+    private IEnumerable<Point> EmptyNeighborCoordinates(Point coordinate) =>
+        NeighborCoordinates(coordinate).Where(IsEmpty);
+
+    private Player TerritoryOwner(HashSet<Point> coords)
+    {
+        var neighborColors = coords.SelectMany(TakenNeighborCoordinates).Select(GetPlayer);
+        var uniqueNeighborColors = ToSet(neighborColors);
+
+        if (uniqueNeighborColors.Count == 1)
+            return uniqueNeighborColors.First();
+
+        return Player.None;
+    }
+
+    private HashSet<Point> TerritoryHelper(HashSet<Point> remainder, HashSet<Point> acc)
+    {
+        if (!remainder.Any())
+            return acc;
+
+        var emptyNeighbors = new HashSet<Point>(remainder.SelectMany(EmptyNeighborCoordinates));
+        emptyNeighbors.ExceptWith(acc);
+
+        var newAcc = ToSet(acc);
+        newAcc.UnionWith(emptyNeighbors);
+        return TerritoryHelper(emptyNeighbors, newAcc);
+    }
+
+    private HashSet<Point> Territory(Point coordinate) =>
+        IsValidCoordinate(coordinate) && IsEmpty(coordinate)
+            ? TerritoryHelper(ToSingletonSet(coordinate), ToSingletonSet(coordinate))
+            : new HashSet<Point>();
+
+    public Tuple<Player, IEnumerable<Point>> TerritoryFor(Point coord)
+    {
+        var coords = Territory(coord);
+        if (!coords.Any())
+            return null;
+
+        var owner = TerritoryOwner(coords);
+        return Tuple.Create(owner, coords.AsEnumerable());
+    }
+
+    private Dictionary<Player, IEnumerable<Point>> TerritoriesHelper(HashSet<Point> remainder, Dictionary<Player, IEnumerable<Point>> acc)
+    {
+        if (!remainder.Any())
+            return acc;
+
+        var coord = remainder.First();
+        var coords = Territory(coord);
+        var owner = TerritoryOwner(coords);
+
+        var newRemainder = ToSet(remainder);
+        newRemainder.ExceptWith(coords);
+
+        var newAcc = new Dictionary<Player, IEnumerable<Point>>(acc);
+        newAcc[owner] = coords;
+
+        return TerritoriesHelper(newRemainder, newAcc);
+    }
+
+    public Dictionary<Player, IEnumerable<Point>> Territories()
+    {
+        var emptyCoords = EmptyCoordinates();
+        return TerritoriesHelper(ToSet(emptyCoords), new Dictionary<Player, IEnumerable<Point>>());
+    }
+
+    private static HashSet<T> ToSet<T>(IEnumerable<T> value) => new HashSet<T>(value);
+    private static HashSet<T> ToSingletonSet<T>(T value) => new HashSet<T> { value };    
+}

data/tracks/csharp/exercises/go-counting/GoCountingTest.cs

@@ -0,0 +1,127 @@
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+
+public class GoCountingTest
+{
+    private static readonly string boardFiveByFive =
+        string.Join("\n", new[]
+            {
+                "  B  ",
+                " B B ",
+                "B W B",
+                " W W ",
+                "  W  "
+            });
+
+    private static readonly string board9x9 =
+        string.Join("\n", new[]
+            {
+                "  B   B  ",
+                "B   B   B",
+                "WBBBWBBBW",
+                "W W W W W",
+                "         ",
+                " W W W W ",
+                "B B   B B",
+                " W BBB W ",
+                "   B B   "
+            });
+
+    [Test]
+    public void FiveByFiveTerritoryForBlack()
+    {
+        var board = new GoCounting(boardFiveByFive);
+        var result = board.TerritoryFor(new Point(0, 1));
+        Assert.That(result.Item1, Is.EqualTo(GoCounting.Player.Black));
+        Assert.That(result.Item2, Is.EquivalentTo(new[] { new Point(0, 0), new Point(0, 1), new Point(1, 0) }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void FiveByFiveTerritoryForWhite()
+    {
+        var board = new GoCounting(boardFiveByFive);
+        var result = board.TerritoryFor(new Point(2, 3));
+        Assert.That(result.Item1, Is.EqualTo(GoCounting.Player.White));
+        Assert.That(result.Item2, Is.EquivalentTo(new[] { new Point(2, 3) }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void FiveByFiveOpenTerritory()
+    {
+        var board = new GoCounting(boardFiveByFive);
+        var result = board.TerritoryFor(new Point(1, 4));
+        Assert.That(result.Item1, Is.EqualTo(GoCounting.Player.None));
+        Assert.That(result.Item2, Is.EquivalentTo(new[] { new Point(0, 3), new Point(0, 4), new Point(1, 4) }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void FiveByFiveNonTerritoryStone()
+    {
+        var board = new GoCounting(boardFiveByFive);
+        Assert.That(board.TerritoryFor(new Point(1, 1)), Is.Null);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void FiveByFiveNonTerritoryDueToTooLowCoordinate()
+    {
+        var board = new GoCounting(boardFiveByFive);
+        Assert.That(board.TerritoryFor(new Point(-1, 1)), Is.Null);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void FiveByFiveNonTerritoryDueToTooHighCoordinate()
+    {
+        var board = new GoCounting(boardFiveByFive);
+        Assert.That(board.TerritoryFor(new Point(1, 5)), Is.Null);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void MinimalBoardWithNoTerritories()
+    {
+        var input = "B";
+        var board = new GoCounting(input);
+
+        var expected = new Dictionary<GoCounting.Player, IEnumerable<Point>>();
+
+        Assert.That(board.Territories(), Is.EquivalentTo(expected));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void OneTerritoryCoveringTheWholeBoard()
+    {
+        var input = " ";
+        var board = new GoCounting(input);
+
+        var expected = new Dictionary<GoCounting.Player, IEnumerable<Point>>
+        {
+            [GoCounting.Player.None] = new[] { new Point(0, 0) }
+        };
+
+        Assert.That(board.Territories(), Is.EquivalentTo(expected));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void TwoTerritoriesOnRectangularBoard()
+    {
+        var input = string.Join("\n", new[] { " BW ", " BW " });
+        var board = new GoCounting(input);
+
+        var expected = new Dictionary<GoCounting.Player, IEnumerable<Point>>
+        {
+            [GoCounting.Player.Black] = new[] { new Point(0, 0), new Point(0, 1) },
+            [GoCounting.Player.White] = new[] { new Point(3, 0), new Point(3, 1) }
+        };
+
+        Assert.That(board.Territories(), Is.EquivalentTo(expected));
+    }
+}

data/tracks/fsharp/config.json

@@ -65,13 +65,6 @@
         "Floating-point numbers"
       ]
     },
-    {
-      "slug": "bank-account",
-      "difficulty": 2,
-      "topics": [
-        "Optional values"
-      ]
-    },
     {
       "slug": "grains",
       "difficulty": 2,
@@ -557,6 +550,14 @@
         "Transforming"
       ]
     },
+    {
+      "slug": "bank-account",
+      "difficulty": 5,
+      "topics": [
+        "Optional values",
+        "Concurrency"
+      ]
+    },
     {
       "slug": "markdown",
       "difficulty": 5,
@@ -574,6 +575,13 @@
         "Transforming"
       ]
     },
+    {
+      "slug": "book-store",
+      "difficulty": 5,
+      "topics": [
+        "Recursion"
+      ]
+    },
     {
       "slug": "tournament",
       "difficulty": 6,

data/tracks/fsharp/docs/LEARNING.md

@@ -1,6 +1,16 @@
-Exercism provides exercises and feedback but can be difficult to jump into for those learning F# for the first time. These resources can help you get started:
+## Learning F# 
 
-* [StackOverflow - F#](http://stackoverflow.com/questions/tagged/f%23)
-* [F# For Fun and Profit](http://fsharpforfunandprofit.com/)
-* [Try F#](http://www.tryfsharp.org/Learn)
-* [F# Foundation](http://fsharp.org/)
+### Websites
+* The [F# for Fun and Profit](http://fsharpforfunandprofit.com/) website has tons of great F# content. From a gentle introduction to the world of F# to more advanced concepts, it's all covered. Bonus: all content is also available as an [eBook](https://www.gitbook.com/book/swlaschin/fsharpforfunandprofit/details).
+* The [Try F#](http://www.tryfsharp.org/Learn) website has a great [interactive tutorial](http://www.tryfsharp.org/Learn/getting-started) that allows you to write, compile and execute F# code directly in the browser.
+* The [F# Foundation](http://fsharp.org/) is a non-profit organisation which aim is to promote F#. The website has lots of links to great F# content. Perhaps even more interesting is their [mentorship program](http://fsharp.org/mentorship/index.html), where you can apply to learn F# from an experienced F# mentor.
+
+### Videos
+* [F# for the Practical Developer](https://www.youtube.com/watch?v=7z_q06HQLes&t=2070s) is a nice introduction to F#.
+* [F# - Why you should give an F](https://www.youtube.com/watch?v=kKkFabSzZvU) has Daniel Chambers give a sweet introduction into F#, neatly highlighting most F#'s features.
+* [Dr. Don Syme - Introduction to F#](https://channel9.msdn.com/Series/C9-Lectures-Dr-Don-Syme-Introduction-to-F-/C9-Lectures-Dr-Don-Syme-Introduction-to-F-1-of-3) has Don Syme, the designer of F#, give an introduction to F#.
+* If you're a C# developer, you might like [F# for C# developers](https://vimeo.com/78908217) by Phil Trelford.
+
+### Books
+* [Beginning F# 4.0](https://books.google.nl/books?id=puQgDAAAQBAJ&redir_esc=y)
+* [Real-World Functional Programming](https://books.google.nl/books?id=KfooAQAAMAAJ&q=isbn:1933988924&dq=isbn:1933988924&hl=en&sa=X&ved=0ahUKEwj-4eCii43RAhWdYFAKHdmnAEIQ6AEIHDAA)

data/tracks/fsharp/docs/RESOURCES.md

@@ -1,5 +1,17 @@
-## Linting
-F# projects (.fsproj) can be linted for further code analysis via a third party tool - [FSharpLint](https://github.com/fsprojects/FSharpLint).
+## Recommended Learning Resources
 
-To use this, just follow the directions from the wiki page to use the [command line tool](https://github.com/duckmatt/FSharpLint/wiki/Console-Application).
+### Blogs
+* Sergey Tihon's [F# Weekly blog](https://sergeytihon.wordpress.com/) is a weekly-updated website that lists recent F# news and articles.
+* Mark Seemann's [blog](http://blog.ploeh.dk/) also has lots of interesting F# articles, usually focusing on how to design your application.
 
+### Social media
+* [StackOverflow ](http://stackoverflow.com/questions/tagged/f%23) can be used to search for your problem and see if it has been answered already. You can also ask and answer questions.
+* The [F# channel](https://functionalprogramming.slack.com/messages/fsharp/) of the [functionalprogramming slack account](https://functionalprogramming.slack.com/). To join, go to [fpchat.com](http://fpchat.com/).
+* The [F# slack account](https://fsharp.slack.com). To join, you have to [become a member of the F# foundation](http://fsharp.org/guides/slack/).
+* [/r/fsharp](https://www.reddit.com/r/fsharp) is the F# subreddit.
+
+### Videos
+* The [Community for F#](https://www.youtube.com/channel/UCCQPh0mSMaVpRcKUeWPotSA/feed) YouTube channel has got lots of F# videos.
+
+### Books
+* [Expert F# 4.0](https://books.google.nl/books?id=L_0PogEACAAJ&dq=isbn:1484207424&hl=en&sa=X&ved=0ahUKEwjs__-hi43RAhWIMFAKHUJPASwQ6AEIHDAA)

data/tracks/fsharp/exercises/bank-account/BankAccountTest.fs

@@ -12,11 +12,13 @@ let ``Returns empty balance after opening`` () =
 [<Test>]
 [<Ignore("Remove to run test")>]
 let ``Check basic balance`` () =
-    let account1 = mkBankAccount() |> openAccount
-    let openingBalance = account1 |> getBalance 
+    let account = mkBankAccount() |> openAccount
+    let openingBalance = account |> getBalance 
 
-    let account2 = account1 |> updateBalance 10.0
-    let updatedBalance = account2 |> getBalance
+    let updatedBalance = 
+        account
+        |> updateBalance 10.0 
+        |> getBalance
 
     Assert.That(openingBalance, Is.EqualTo(Some 0.0))
     Assert.That(updatedBalance, Is.EqualTo(Some 10.0))
@@ -24,14 +26,18 @@ let ``Check basic balance`` () =
 [<Test>]
 [<Ignore("Remove to run test")>]
 let ``Balance can increment or decrement`` () =    
-    let account1 = mkBankAccount() |> openAccount
-    let openingBalance = account1 |> getBalance 
+    let account = mkBankAccount() |> openAccount
+    let openingBalance = account |> getBalance 
 
-    let account2 = account1 |> updateBalance 10.0
-    let addedBalance = account2 |> getBalance
+    let addedBalance = 
+        account 
+        |> updateBalance 10.0
+        |> getBalance
 
-    let account3 = account2 |> updateBalance -15.0
-    let subtractedBalance = account3 |> getBalance
+    let subtractedBalance = 
+        account 
+        |> updateBalance -15.0
+        |> getBalance
 
     Assert.That(openingBalance, Is.EqualTo(Some 0.0))
     Assert.That(addedBalance, Is.EqualTo(Some 10.0))
@@ -45,4 +51,26 @@ let ``Account can be closed`` () =
         |> openAccount
         |> closeAccount
 
-    Assert.That(account |> getBalance, Is.EqualTo(None))
+    Assert.That(account |> getBalance, Is.EqualTo(None))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Account can be updated from multiple threads`` () =
+    let account = 
+        mkBankAccount()
+        |> openAccount
+
+    let updateAccountAsync =        
+        async {                             
+            account 
+            |> updateBalance 1.0
+            |> ignore
+        }
+
+    updateAccountAsync
+    |> List.replicate 1000
+    |> Async.Parallel 
+    |> Async.RunSynchronously
+    |> ignore
+
+    Assert.That(account |> getBalance, Is.EqualTo(Some 1000.0))

data/tracks/fsharp/exercises/bank-account/Example.fs

@@ -1,24 +1,29 @@
 module BankAccount
 
-type BankAccount = 
-    | Open of float
-    | Closed
+open System
 
-let mkBankAccount() = Closed
+type BankAccount() = 
+    member val Lock = new Object()
+    member val Balance: float option = None with get,set
 
-let openAccount =
-    function
-    | Open x -> Open x
-    | Closed -> Open 0.0
+let mkBankAccount() = BankAccount()
 
-let closeAccount x = Closed
+let openAccount (account: BankAccount) = 
+    lock account.Lock (fun () ->
+        account.Balance <- Some 0.0
+        account
+    )
 
-let getBalance =
-    function
-    | Open x -> Some x
-    | Closed -> None
+let closeAccount (account: BankAccount) = 
+    lock account.Lock (fun () ->
+        account.Balance <- None    
+        account
+    )
 
-let updateBalance change =
-    function
-    | Open x -> Open (x + change)
-    | Closed -> Closed
+let getBalance (account: BankAccount) = account.Balance
+
+let updateBalance change (account: BankAccount) = 
+    lock account.Lock (fun () ->
+        account.Balance <- Option.map ((+) change) account.Balance    
+        account
+    )

data/tracks/fsharp/exercises/book-store/BookStoreTest.fs

@@ -0,0 +1,64 @@
+module BookStoreTest
+
+open System
+open NUnit.Framework
+open BookStore
+
+[<Test>]
+let ``Basket with single book`` () =
+    Assert.That(calculateTotalCost [1], Is.EqualTo(8))
+
+[<Ignore("Remove to run test")>]
+[<Test>]
+let ``Basket with two of same book`` () =
+    Assert.That(calculateTotalCost [2; 2], Is.EqualTo(16))
+
+[<Ignore("Remove to run test")>]
+[<Test>]
+let ``Empty basket`` () =
+    Assert.That(calculateTotalCost [], Is.EqualTo(0))
+
+[<Ignore("Remove to run test")>]
+[<Test>]
+let ``Basket with two different books`` () =
+    Assert.That(calculateTotalCost [1; 2], Is.EqualTo(15.2))
+
+[<Ignore("Remove to run test")>]
+[<Test>]
+let ``Basket with three different books`` () =
+    Assert.That(calculateTotalCost [1; 2; 3], Is.EqualTo(21.6))
+
+[<Ignore("Remove to run test")>]
+[<Test>]
+let ``Basket with four different books`` () =
+    Assert.That(calculateTotalCost [1; 2; 3; 4], Is.EqualTo(25.6))
+
+[<Ignore("Remove to run test")>]
+[<Test>]
+let ``Basket with five different books`` () =
+    Assert.That(calculateTotalCost [1; 2; 3; 4; 5], Is.EqualTo(30))
+
+[<Ignore("Remove to run test")>]
+[<Test>]
+let ``Basket with eight books`` () =
+    Assert.That(calculateTotalCost [1; 1; 2; 2; 3; 3; 4; 5], Is.EqualTo(51.20))
+
+[<Ignore("Remove to run test")>]
+[<Test>]
+let ``Basket with nine books`` () =
+    Assert.That(calculateTotalCost [1; 1; 2; 2; 3; 3; 4; 4; 5], Is.EqualTo(55.60))
+
+[<Ignore("Remove to run test")>]
+[<Test>]
+let ``Basket with ten books`` () =
+    Assert.That(calculateTotalCost [1; 1; 2; 2; 3; 3; 4; 4; 5; 5], Is.EqualTo(60))
+
+[<Ignore("Remove to run test")>]
+[<Test>]
+let ``Basket with eleven books`` () =
+    Assert.That(calculateTotalCost [1; 1; 2; 2; 3; 3; 4; 4; 5; 5; 1], Is.EqualTo(68))
+
+[<Ignore("Remove to run test")>]
+[<Test>]
+let ``Basket with twelve books`` () =
+    Assert.That(calculateTotalCost [1; 1; 2; 2; 3; 3; 4; 4; 5; 5; 1; 2], Is.EqualTo(75.20))

data/tracks/fsharp/exercises/book-store/Example.fs

@@ -0,0 +1,52 @@
+module BookStore
+
+let private costPerGroup groupSize =
+    let discountPercentage =
+        match groupSize with
+        | 1 ->  0.
+        | 2 ->  5.
+        | 3 -> 10.
+        | 4 -> 20.
+        | 5 -> 25.
+        | _ -> failwith "Invalid group size"
+
+    8. * (groupSize |> float) * (100. - discountPercentage) / 100.
+
+let private remove n list =
+    let rec removeTail n list acc =
+        match list with
+        | x::xs when x = n -> List.append (List.rev acc) xs
+        | x::xs            -> removeTail n xs (x::acc)
+        | []               -> List.rev acc
+    removeTail n list []
+
+let rec private calculateTotalCostHelper books priceSoFar =
+    match books |> List.length with
+    | 0 -> priceSoFar
+    | _ ->
+        let groups =
+            books
+            |> List.groupBy id
+            |> List.map fst
+        
+        let prices =
+            [1 .. groups |> List.length]
+            |> List.map (fun i ->
+                let itemsToRemove =
+                    groups
+                    |> List.take i
+
+                let remaining =
+                    itemsToRemove
+                    |> List.fold (fun state t ->
+                        remove t state)
+                        books
+
+                calculateTotalCostHelper remaining (priceSoFar + costPerGroup i)
+            )
+        
+        prices
+        |> List.min
+
+let calculateTotalCost books =
+    calculateTotalCostHelper books 0.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.0.5.9
+  version: 2.0.5.10
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-24 00:00:00.000000000 Z
+date: 2016-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -1333,6 +1333,8 @@ files:
 - tracks/csharp/exercises/food-chain/FoodChainTest.cs
 - tracks/csharp/exercises/gigasecond/Example.cs
 - tracks/csharp/exercises/gigasecond/GigasecondTest.cs
+- tracks/csharp/exercises/go-counting/Example.cs
+- tracks/csharp/exercises/go-counting/GoCountingTest.cs
 - tracks/csharp/exercises/grade-school/Example.cs
 - tracks/csharp/exercises/grade-school/GradeSchoolTest.cs
 - tracks/csharp/exercises/grains/Example.cs
@@ -2420,6 +2422,8 @@ files:
 - tracks/fsharp/exercises/binary-search/Example.fs
 - tracks/fsharp/exercises/bob/BobTest.fs
 - tracks/fsharp/exercises/bob/Example.fs
+- tracks/fsharp/exercises/book-store/BookStoreTest.fs
+- tracks/fsharp/exercises/book-store/Example.fs
 - tracks/fsharp/exercises/bowling/BowlingTest.fs
 - tracks/fsharp/exercises/bowling/Example.fs
 - tracks/fsharp/exercises/bracket-push/BracketPushTest.fs