trackler 2.0.6.11 → 2.0.6.12

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

@@ -0,0 +1,139 @@
+using Sprache;
+using System.Collections.Generic;
+using System.Linq;
+using System;
+
+public static class Alphametics
+{
+    public static IDictionary<char, int> Solve(string equation)
+    {
+        var expression = ExpressionParser.Equation.Parse(equation);
+        
+        var maps = GetValidMaps(expression.Chars, expression.StartChars);
+        return maps.First(map => expression.Solve(map) == 0);
+    }
+    
+    private static IEnumerable<IDictionary<char, int>> GetValidMaps(HashSet<char> chars, HashSet<char> startChars)
+        => GetMaps(chars, startChars).Where(map => IsValidMap(map, startChars));
+
+    private static IEnumerable<IDictionary<char, int>> GetMaps(HashSet<char> chars, HashSet<char> startChars)
+        => GetDigitPermutations(chars.Count).Select(digits => GetMap(digits, chars));
+
+    private static IEnumerable<IEnumerable<int>> GetDigitPermutations(int length) 
+        => Enumerable.Range(0, 10).Permutations(length);
+
+    private static IDictionary<char, int> GetMap(IEnumerable<int> digits, IEnumerable<char> chars)
+        => digits.Zip(chars, (i, c) => new KeyValuePair<char, int>(c, i)).ToDictionary(x => x.Key, x => x.Value);
+
+    private static bool IsValidMap(IDictionary<char, int> map, IEnumerable<char> startChars) =>
+        !startChars.Any(c => map[c] == 0);
+}
+
+public static class EnumerableExtensions
+{
+    public static IEnumerable<IEnumerable<T>> Permutations<T>(this IEnumerable<T> input, int length)
+    {
+        if (length == 1)
+            return input.Select(t => new T[] { t });
+
+        return Permutations(input, length - 1)
+            .SelectMany(t => input.Where(o => !t.Contains(o)),
+                (t1, t2) => t1.Concat(new T[] { t2 }));
+    }
+}
+
+public enum ExpressionType
+{
+    Add,
+    Equal
+}
+
+public abstract class Expression
+{
+    public abstract HashSet<char> Chars { get; }
+    public abstract HashSet<char> StartChars { get; }
+    public abstract int Solve(IDictionary<char, int> mapping);
+}
+
+public class PlaceholderExpression : Expression
+{
+    public PlaceholderExpression(string value)
+    {
+        Value = value;
+        Chars = new HashSet<char>(value);
+        StartChars = new HashSet<char> { value[0] };
+    }
+
+    public override HashSet<char> Chars { get; }
+    public override HashSet<char> StartChars { get; }
+
+    public string Value { get; }
+
+    public static PlaceholderExpression Create(string value) => new PlaceholderExpression(value);
+
+    public override int Solve(IDictionary<char, int> mapping) => Value.Aggregate(0, (acc, x) => acc * 10 + mapping[x]);
+}
+
+public abstract class BinaryExpression : Expression
+{
+    public BinaryExpression(Expression left, Expression right)
+    {
+        Left = left;
+        Right = right;
+
+        Chars = new HashSet<char>(Left.Chars);
+        Chars.UnionWith(Right.Chars);
+
+        StartChars = new HashSet<char>(Left.StartChars);
+        StartChars.UnionWith(Right.StartChars);
+    }
+
+    public Expression Left { get; }
+    public Expression Right { get; }
+
+    public override HashSet<char> Chars { get; }
+    public override HashSet<char> StartChars { get; }
+
+    public static BinaryExpression Create(ExpressionType type, Expression left, Expression right)
+    {
+        switch (type)
+        {
+            case ExpressionType.Add:
+                return new AddExpression(left, right);
+            case ExpressionType.Equal:
+                return new EqualExpression(left, right);
+            default:
+                throw new InvalidOperationException("Invalid expression");
+        }
+    }
+}
+
+public class AddExpression : BinaryExpression
+{
+    public AddExpression(Expression left, Expression right) : base(left, right)
+    {
+    }
+
+    public override int Solve(IDictionary<char, int> mapping) => Left.Solve(mapping) + Right.Solve(mapping);
+}
+
+public class EqualExpression : BinaryExpression
+{
+    public EqualExpression(Expression left, Expression right) : base(left, right)
+    {
+    }
+
+    public override int Solve(IDictionary<char, int> mapping) => Left.Solve(mapping) - Right.Solve(mapping);
+}
+
+public static class ExpressionParser
+{
+    public static Parser<ExpressionType> Operator(string op, ExpressionType operatorType)
+        => Parse.String(op).Token().Return(operatorType);
+
+    public static readonly Parser<ExpressionType> Add = Operator("+", ExpressionType.Add);
+    public static readonly Parser<ExpressionType> Equality = Operator("==", ExpressionType.Equal);
+    public static readonly Parser<Expression> Operand = Parse.Upper.AtLeastOnce().Text().Select(PlaceholderExpression.Create);
+    public static readonly Parser<Expression> Expr = Parse.ChainOperator(Add, Operand, BinaryExpression.Create);
+    public static readonly Parser<Expression> Equation = Parse.ChainOperator(Equality, Expr, BinaryExpression.Create);
+}

