trackler 2.0.5.8 → 2.0.5.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a0e02be1736f9ad6f815b3593e22e0338b90bb5
-  data.tar.gz: f6a8a9b2ee6b9afaa21cee8f4fdce3b2962b6db4
+  metadata.gz: d1f9e78737566c55c139024513a73f38029f2a0c
+  data.tar.gz: 853360aad86762df2a9279f3ad209e4497c739ad
 SHA512:
-  metadata.gz: cab4b14cee19781307d566eed637b27a43e1dd980f9227881a1b9c066bee293ebabd741850259e437d3c42248bbc758ef97daadb4275cfe7e105c4e751a1b609
-  data.tar.gz: 9ccafd1cfc519b3903983fa6e291ca8f0f77afbc2be851144e8edc12416f3280b74e983e501d5beb93d7b63d5d84fafe70480f91a44031e9783c04df26e92762
+  metadata.gz: 1517522938b3420f81dd931fb53458a99858c61e4673ec0413c120fc9aff827306e257fb5a316a21a2b771c12ae8a859ea943b53967ade8471031c9761e139e6
+  data.tar.gz: 527684182f9afe7b3e1e4a8b9fbc0a07e1a60dc0272d1188efb311678f065d4eb49118f5c059a87bb6d8a6daf0158a20e06dea9d45c69c746b01effb5541c3ed

data/common/exercises/sum-of-multiples/description.md

@@ -3,5 +3,5 @@ multiples of either 3 or 5, we get 3, 5, 6 and 9, 10, 12, 15, and 18.
 
 The sum of these multiples is 78.
 
-Write a program that can find the sum of the multiples of a given set of
-numbers.
+Write a program that, given a number, can find the sum of the multiples
+of a given set of numbers, up to but not including that number.

data/lib/trackler/version.rb

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

data/tracks/csharp/config.json

@@ -560,6 +560,15 @@
         "Transforming"
       ]
     },
+    {
+      "slug": "markdown",
+      "difficulty": 5,
+      "topics": [
+        "Parsing",
+        "Transforming",
+        "Refactoring"
+      ]
+    },
     {
       "slug": "run-length-encoding",
       "difficulty": 5,
@@ -568,6 +577,13 @@
         "Transforming"
       ]
     },
+    {
+      "slug": "book-store",
+      "difficulty": 5,
+      "topics": [
+        "Recursion"
+      ]
+    },
     {
       "slug": "tournament",
       "difficulty": 6,
@@ -706,6 +722,14 @@
         "Logic"
       ]
     },
