trackler 1.0.0 → 1.0.0.1

data/tracks/csharp/exercises/paket.references

@@ -1 +1,2 @@
-NUnit
+NUnit
+Sprache

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

@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public static class Poker
+{
+    private struct Card
+    {
+        public int Rank;
+        public int Suit;
+    }
+
+    private struct Hand
+    {
+        public string Input;
+        public int Score;
+    }
+
+    public static IEnumerable<string> BestHands(IEnumerable<string> hands)
+    {
+        var scoredHands = hands.Select(ParseHand).ToArray();
+        var maxScore = scoredHands.Max(h => h.Score);
+        return scoredHands.Where(h => h.Score == maxScore).Select(h => h.Input).ToList();
+    }
+
+    private static Hand ParseHand(string hand) => new Hand { Input = hand, Score = ScoreHand(ParseCards(hand)) };
+
+    private static Card[] ParseCards(string hand) => hand.Split(' ').Select(ParseCard).OrderByDescending(c => c.Rank).ToArray();
+
+    private static Card ParseCard(string card) => new Card { Rank = ParseRank(card), Suit = ParseSuit(card) };
+    
+    private static int ParseRank(string card) => "..23456789TJQKA".IndexOf(card[0]);
+
+    private static int ParseSuit(string card) => ".HSDC".IndexOf(card[1]);
+    
+    private static int ScoreHand(Card[] cards)
+    {
+        var cardsByRank = cards
+            .GroupBy(c => c.Rank)
+            .OrderByDescending(c => c.Count())
+            .Select(g => g.Max(c => c.Rank))
+            .ToArray();
+
+        var rankCounts = cards
+            .GroupBy(c => c.Rank)
+            .Select(g => g.Count())
+            .OrderByDescending(c => c)
+            .ToArray();
+        
+        var ranks = cards.Select(c => c.Rank).ToArray();
+        var suits = cards.Select(c => c.Suit).ToArray();
+
+        if (ranks.SequenceEqual(new[] { 14, 5, 4, 3, 2 }))
+        {
+            ranks = new[] { 1, 2, 3, 4, 5 };
+        }
+        
+        var flush = suits.Distinct().Count() == 1;
+        var straight = ranks.Distinct().Count() == 5 && ranks[0] - ranks[4] == 4;
+        
+        if (straight && flush)
+        {
+            return 800 + ranks.First();
+        }
+        if (rankCounts.SequenceEqual(new [] { 4, 1 }))
+        {
+            return 700 + cardsByRank[0];
+        }
+        if (rankCounts.SequenceEqual(new[] { 3, 2 }))
+        {
+            return 600 + cardsByRank[0];
+        }
+        if (flush)
+        {
+            return 500 + ranks.First();
+        }
+        if (straight)
+        {
+            return 400 + ranks.First();
+        }
+        if (rankCounts.SequenceEqual(new[] { 3, 1, 1 }))
+        {
+            return 300 + cardsByRank[0];
+        }
+        if (rankCounts.SequenceEqual(new[] { 2, 2, 1 }))
+        {
+            return 200 + Math.Max(cardsByRank[0], cardsByRank[1]);
+        }
+        if (rankCounts.SequenceEqual(new[] { 2, 1, 1, 1 }))
+        {
+            return 100 + cardsByRank[0];
+        }
+
+        return ranks.Max();
+    }
+}

data/tracks/csharp/exercises/poker/PokerTest.cs