data/tracks/csharp/exercises/dot-dsl/DotDslTest.cs

@@ -0,0 +1,91 @@
+using NUnit.Framework;
+
+public class DotDslTest
+{
+    [Test]
+    public void Empty_graph()
+    {
+        var g = new Graph();
+
+        Assert.That(g.Nodes, Is.Empty);
+        Assert.That(g.Edges, Is.Empty);
+        Assert.That(g.Attrs, Is.Empty);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Graph_with_one_node()
+    {
+        var g = new Graph
+        {
+            new Node("a")
+        };
+
+        Assert.That(g.Nodes, Is.EquivalentTo(new[] { new Node("a") }));
+        Assert.That(g.Edges, Is.Empty);
+        Assert.That(g.Attrs, Is.Empty);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Graph_with_one_node_with_keywords()
+    {
+        var g = new Graph
+        {
+            new Node("a") { { "color", "green" } }
+        };
+
+        Assert.That(g.Nodes, Is.EquivalentTo(new[] { new Node("a") { { "color", "green" } } }));
+        Assert.That(g.Edges, Is.Empty);
+        Assert.That(g.Attrs, Is.Empty);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Graph_with_one_edge()
+    {
+        var g = new Graph
+        {
+            new Edge("a", "b")
+        };
+
+        Assert.That(g.Nodes, Is.Empty);
+        Assert.That(g.Edges, Is.EquivalentTo(new[] { new Edge("a", "b") }));
+        Assert.That(g.Attrs, Is.Empty);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Graph_with_one_attribute()
+    {
+        var g = new Graph
+        {
+            { "foo", "1" }
+        };
+
+        Assert.That(g.Nodes, Is.Empty);
+        Assert.That(g.Edges, Is.Empty);
+        Assert.That(g.Attrs, Is.EquivalentTo(new[] { new Attr("foo", "1") }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Graph_with_attributes()
+    {
+        var g = new Graph
+        {
+            { "foo", "1" },
+            { "title", "Testing Attrs" },
+            new Node("a") { { "color", "green" } },
+            new Node("c"),
+            new Node("b") { {  "label", "Beta!" } },
+            new Edge("b", "c"),
+            new Edge("a", "b") { { "color", "blue" } },
+            { "bar", "true" }
+        };
+
+        Assert.That(g.Nodes, Is.EquivalentTo(new[] { new Node("a") { { "color", "green" } }, new Node("b") { { "label", "Beta!" } }, new Node("c") }));
+        Assert.That(g.Edges, Is.EquivalentTo(new[] { new Edge("a", "b") { { "color", "blue" } }, new Edge("b", "c") }));
+        Assert.That(g.Attrs, Is.EquivalentTo(new[] { new Attr("bar", "true"), new Attr("foo", "1"), new Attr("title", "Testing Attrs") }));
+    }
+}

data/tracks/csharp/exercises/dot-dsl/Example.cs

@@ -0,0 +1,90 @@
+using System.Collections;
+using System.Collections.Generic;
+
+public class Node : Element
+{
+    public Node(string name)
+    {
+        Name = name;
+    }
+
+    public string Name { get; }
+
+    public override bool Equals(object obj)
+    {
+        if (obj == null || GetType() != obj.GetType())
+            return false;
+
+        return ((Node)obj).Name == Name;
+    }
+
+    public override int GetHashCode() => Name.GetHashCode();
+}
+
+public class Edge : Element
+{
+    public Edge(string node1, string node2)
+    {
+        Node1 = node1;
+        Node2 = node2;
+    }
+
+    public string Node1 { get; }
+    public string Node2 { get; }
+
+    public override bool Equals(object obj)
+    {
+        if (obj == null || GetType() != obj.GetType())
+            return false;
+
+        return ((Edge)obj).Node1 == Node1 && ((Edge)obj).Node2 == Node2;
+    }
+
+    public override int GetHashCode() => Node1.GetHashCode() ^ Node2.GetHashCode();
+}
+
+
+public class Attr
+{
+    public Attr(string key, string value)
+    {
+        Key = key;
+        Value = value;
+    }
+
+    public string Key { get; }
+    public string Value { get; }
+
+    public override bool Equals(object obj)
+    {
+        if (obj == null || GetType() != obj.GetType())
+            return false;
+
+        return ((Attr)obj).Key == Key && ((Attr)obj).Value == Value;
+    }
+
+    public override int GetHashCode() => Key.GetHashCode() ^ Value.GetHashCode();
+}
+
+public class Graph : Element
+{
+    private List<Node> nodes = new List<Node>();
+    private List<Edge> edges = new List<Edge>();
+
+    public IEnumerable<Node> Nodes => nodes;
+    public IEnumerable<Edge> Edges => edges;
+    public IEnumerable<Attr> Attrs => attrs;
+
+    public void Add(Node node) => nodes.Add(node);
+    public void Add(Edge edge) => edges.Add(edge);
+}
+
+public abstract class Element : IEnumerable<Attr>
+{
+    protected List<Attr> attrs = new List<Attr>();
+
+    public void Add(string key, string value) => attrs.Add(new Attr(key, value));
+
+    public IEnumerator<Attr> GetEnumerator() => attrs.GetEnumerator();
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+}

data/tracks/csharp/exercises/dot-dsl/HINTS.md

@@ -0,0 +1,2 @@
+## Hints
+This exercise requires you to implement classes with a custom equality check. For more information, see [this page](https://msdn.microsoft.com/en-us/library/bsc2ak47(v=vs.110).aspx).

data/tracks/csharp/exercises/error-handling/ErrorHandlingTest.cs

@@ -0,0 +1,65 @@
+using System;
+using NUnit.Framework;
+
+[TestFixture]
+public class ErrorHandlingTest
+{
+    // Read more about exception handling here:
+    // https://msdn.microsoft.com/en-us/library/ms173162.aspx?f=255&MSPPError=-2147217396
+    [TestCase]
+    public void ThrowException()
+    {
+        Assert.Throws<Exception>(ErrorHandling.HandleErrorByThrowingException);
+    }
+
+    // Read more about nullable types here:
+    // https://msdn.microsoft.com/en-us/library/1t3y8s4s.aspx?f=255&MSPPError=-2147217396
+    [TestCase]
+    [Ignore("Remove to run test")]
+    public void ReturnNullableType()
+    {
+        var successfulResult = ErrorHandling.HandleErrorByReturningNullableType("1");
+        Assert.That(successfulResult, Is.EqualTo(1));
+
+        var failureResult = ErrorHandling.HandleErrorByReturningNullableType("a");
+        Assert.That(failureResult, Is.EqualTo(null));
+    }
+
+    // Read more about out parameters here:
+    // https://msdn.microsoft.com/en-us/library/t3c3bfhx.aspx?f=255&MSPPError=-2147217396
+    [TestCase]
+    [Ignore("Remove to run test")]
+    public void ReturnWithOutParameter()
+    {
+        int result;
+        var successfulResult = ErrorHandling.HandleErrorWithOutParam("1", out result);
+        Assert.That(successfulResult, Is.EqualTo(true));
+        Assert.That(result, Is.EqualTo(1));
+        
+        var failureResult = ErrorHandling.HandleErrorWithOutParam("a", out result);
+        Assert.That(failureResult, Is.EqualTo(false));
+        // The value of result is meaningless here (it could be anything) so it shouldn't be used and it's not validated 
+    }
+
+    private class DisposableResource : IDisposable
+    {
+        public bool IsDisposed { get; private set; }
+
+        public void Dispose()
+        {
+            IsDisposed = true;
+        }
+    }
+
+    // Read more about IDisposable here:
+    // https://msdn.microsoft.com/en-us/library/system.idisposable(v=vs.110).aspx
+    [TestCase]
+    [Ignore("Remove to run test")]
+    public void DisposableObjectsAreDisposedWhenThrowingAnException()
+    {
+        var disposbaleResource = new DisposableResource();
+
+        Assert.Throws<Exception>(() => ErrorHandling.DisposableResourcesAreDisposedWhenExceptionIsThrown(disposbaleResource));
+        Assert.That(disposbaleResource.IsDisposed, Is.EqualTo(true));
+    }
+}

data/tracks/csharp/exercises/error-handling/Example.cs

@@ -0,0 +1,34 @@
+using System;
+
+public static class ErrorHandling
+{
+    public static void HandleErrorByThrowingException()
+    {
+        throw new Exception("An error occured.");
+    }
+
+    public static int? HandleErrorByReturningNullableType(string input)
+    {
+        int result;
+
+        if (int.TryParse(input, out result))
+        {
+            return result;
+        }
+
+        return null;
+    }
+
+    public static bool HandleErrorWithOutParam(string input, out int result)
+    {
+        return int.TryParse(input, out result);
+    }
+
+    public static void DisposableResourcesAreDisposedWhenExceptionIsThrown(IDisposable disposableObject)
+    {
+        using (disposableObject)
+        {
+            throw new Exception("An error occured.");
+        }
+    }
+}

data/tracks/csharp/exercises/exercises.csproj

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

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

@@ -0,0 +1,85 @@
+using System.Collections.Generic;
+using System.Linq;
+
+public delegate void HangmanChangedEventHandler(object sender, HangmanState state);
+
+public class HangmanState
+{
+    public HangmanGame.Status Status { get; set; }
+    public int RemainingGuesses { get; set; }
+    public string MaskedWord { get; set; }
+    public HashSet<char> Guesses { get; set; }
+}
+
+public class HangmanGame
+{
+    private const int NumberOfAllowedGuesses = 9;
+    private const char UnguessedCharacterPlaceHolder = '_';
+
+    private readonly string word;
+    private readonly HangmanState state;
+
+    public enum Status
+    {
+        Busy,
+        Win,
+        Lose
+    }
+
+    public HangmanGame(string word)
+    {
+        this.word = word;
+
+        state = new HangmanState
+        {
+            RemainingGuesses = NumberOfAllowedGuesses,
+            Guesses = new HashSet<char>()
+        };
+
+        UpdateMaskedWord();
+        UpdateStatus();
+    }
+
+    public event HangmanChangedEventHandler StateChanged;
+
+    public void Start()
+    {
+        StateChanged?.Invoke(this, state);
+    }
+
+    public void Guess(char c)
+    {
+        UpdateRemainingGuesses(c);
+        UpdateMaskedWord();
+        UpdateStatus();
+
+        StateChanged?.Invoke(this, state);
+    }
+
+    private void UpdateRemainingGuesses(char c)
+    {
+        if (UnknownCharacter(c) || CharacterAlreadyGuessed(c))
+            state.RemainingGuesses--;
+
+        state.Guesses.Add(c);
+    }
+
+    private bool UnknownCharacter(char c) => word.All(x => x != c);
+
+    private bool CharacterAlreadyGuessed(char c) => state.Guesses.Contains(c);    
+
+    private void UpdateMaskedWord()
+    {
+        state.MaskedWord = new string(word.Select(c => state.Guesses.Contains(c) ? c : UnguessedCharacterPlaceHolder).ToArray());
+    }
+
+    private void UpdateStatus()
+    {
+        if (state.MaskedWord == word)
+            state.Status = Status.Win;
+        else if (state.RemainingGuesses < 0)
+            state.Status = Status.Lose;        
+        else
+            state.Status = Status.Busy;
+    }
+}

data/tracks/csharp/exercises/hangman/HangmanTest.cs

@@ -0,0 +1,140 @@
+using NUnit.Framework;
+
+public class HangmanTest
+{
+    [Test]
+    public void Initially_9_failures_are_allowed()
+    {
+        var game = new HangmanGame("foo");
+
+        HangmanState lastState = null;
+        game.StateChanged += (sender, state) => lastState = state;
+
+        game.Start();
+
+        Assert.That(lastState.Status, Is.EqualTo(HangmanGame.Status.Busy));
+        Assert.That(lastState.RemainingGuesses, Is.EqualTo(9));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Initially_no_letters_are_guessed()
+    {
+        var game = new HangmanGame("foo");
+        
+        HangmanState lastState = null;
+        game.StateChanged += (sender, state) => lastState = state;
+
+        game.Start();
+
+        Assert.That(lastState.MaskedWord, Is.EqualTo("___"));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void After_10_failures_the_game_is_over()
+    {
+        var game = new HangmanGame("foo");
+        
+        HangmanState lastState = null;
+        game.StateChanged += (sender, state) => lastState = state;
+
+        game.Start();
+
+        for (var i = 0; i < 10; i++)
+        {
+            game.Guess('x');
+        }
+
+        Assert.That(lastState.Status, Is.EqualTo(HangmanGame.Status.Lose));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Feeding_a_correct_letter_removes_underscores()
+    {
+        var game = new HangmanGame("foobar");
+
+        HangmanState lastState = null;
+        game.StateChanged += (sender, state) => lastState = state;
+
+        game.Start();
+
+        game.Guess('b');
+
+        Assert.That(lastState.Status, Is.EqualTo(HangmanGame.Status.Busy));
+        Assert.That(lastState.RemainingGuesses, Is.EqualTo(9));
+        Assert.That(lastState.MaskedWord, Is.EqualTo("___b__"));
+
+        game.Guess('o');
+
+        Assert.That(lastState.Status, Is.EqualTo(HangmanGame.Status.Busy));
+        Assert.That(lastState.RemainingGuesses, Is.EqualTo(9));
+        Assert.That(lastState.MaskedWord, Is.EqualTo("_oob__"));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Feeding_a_correct_letter_twice_counts_as_a_failure()
+    {
+        var game = new HangmanGame("foobar");
+        
+        HangmanState lastState = null;
+        game.StateChanged += (sender, state) => lastState = state;
+
+        game.Start();
+
+        game.Guess('b');
+
+        Assert.That(lastState.Status, Is.EqualTo(HangmanGame.Status.Busy));
+        Assert.That(lastState.RemainingGuesses, Is.EqualTo(9));
+        Assert.That(lastState.MaskedWord, Is.EqualTo("___b__"));
+
+        game.Guess('b');
+
+        Assert.That(lastState.Status, Is.EqualTo(HangmanGame.Status.Busy));
+        Assert.That(lastState.RemainingGuesses, Is.EqualTo(8));
+        Assert.That(lastState.MaskedWord, Is.EqualTo("___b__"));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Getting_all_the_letters_right_makes_for_a_win()
+    {
+        var game = new HangmanGame("hello");
+        
+        HangmanState lastState = null;
+        game.StateChanged += (sender, state) => lastState = state;
+
+        game.Start();
+
+        game.Guess('b');
+
+        Assert.That(lastState.Status, Is.EqualTo(HangmanGame.Status.Busy));
+        Assert.That(lastState.RemainingGuesses, Is.EqualTo(8));
+        Assert.That(lastState.MaskedWord, Is.EqualTo("_____"));
+
+        game.Guess('e');
+
+        Assert.That(lastState.Status, Is.EqualTo(HangmanGame.Status.Busy));
+        Assert.That(lastState.RemainingGuesses, Is.EqualTo(8));
+        Assert.That(lastState.MaskedWord, Is.EqualTo("_e___"));
+
+        game.Guess('l');
+
+        Assert.That(lastState.Status, Is.EqualTo(HangmanGame.Status.Busy));
+        Assert.That(lastState.RemainingGuesses, Is.EqualTo(8));
+        Assert.That(lastState.MaskedWord, Is.EqualTo("_ell_"));
+
+        game.Guess('o');
+
+        Assert.That(lastState.Status, Is.EqualTo(HangmanGame.Status.Busy));
+        Assert.That(lastState.RemainingGuesses, Is.EqualTo(8));
+        Assert.That(lastState.MaskedWord, Is.EqualTo("_ello"));
+
+        game.Guess('h');
+
+        Assert.That(lastState.Status, Is.EqualTo(HangmanGame.Status.Win));
+        Assert.That(lastState.MaskedWord, Is.EqualTo("hello"));
+    }
+}