+    {
+      "slug": "connect",
+      "difficulty": 8,
+      "topics": [
+        "Parsing",
+        "Transforming"
+      ]
+    },
     {
       "slug": "say",
       "difficulty": 8,

data/tracks/csharp/exercises/book-store/BookStoreTest.cs

@@ -0,0 +1,95 @@
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+
+[TestFixture]
+public class BookStoreTest
+{
+    [Test]
+    public void Basket_with_single_book()
+    {
+        Assert.That(BookStore.CalculateTotalCost(MakeList(1)), Is.EqualTo(8));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Basket_with_two_of_same_book()
+    {
+        Assert.That(BookStore.CalculateTotalCost(MakeList(2, 2)), Is.EqualTo(16));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Empty_basket()
+    {
+        Assert.That(BookStore.CalculateTotalCost(MakeList()), Is.EqualTo(0));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Basket_with_two_different_books()
+    {
+        Assert.That(BookStore.CalculateTotalCost(MakeList(1, 2)), Is.EqualTo(15.2));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Basket_with_three_different_books()
+    {
+        Assert.That(BookStore.CalculateTotalCost(MakeList(1, 2, 3)), Is.EqualTo(21.6));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Basket_with_four_different_books()
+    {
+        Assert.That(BookStore.CalculateTotalCost(MakeList(1, 2, 3, 4)), Is.EqualTo(25.6));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Basket_with_five_different_books()
+    {
+        Assert.That(BookStore.CalculateTotalCost(MakeList(1, 2, 3, 4, 5)), Is.EqualTo(30));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Basket_with_eight_books()
+    {
+        Assert.That(BookStore.CalculateTotalCost(MakeList(1, 1, 2, 2, 3, 3, 4, 5)), Is.EqualTo(51.20));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Basket_with_nine_books()
+    {
+        Assert.That(BookStore.CalculateTotalCost(MakeList(1, 1, 2, 2, 3, 3, 4, 4, 5)), Is.EqualTo(55.60));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Basket_with_ten_books()
+    {
+        Assert.That(BookStore.CalculateTotalCost(MakeList(1, 1, 2, 2, 3, 3, 4, 4, 5, 5)), Is.EqualTo(60));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Basket_with_eleven_books()
+    {
+        Assert.That(BookStore.CalculateTotalCost(MakeList(1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1)), Is.EqualTo(68));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Basket_with_twelve_books()
+    {
+        Assert.That(BookStore.CalculateTotalCost(MakeList(1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1, 2)), Is.EqualTo(75.20));
+    }
+
+    private static List<int> MakeList(params int[] values)
+    {
+        return values.ToList();
+    }
+}

data/tracks/csharp/exercises/book-store/Example.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public class BookStore
+{
+    public static double CalculateTotalCost(List<int> books)
+    {
+        return CalculateTotalCost(books, 0);
+    }
+
+    private static double CalculateTotalCost(List<int> books, double priceSoFar)
+    {
+        if (books.Count == 0)
+        {
+            return priceSoFar;
+        }
+
+        var groups = books
+            .GroupBy(b => b)
+            .Select(g => g.Key)
+            .ToList();
+
+        var minPrice = double.MaxValue;
+
+        for (int i = groups.Count; i >= 1; i--)
+        {
+            var itemsToRemove = groups.Take(i).ToList();
+            var remaining = books.ToList();
+
+            foreach (var item in itemsToRemove)
+            {
+                remaining.Remove(item);
+            }
+
+            var price = CalculateTotalCost(remaining.ToList(), priceSoFar + CostPerGroup(i));
+            minPrice = Math.Min(minPrice, price);
+        }
+
+        return minPrice;
+    }
+
+    private static double CostPerGroup(int groupSize)
+    {
+        double discountPercentage;
+
+        switch (groupSize)
+        {
+            case 1:
+                discountPercentage = 0;
+                break;
+            case 2:
+                discountPercentage = 5;
+                break;
+            case 3:
+                discountPercentage = 10;
+                break;
+            case 4:
+                discountPercentage = 20;
+                break;
+            case 5:
+                discountPercentage = 25;
+                break;
+            default:
+                throw new InvalidOperationException($"Invalid group size: {groupSize}");
+        }
+        
+        return 8 * groupSize * (100 - discountPercentage) / 100;
+    }
+}

data/tracks/csharp/exercises/connect/ConnectTest.cs

@@ -0,0 +1,131 @@
+using NUnit.Framework;
+using System.Linq;
+
+public class ConnectTest
+{
+    private static string MakeBoard(string[] board)
+    {
+        return string.Join("\n", board.Select(x => x.Replace(" ", "")));
+    }
+
+    [Test]
+    public void Empty_board_has_no_winner()
+    {
+        var lines = new[] 
+            {
+                ". . . . .    ",
+                " . . . . .   ",
+                "  . . . . .  ",
+                "   . . . . . ",
+                "    . . . . ."
+            };
+        var board = new Connect(MakeBoard(lines));
+        Assert.That(board.Result(), Is.EqualTo(Connect.Winner.None));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void One_by_one_board_with_black_stone()
+    {
+        var lines = new[] { "X" };
+        var board = new Connect(MakeBoard(lines));
+        Assert.That(board.Result(), Is.EqualTo(Connect.Winner.Black));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void One_by_one_board_with_white_stone()
+    {
+        var lines = new[] { "O" };
+        var board = new Connect(MakeBoard(lines));
+        Assert.That(board.Result(), Is.EqualTo(Connect.Winner.White));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Convoluted_path()
+    {
+        var lines = new[] 
+            {
+                ". X X . .    ",
+                " X . X . X   ",
+                "  . X . X .  ",
+                "   . X X . . ",
+                "    O O O O O"
+            };
+        var board = new Connect(MakeBoard(lines));
+        Assert.That(board.Result(), Is.EqualTo(Connect.Winner.Black));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Rectangle_black_wins()
+    {
+        var lines = new[] 
+            {
+                ". O . .    ",
+                " O X X X   ",
+                "  O X O .  ",
+                "   X X O X ",
+                "    . O X ."
+            };
+        var board = new Connect(MakeBoard(lines));
+        Assert.That(board.Result(), Is.EqualTo(Connect.Winner.Black));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Rectangle_white_wins()
+    {
+        var lines = new[] 
+            {
+                ". O . .    ",
+                " O X X X   ",
+                "  O O O .  ",
+                "   X X O X ",
+                "    . O X ."
+            };
+        var board = new Connect(MakeBoard(lines));
+        Assert.That(board.Result(), Is.EqualTo(Connect.Winner.White));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Spiral_black_wins()
+    {
+        var lines = new[]
+            {
+            "OXXXXXXXX",
+            "OXOOOOOOO",
+            "OXOXXXXXO",
+            "OXOXOOOXO",
+            "OXOXXXOXO",
+            "OXOOOXOXO",
+            "OXXXXXOXO",
+            "OOOOOOOXO",
+            "XXXXXXXXO"
+        };
+        var board = new Connect(MakeBoard(lines));
+        Assert.That(board.Result(), Is.EqualTo(Connect.Winner.Black));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Spiral_nobody_wins()
+    {
+        var lines = new[]
+            {
+            "OXXXXXXXX",
+            "OXOOOOOOO",
+            "OXOXXXXXO",
+            "OXOXOOOXO",
+            "OXOX.XOXO",
+            "OXOOOXOXO",
+            "OXXXXXOXO",
+            "OOOOOOOXO",
+            "XXXXXXXXO"
+        };
+        var board = new Connect(MakeBoard(lines));
+        Assert.That(board.Result(), Is.EqualTo(Connect.Winner.None));
+    }
+}

data/tracks/csharp/exercises/connect/Example.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+
+public class Connect
+{
+    public enum Winner
+    {
+        White,
+        Black,
+        None
+    }
+
+    public enum Cell
+    {
+        Empty,
+        White,
+        Black
+    }
+
+    private readonly Cell[][] board;
+
+    public Connect(string input)
+    {
+        board = ParseBoard(input);
+    }
+
+    private static Cell CharToCell(char c)
+    {
+        switch (c)
+        {
+            case 'O': return Cell.White;
+            case 'X': return Cell.Black;
+            default: return Cell.Empty;
+        }
+    }
+
+    private static Cell[][] ParseBoard(string input)
+    {
+        var split = input.Split('\n');
+        var rows = split.Length;
+        var cols = split[0].Length;
+
+        return split.Select(row => row.Select(CharToCell).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 bool CellAtCoordinateEquals(Cell cell, Point coordinate) => board[coordinate.Y][coordinate.X] == cell;
+
+    private HashSet<Point> Adjacent(Cell cell, Point coordinate)
+    {
+        var row = coordinate.Y;
+        var col = coordinate.X;
+
+        var coords = new[]
+        {
+            new Point(col + 1, row - 1),
+            new Point(col,     row - 1),
+            new Point(col - 1, row    ),
+            new Point(col + 1, row    ),
+            new Point(col - 1, row + 1),
+            new Point(col,     row + 1)
+        };
+
+        return new HashSet<Point>(coords.Where(coord => IsValidCoordinate(coord) && CellAtCoordinateEquals(cell, coord)));
+    }
+    
+    private bool ValidPath(Cell cell, Func<Cell[][], Point, bool> stop, HashSet<Point> processed, Point coordinate)
+    {
+        if (stop(board, coordinate))
+            return true;
+
+        var next = Adjacent(cell, coordinate);
+        next.ExceptWith(processed);
+        
+        if (!next.Any())
+            return false;
+
+        return next.Any(nextCoord => {
+            var updatedProcessed = new HashSet<Point>(processed);
+            updatedProcessed.Add(nextCoord);
+
+            return ValidPath(cell, stop, updatedProcessed, nextCoord);
+        });
+    }   
+
+    private bool IsWhiteStop(Cell[][] board, Point coordinate) => coordinate.Y == Rows - 1;
+    private bool IsBlackStop(Cell[][] board, Point coordinate) => coordinate.X == Cols - 1;
+
+    private HashSet<Point> WhiteStart() =>
+        new HashSet<Point>(Enumerable.Range(0, Cols).Select(col => new Point(col, 0)).Where(coord => CellAtCoordinateEquals(Cell.White, coord)));
+        
+    private HashSet<Point> BlackStart() =>
+        new HashSet<Point>(Enumerable.Range(0, Rows).Select(row => new Point(0, row)).Where(coord => CellAtCoordinateEquals(Cell.Black, coord)));
+
+    private bool ColorWins(Cell cell, Func<Cell[][], Point, bool> stop, Func<HashSet<Point>> start)
+    {
+        return start().Any(coordinate => ValidPath(cell, stop, new HashSet<Point>(), coordinate));
+    }
+
+    private bool WhiteWins() => ColorWins(Cell.White, IsWhiteStop, WhiteStart);
+    private bool BlackWins() => ColorWins(Cell.Black, IsBlackStop, BlackStart);        
+    
+    public Winner Result()
+    {
+        if (WhiteWins())
+            return Winner.White;
+
+        if (BlackWins())
+            return Winner.Black;
+
+        return Winner.None;
+    }
+}

data/tracks/csharp/exercises/exercises.csproj

@@ -38,7 +38,7 @@
     <Reference Include="Microsoft.CSharp" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="**\*.cs" Exclude="sgf-parsing\SgfParsing.cs" />
+    <Compile Include="**\*.cs" Exclude="sgf-parsing\SgfParsing.cs;markdown\Markdown.cs" />
   </ItemGroup>
   <ItemGroup>
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />

data/tracks/csharp/exercises/markdown/Example.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+public static class Markdown
+{
+    private static string OpeningTag(string tag) => $"<{tag}>";
+    private static string ClosingTag(string tag) => $"</{tag}>";
+    private static string WrapInTag(this string text, string tag) => $"{OpeningTag(tag)}{text}{ClosingTag(tag)}";
+    private static bool StartsWithTag(this string text, string tag) => text.StartsWith(OpeningTag(tag));
+
+    private const string HeaderMarkdown = "#";
+    private const string BoldMarkdown = "__";
+    private const string ItalicMarkdown = "_";
+    private const string ListItemMarkdown = "*";
+
+    private const string BoldTag = "em";
+    private const string ItalicTag = "i";
+    private const string ParagraphTag = "p";
+    private const string ListTag = "ul";
+    private const string ListItemTag = "li";
+
+    private static string ParseDelimited(this string markdown, string delimiter, string tag)
+    {
+        var pattern = $"{delimiter}(.+){delimiter}";
+        var replacement = "$1".WrapInTag(tag);
+        return Regex.Replace(markdown, pattern, replacement);
+    }
+
+    private static string ParseBold(this string markdown) => markdown.ParseDelimited(BoldMarkdown, BoldTag);
+    private static string ParseItalic(this string markdown) => markdown.ParseDelimited(ItalicMarkdown, ItalicTag);
+
+    private static string ParseText(this string markdown, bool list)
+    {
+        var textHtml = markdown
+            .ParseBold()
+            .ParseItalic();
+
+        return list ? textHtml : textHtml.WrapInTag(ParagraphTag);
+    }
+
+    private static Tuple<bool, string> ParseHeader(this string markdown, bool list)
+    {
+        var headerNumber =
+            markdown
+                .TakeWhile(c => c == HeaderMarkdown[0])
+                .Count();
+
+        if (headerNumber == 0)
+            return null;
+
+        var headerTag = $"h{headerNumber}";
+        var headerHtml = markdown.Substring(headerNumber + 1).WrapInTag(headerTag);
+        var html = list ? ClosingTag(ListTag) + headerHtml : headerHtml;
+
+        return Tuple.Create(false, html);
+    }
+
+    private static Tuple<bool, string> ParseLineItem(this string markdown, bool list)
+    {
+        if (!markdown.StartsWith(ListItemMarkdown))
+            return null;
+
+        var innerHtml =
+            markdown
+                .Substring(2)
+                .ParseText(true)
+                .WrapInTag(ListItemTag);
+
+        var html = list ? innerHtml : OpeningTag(ListTag) + innerHtml;
+        return Tuple.Create(true, html);
+    }
+
+    private static Tuple<bool, string> ParseParagraph(this string markdown, bool list)
+    {
+        if (list)
+            return Tuple.Create(false, ClosingTag(ListTag) + markdown.ParseText(list));
+
+        return Tuple.Create(false, markdown.ParseText(list));
+    }
+
+    private static Tuple<bool, string> ParseLine(Tuple<bool, string> accumulator, string markdown)
+    {
+        var list = accumulator.Item1;
+        var html = accumulator.Item2;
+
+        var result =
+            markdown.ParseHeader(list) ??
+            markdown.ParseLineItem(list) ??
+            markdown.ParseParagraph(list);
+
+        if (result == null)
+            throw new ArgumentException("Invalid markdown");
+
+        return Tuple.Create(result.Item1, html + result.Item2);
+    }
+
+    public static string Parse(string markdown)
+    {
+        var lines = markdown.Split('\n');
+        var result = lines.Aggregate(Tuple.Create(false, ""), ParseLine);
+
+        var list = result.Item1;
+        var html = result.Item2;
+
+        return list ? html + ClosingTag(ListTag) : html;
+    }
+}

data/tracks/csharp/exercises/markdown/HINTS.md

@@ -0,0 +1,3 @@
+## Hints
+For this exercise the following C# feature comes in handy:
+- [String Interpolation](https://msdn.microsoft.com/en-us/library/dn961160.aspx) (C# 6 and up).

data/tracks/csharp/exercises/markdown/Markdown.cs

@@ -0,0 +1,151 @@
+using System;
+using System.Text.RegularExpressions;
+
+public static class Markdown
+{
+    private static string Wrap(string text, string tag) => "<" + tag + ">" + text + "</" + tag + ">";
+
+    private static bool IsTag(string text, string tag) => text.StartsWith("<" + tag + ">");
+
+    private static string Parse(string markdown, string delimiter, string tag)
+    {
+        var pattern = delimiter + "(.+)" + delimiter;
+        var replacement = "<" + tag + ">$1</" + tag + ">";
+        return Regex.Replace(markdown, pattern, replacement);
+    }
+
+    private static string Parse__(string markdown) => Parse(markdown, "__", "em");
+
+    private static string Parse_(string markdown) => Parse(markdown, "_", "i");
+
+    private static string ParseText(string markdown, bool list)
+    {
+        var parsedText = Parse_(Parse__((markdown)));
+
+        if (list)
+        {
+            return parsedText;
+        }
+        else
+        {
+            return Wrap(parsedText, "p");
+        }
+    }
+
+    private static string ParseHeader(string markdown, bool list, out bool inListAfter)
+    {
+        var count = 0;
+
+        for (int i = 0; i < markdown.Length; i++)
+        {
+            if (markdown[i] == '#')
+            {
+                count += 1;
+            }
+            else
+            {
+                break;
+            }
+        }
+
+        if (count == 0)
+        {
+            inListAfter = list;
+            return null;
+        }
+
+        var headerTag = "h" + count;
+        var headerHtml = Wrap(markdown.Substring(count + 1), headerTag);
+
+        if (list)
+        {
+            inListAfter = false;
+            return "</ul>" + headerHtml;
+        }
+        else
+        {
+            inListAfter = false;
+            return headerHtml;
+        }
+    }
+
+    private static string ParseLineItem(string markdown, bool list, out bool inListAfter)
+    {
+        if (markdown.StartsWith("*"))
+        {
+            var innerHtml = Wrap(ParseText(markdown.Substring(2), true), "li");
+
+            if (list)
+            {
+                inListAfter = true;
+                return innerHtml;
+            }
+            else
+            {
+                inListAfter = true;
+                return "<ul>" + innerHtml;
+            }
+        }
+
+        inListAfter = list;
+        return null;
+    }
+
+    private static string ParseParagraph(string markdown, bool list, out bool inListAfter)
+    {
+        if (!list)
+        {
+            inListAfter = false;
+            return ParseText(markdown, list);
+        }
+        else
+        {
+            inListAfter = false;
+            return "</ul>" + ParseText(markdown, list);
+        }
+    }
+
+    private static string ParseLine(string markdown, bool list, out bool inListAfter)
+    {
+        var result = ParseHeader(markdown, list, out inListAfter);
+
+        if (result == null)
+        {
+            result = ParseLineItem(markdown, list, out inListAfter);
+        }
+
+        if (result == null)
+        {
+            result = ParseParagraph(markdown, list, out inListAfter);
+        }
+
+        if (result == null)
+        {
+            throw new ArgumentException("Invalid markdown");
+        }
+
+        return result;
+    }
+
+    public static string Parse(string markdown)
+    {
+        var lines = markdown.Split('\n');
+        var result = "";
+        var list = false;
+
+        for (int i = 0; i < lines.Length; i++)
+        {
+            var lineResult = ParseLine(lines[i], list, out list);
+            result += lineResult;
+        }
+
+        if (list)
+        {
+            return result + "</ul>";
+        }
+        else
+        {
+            return result;
+        }
+    }
+}

data/tracks/csharp/exercises/markdown/MarkdownTest.cs

@@ -0,0 +1,76 @@
+using NUnit.Framework;
+
+public class MarkdownTest
+{
+    [Test]
+    public void Parses_normal_text_as_a_paragraph()
+    {
+        var input = "This will be a paragraph";
+        var expected = "<p>This will be a paragraph</p>";
+        Assert.That(Markdown.Parse(input), Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void Parsing_italics()
+    {
+        var input = "_This will be italic_";
+        var expected = "<p><i>This will be italic</i></p>";
+        Assert.That(Markdown.Parse(input), Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void Parsing_bold_text()
+    {
+        var input = "__This will be bold__";
+        var expected = "<p><em>This will be bold</em></p>";
+        Assert.That(Markdown.Parse(input), Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void Mixed_normal_italics_and_bold_text()
+    {
+        var input = "This will _be_ __mixed__";
+        var expected = "<p>This will <i>be</i> <em>mixed</em></p>";
+        Assert.That(Markdown.Parse(input), Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void With_h1_header_level()
+    {
+        var input = "# This will be an h1";
+        var expected = "<h1>This will be an h1</h1>";
+        Assert.That(Markdown.Parse(input), Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void With_h2_header_level()
+    {
+        var input = "## This will be an h2";
+        var expected = "<h2>This will be an h2</h2>";
+        Assert.That(Markdown.Parse(input), Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void With_h6_header_level()
+    {
+        var input = "###### This will be an h6";
+        var expected = "<h6>This will be an h6</h6>";
+        Assert.That(Markdown.Parse(input), Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void Unordered_lists()
+    {
+        var input = "* Item 1\n* Item 2";
+        var expected = "<ul><li>Item 1</li><li>Item 2</li></ul>";
+        Assert.That(Markdown.Parse(input), Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void With_a_little_bit_of_everything()
+    {
+        var input = "# Header!\n* __Bold Item__\n* _Italic Item_";
+        var expected = "<h1>Header!</h1><ul><li><em>Bold Item</em></li><li><i>Italic Item</i></li></ul>";
+        Assert.That(Markdown.Parse(input), Is.EqualTo(expected));
+    }
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.0.5.8
+  version: 2.0.5.9
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-23 00:00:00.000000000 Z
+date: 2016-12-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -1298,6 +1298,8 @@ files:
 - tracks/csharp/exercises/binary-search/Example.cs
 - tracks/csharp/exercises/bob/BobTest.cs
 - tracks/csharp/exercises/bob/Example.cs
+- tracks/csharp/exercises/book-store/BookStoreTest.cs
+- tracks/csharp/exercises/book-store/Example.cs
 - tracks/csharp/exercises/bowling/BowlingTest.cs
 - tracks/csharp/exercises/bowling/Example.cs
 - tracks/csharp/exercises/bracket-push/BracketPushTest.cs
@@ -1308,6 +1310,8 @@ files:
 - tracks/csharp/exercises/circular-buffer/Example.cs
 - tracks/csharp/exercises/clock/ClockTest.cs
 - tracks/csharp/exercises/clock/Example.cs
+- tracks/csharp/exercises/connect/ConnectTest.cs
+- tracks/csharp/exercises/connect/Example.cs
 - tracks/csharp/exercises/crypto-square/CryptoSquareTest.cs
 - tracks/csharp/exercises/crypto-square/Example.cs
 - tracks/csharp/exercises/custom-set/CustomSetTest.cs
@@ -1356,6 +1360,10 @@ files:
 - tracks/csharp/exercises/list-ops/ListOpsTest.cs
 - tracks/csharp/exercises/luhn/Example.cs
 - tracks/csharp/exercises/luhn/LuhnTest.cs
+- tracks/csharp/exercises/markdown/Example.cs
+- tracks/csharp/exercises/markdown/HINTS.md
+- tracks/csharp/exercises/markdown/Markdown.cs
+- tracks/csharp/exercises/markdown/MarkdownTest.cs
 - tracks/csharp/exercises/matrix/Example.cs
 - tracks/csharp/exercises/matrix/MatrixTest.cs
 - tracks/csharp/exercises/meetup/Example.cs