@@ -0,0 +1,171 @@
+using NUnit.Framework;
+
+public class PokerTest
+{
+    [Test]
+    public void One_hand()
+    {
+        const string hand = "4S 5S 7H 8D JC";
+        Assert.That(Poker.BestHands(new[] { hand }), Is.EqualTo(new[] { hand }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Nothing_vs_one_pair()
+    {
+        const string nothing = "4S 5H 6S 8D JH";
+        const string pairOf4 = "2S 4H 6S 4D JH";
+        Assert.That(Poker.BestHands(new[] { nothing, pairOf4 }), Is.EqualTo(new[] { pairOf4 }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Two_pairs()
+    {
+        const string pairOf2 = "4S 2H 6S 2D JH";
+        const string pairOf4 = "2S 4H 6S 4D JH";
+        Assert.That(Poker.BestHands(new[] { pairOf2, pairOf4 }), Is.EqualTo(new[] { pairOf4 }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void One_pair_vs_double_pair()
+    {
+        const string pairOf8 = "2S 8H 6S 8D JH";
+        const string doublePair = "4S 5H 4S 8D 5H";
+        Assert.That(Poker.BestHands(new[] { pairOf8, doublePair }), Is.EqualTo(new[] { doublePair }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Two_double_pairs()
+    {
+        const string doublePair2And8 = "2S 8H 2S 8D JH";
+        const string doublePair4And5 = "4S 5H 4S 8D 5H";
+        Assert.That(Poker.BestHands(new[] { doublePair2And8, doublePair4And5 }), Is.EqualTo(new[] { doublePair2And8 }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Double_pair_vs_three()
+    {
+        const string doublePair2And8 = "2S 8H 2S 8D JH";
+        const string threeOf4 = "4S 5H 4S 8D 4H";
+        Assert.That(Poker.BestHands(new[] { doublePair2And8, threeOf4 }), Is.EqualTo(new[] { threeOf4 }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Two_threes()
+    {
+        const string threeOf2 = "2S 2H 2S 8D JH";
+        const string threeOf1 = "4S AH AS 8D AH";
+        Assert.That(Poker.BestHands(new[] { threeOf2, threeOf1 }), Is.EqualTo(new[] { threeOf1 }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Three_vs_straight()
+    {
+        const string threeOf4 = "4S 5H 4S 8D 4H";
+        const string straight = "3S 4H 2S 6D 5H";
+        Assert.That(Poker.BestHands(new[] { threeOf4, straight }), Is.EqualTo(new[] { straight }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Two_straights()
+    {
+        const string straightTo8 = "4S 6H 7S 8D 5H";
+        const string straightTo9 = "5S 7H 8S 9D 6H";
+        Assert.That(Poker.BestHands(new[] { straightTo8, straightTo9 }), Is.EqualTo(new[] { straightTo9 }));
+        
+        const string straightTo1 = "AS QH KS TD JH";
+        const string straightTo5 = "4S AH 3S 2D 5H";
+        Assert.That(Poker.BestHands(new[] { straightTo1, straightTo5 }), Is.EqualTo(new[] { straightTo1 }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Straight_vs_flush()
+    {
+        const string straightTo8 = "4S 6H 7S 8D 5H";
+        const string flushTo7 = "2S 4S 5S 6S 7S";
+        Assert.That(Poker.BestHands(new[] { straightTo8, flushTo7 }), Is.EqualTo(new[] { flushTo7 }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Two_flushes()
+    {
+        const string flushTo8 = "3H 6H 7H 8H 5H";
+        const string flushTo7 = "2S 4S 5S 6S 7S";
+        Assert.That(Poker.BestHands(new[] { flushTo8, flushTo7 }), Is.EqualTo(new[] { flushTo8 }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Flush_vs_full()
+    {
+        const string flushTo8 = "3H 6H 7H 8H 5H";
+        const string full = "4S 5H 4S 5D 4H";
+        Assert.That(Poker.BestHands(new[] { full, flushTo8 }), Is.EqualTo(new[] { full }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Two_fulls()
+    {
+        const string fullOf4By9 = "4H 4S 4D 9S 9D";
+        const string fullOf5By8 = "5H 5S 5D 8S 8D";
+        Assert.That(Poker.BestHands(new[] { fullOf4By9, fullOf5By8 }), Is.EqualTo(new[] { fullOf5By8 }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Full_vs_square()
+    {
+        const string full = "4S 5H 4S 5D 4H";
+        const string squareOf3 = "3S 3H 2S 3D 3H";
+        Assert.That(Poker.BestHands(new[] { full, squareOf3 }), Is.EqualTo(new[] { squareOf3 }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Two_squares()
+    {
+        const string squareOf2 = "2S 2H 2S 8D 2H";
+        const string squareOf5 = "4S 5H 5S 5D 5H";
+        Assert.That(Poker.BestHands(new[] { squareOf2, squareOf5 }), Is.EqualTo(new[] { squareOf5 }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Square_vs_straight_flush()
+    {
+        const string squareOf5 = "4S 5H 5S 5D 5H";
+        const string straightFlushTo9 = "5S 7S 8S 9S 6S";
+        Assert.That(Poker.BestHands(new[] { squareOf5, straightFlushTo9 }), Is.EqualTo(new[] { straightFlushTo9 }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Two_straight_flushes()
+    {
+        const string straightFlushTo8 = "4H 6H 7H 8H 5H";
+        const string straightFlushTo9 = "5S 7S 8S 9S 6S";
+        Assert.That(Poker.BestHands(new[] { straightFlushTo8, straightFlushTo9 }),
+            Is.EqualTo(new[] { straightFlushTo9 }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Three_hand_with_tie()
+    {
+        const string spadeStraightTo9 = "9S 8S 7S 6S 5S";
+        const string diamondStraightTo9 = "9D 8D 7D 6D 5D";
+        const string threeOf4 = "4D 4S 4H QS KS";
+        Assert.That(Poker.BestHands(new[] { spadeStraightTo9, diamondStraightTo9, threeOf4 }),
+            Is.EqualTo(new[] { spadeStraightTo9, diamondStraightTo9 }));
+    }
+}

data/tracks/csharp/exercises/sgf-parsing/Example.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Sprache;
+
+public class SgfTree
+{
+    public IDictionary<string, string[]> Data { get; }
+    public SgfTree[] Children { get; }
+
+    public SgfTree(IDictionary<string, string[]> data, params SgfTree[] children)
+    {
+        Data = data;
+        Children = children;
+    }
+}
+
+public static class SgfParser
+{
+    private static char Unescape(char c) => c == 'n' || c == 'r' || c == 't' ? ' ' : c;
+    private static string ToString(IEnumerable<char> chars) => new string(chars.ToArray());
+
+    private static readonly Parser<char> NormalChar = Parse.Char(c => c != '\\' && c != ']', "Normal char");
+    private static readonly Parser<char> EscapedChar = Parse.Char('\\').Then(_ => Parse.AnyChar.Token().Select(Unescape));
+    private static readonly Parser<string> CValueType = EscapedChar.Or(NormalChar).Many().Select(ToString);
+    private static readonly Parser<string> PropValue = CValueType.Contained(Parse.Char('['), Parse.Char(']'));
+    private static readonly Parser<string> PropIdent = Parse.Char(char.IsUpper, "Upper case character").Select(c => c.ToString());
+    private static readonly Parser<IDictionary<string, string[]>> Property = PropIdent.Then(ident => PropValue.Many().Select(values => PropertyToData(ident, values)));
+    private static readonly Parser<IDictionary<string, string[]>> Node = Parse.Char(';').Then(_ => Property.Optional().Select(o => o.GetOrDefault() ?? new Dictionary<string, string[]>()));
+
+    private static Parser<SgfTree> GameTree() => 
+        Parse.Char('(').Then(c => 
+            Node.AtLeastOnce().Then(nodes => 
+                GameTree().Many().Then(trees => Parse.Char(')')
+                    .Select(___ => NodesToTree(nodes, trees)))));
+
+    public static SgfTree ParseTree(string input) => GameTree().Parse(input);
+    
+    private static SgfTree NodesToTree(IEnumerable<IDictionary<string, string[]>> properties, IEnumerable<SgfTree> trees)
+    {
+        var numberOfProperties = properties.Count();
+
+        if (numberOfProperties == 0)
+        {
+            throw new InvalidOperationException("Can only create tree from non-empty nodes list");
+        }
+
+        if (numberOfProperties == 1)
+        {
+            return new SgfTree(properties.First(), trees.ToArray());
+        }
+
+        return new SgfTree(properties.First(), NodesToTree(properties.Skip(1), trees));
+    }
+
+    private static IDictionary<string, string[]> PropertyToData(string key, IEnumerable<string> values) =>
+        new Dictionary<string, string[]>
+        {
+            [key] = values.ToArray()
+        };
+}

data/tracks/csharp/exercises/sgf-parsing/SgfParsing.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+
+public class SgfTree
+{
+    public IDictionary<string, string[]> Data { get; }
+    public SgfTree[] Children { get; }
+
+    public SgfTree(IDictionary<string, string[]> data, params SgfTree[] children)
+    {
+        Data = data;
+        Children = children;
+    }
+}

data/tracks/csharp/exercises/sgf-parsing/SgfParsingTest.cs

@@ -0,0 +1,158 @@
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+
+public class SgfParsingTest
+{
+    // This exercises requires you to do somewhat more complicated parsing.
+    // This is the perfect exercise to get to know a parser library, of which
+    // there are several available. A simple one is Sprache (https://github.com/sprache/Sprache),
+    // a more complex one is Antlr (http://www.antlr.org/). You can also build
+    // your own parser of course!
+
+    // A tree consists of two parts:
+    // - The node's data: a map of type Dictionary<string, string list> 
+    // - A list of children (which are itself trees)
+
+    private static SgfTree TreeWithChildren(IDictionary<string, string[]> data, SgfTree[] children) => new SgfTree(data, children);
+    private static SgfTree TreeWithSingleChild(IDictionary<string, string[]> data, SgfTree child) => new SgfTree(data, child);
+    private static SgfTree TreeWithNoChildren(IDictionary<string, string[]> data) => new SgfTree(data);
+
+    private static IDictionary<string, string[]> CreateData(string key, params string[] values) => new Dictionary<string, string[]> { [key] = values };
+    
+    [Test]
+    public void Empty_value()
+    {
+        const string input = "";
+        Assert.That(() => SgfParser.ParseTree(input), Throws.Exception);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Tree_without_nodes()
+    {
+        const string input = "()";
+        Assert.That(() => SgfParser.ParseTree(input), Throws.Exception);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Node_without_tree()
+    {
+        const string input = ";";
+        Assert.That(() => SgfParser.ParseTree(input), Throws.Exception);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Node_without_properties()
+    {
+        const string input = "(;)";
+        var expected = TreeWithNoChildren(new Dictionary<string, string[]>());
+        Assert.That(SgfParser.ParseTree(input), Is.EqualTo(expected).Using(SgfTreeEqualityComparer.Instance));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Single_node_tree()
+    {
+        const string input = "(;A[B])";
+        var expected = TreeWithNoChildren(CreateData("A", "B"));
+        Assert.That(SgfParser.ParseTree(input), Is.EqualTo(expected).Using(SgfTreeEqualityComparer.Instance));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Properties_without_delimiter()
+    {
+        const string input = "(;a)";
+        Assert.That(() => SgfParser.ParseTree(input), Throws.Exception);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void All_lowercase_property()
+    {
+        const string input = "(;a[b])";
+        Assert.That(() => SgfParser.ParseTree(input), Throws.Exception);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Upper_and_lowercase_property()
+    {
+        const string input = "(;Aa[b])";
+        Assert.That(() => SgfParser.ParseTree(input), Throws.Exception);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Two_nodes()
+    {
+        const string input = "(;A[B];B[C])";
+        var expected = TreeWithSingleChild(CreateData("A", "B"), TreeWithNoChildren(CreateData("B", "C")));
+        Assert.That(SgfParser.ParseTree(input), Is.EqualTo(expected).Using(SgfTreeEqualityComparer.Instance));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Two_child_trees()
+    {
+        const string input = "(;A[B](;B[C])(;C[D]))";
+        var expected = TreeWithChildren(CreateData("A", "B"), 
+                            new[]
+                            {
+                                TreeWithNoChildren(CreateData("B", "C")),
+                                TreeWithNoChildren(CreateData("C", "D"))
+                            });
+        Assert.That(SgfParser.ParseTree(input), Is.EqualTo(expected).Using(SgfTreeEqualityComparer.Instance));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Multiple_properties()
+    {
+        const string input = "(;A[b][c][d])";
+        var expected = TreeWithNoChildren(CreateData("A", "b", "c", "d"));
+        Assert.That(SgfParser.ParseTree(input), Is.EqualTo(expected).Using(SgfTreeEqualityComparer.Instance));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Escaped_property()
+    {
+        const string input = @"(;A[\]b\nc\nd\t\te \n\]])";
+        var expected = TreeWithNoChildren(CreateData("A", @"]b c d  e  ]"));
+        Assert.That(SgfParser.ParseTree(input), Is.EqualTo(expected).Using(SgfTreeEqualityComparer.Instance));
+    }
+
+    private class SgfTreeEqualityComparer : IEqualityComparer<SgfTree>
+    {
+        public static readonly SgfTreeEqualityComparer Instance = new SgfTreeEqualityComparer();
+
+        public bool Equals(SgfTree x, SgfTree y)
+        {
+            return SgfDataEqualityComparer.Instance.Equals(x.Data, y.Data) && x.Children.SequenceEqual(y.Children, Instance);
+        }
+
+        public int GetHashCode(SgfTree obj)
+        {
+            throw new System.NotImplementedException();
+        }
+    }
+
+    private class SgfDataEqualityComparer : IEqualityComparer<IDictionary<string, string[]>>
+    {
+        public static readonly SgfDataEqualityComparer Instance = new SgfDataEqualityComparer();
+
+        public bool Equals(IDictionary<string, string[]> x, IDictionary<string, string[]> y)
+        {
+            return x.Keys.SequenceEqual(y.Keys) && x.Keys.All(key => x[key].SequenceEqual(y[key]));
+        }
+
+        public int GetHashCode(IDictionary<string, string[]> obj)
+        {
+            throw new System.NotImplementedException();
+        }
+    }
+}