trackler 2.0.5.14 → 2.0.5.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ec7742a72a8b9cb40403f1fa21b731c45a0e949c
-  data.tar.gz: 659146e560273f0e3fc0e1c1830d46d63e4c6c53
+  metadata.gz: 640bf7c491e8a9613de8e88ee23185a2ccfe7114
+  data.tar.gz: dc1a5b2fd961f1bea01631d313ce1ebf9ef8497f
 SHA512:
-  metadata.gz: 8209ff1442ff1dd4a05810ca4d608e3bcc16e121e628d7dfde8611b6baf0239da3e031062c4ecdd263d4a142a993686e42161f650db166b7a8497c1a3ceeb442
-  data.tar.gz: 20053304e9f4973b491bc7cc7ee2dcb1a671699dedbab5dbcd232c7ba83f2efcc3e1269fa3de6cd7b7c3617b37cbb8d73338ebebd70ed64e199ccfd5ab58d811
+  metadata.gz: 90d0a3630526b437476b6a2a3c08b9a4b538550972b606f503ad8092b344e668d5642aa52d02ad5b93f99eb6bd6c17fdd69f271274f0da60c77b2482f5103b65
+  data.tar.gz: 77cb6e64a0f978ee41e62bb23d86b49c0ed9cdaa789f5cfab0167735ab9058138da1b5326992ac87f6afc0cd03fd0790f9ce2c2066aee028c6512bfb0d790c6f

data/common/exercises/perfect-numbers/metadata.yml

@@ -1,4 +1,4 @@
 ---
-blurb: "The Greek mathematician Nicomachus devised a classification scheme for natural numbers."
+blurb: "Determine if a number is perfect, abundant, or deficient based on Nicomachus' (60 - 120 CE) classification scheme for natural numbers."
 source: "Taken from Chapter 2 of Functional Thinking by Neal Ford."
 source_url: "http://shop.oreilly.com/product/0636920029687.do"

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.5.14"
+  VERSION = "2.0.5.15"
 end

data/tracks/csharp/config.json

@@ -486,6 +486,14 @@
         "Lists"
       ]
     },
+    {
+      "slug": "tree-building",
+      "difficulty": 5,
+      "topics": [
+        "Trees",
+        "Refactoring"
+      ]
+    },
     {
       "slug": "scale-generator",
       "difficulty": 5,
@@ -739,6 +747,15 @@
         "Text formatting"
       ]
     },
+    {
+      "slug": "react",
+      "difficulty": 9,
+      "topics": [
+        "Reactive programming",
+        "Classes",
+        "Events"
+      ]
+    },
     {
       "slug": "variable-length-quantity",
       "difficulty": 9,

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" />
+    <Compile Include="**\*.cs" Exclude="sgf-parsing\SgfParsing.cs;markdown\Markdown.cs;tree-building\TreeBuilding.cs" />
   </ItemGroup>
   <ItemGroup>
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />

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

@@ -0,0 +1,124 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+public delegate void ChangedEventHandler(object sender, int value);
+
+public class Reactor
+{
+    private readonly Dictionary<int, Cell> cells = new Dictionary<int, Cell>();
+
+    public InputCell CreateInputCell(int value)
+    {
+        var inputCell = new InputCell(cells.Count, value);
+        inputCell.Changed += CellChanged;
+
+        cells[inputCell.Id] = inputCell;        
+
+        return inputCell;
+    }
+
+    public ComputeCell CreateComputeCell(IEnumerable<Cell> producers, Func<int[], int> compute)
+    {
+        var computeCell = new ComputeCell(cells.Count, producers, compute);
+        cells[computeCell.Id] = computeCell;
+
+        return computeCell;
+    }
+
+    private void CellChanged(object sender, int value)
+    {
+        var cell = (Cell)sender;
+        var consumers = new BitArray(cells.Count);
+        
+        foreach (var consumer in cell.Consumers)
+            consumers.Set(consumer.Id, true);
+
+        for (var id = cell.Id + 1; id < cells.Count; id++)
+        {
+            if (!consumers.Get(id))
+                continue;
+
+            var consumer = (ComputeCell)cells[id];
+            consumer.Recompute();
+
+            foreach (var transitiveConsumer in consumer.Consumers)
+                consumers.Set(transitiveConsumer.Id, true);
+        }
+    }
+}
+
+public abstract class Cell
+{
+    public Cell(int id)
+    {
+        Id = id;
+        Consumers = new List<Cell>();
+    }
+
+    public int Id { get; }
+    public List<Cell> Consumers { get; }
+    
+    public abstract int Value { get; set; }
+    public abstract event ChangedEventHandler Changed;
+}
+
+public class InputCell : Cell
+{
+    private int _value;
+
+    public InputCell(int id, int value) : base(id)
+    {
+        _value = value;
+    }
+
+    public override event ChangedEventHandler Changed;
+
+    public override int Value
+    {
+        get
+        {
+            return _value;
+        }
+        set
+        {
+            if (_value == value)
+                return;
+
+            _value = value;
+            Changed?.Invoke(this, _value);
+        }
+    }   
+}
+
+public class ComputeCell : Cell
+{
+    private readonly IEnumerable<Cell> producers;
+    private readonly Func<int[], int> compute;
+    
+    public ComputeCell(int id, IEnumerable<Cell> producers, Func<int[], int> compute) : base(id)
+    {
+        this.producers = producers;
+        this.compute = compute;
+
+        foreach (var producer in producers)
+            producer.Consumers.Add(this);
+
+        Recompute();
+    }
+
+    public override int Value { get; set; }
+    public override event ChangedEventHandler Changed;
+
+    public void Recompute()
+    {
+        var updatedValue = compute(producers.Select(producer => producer.Value).ToArray());
+
+        if (updatedValue == Value)
+            return;
+        
+        Value = updatedValue;
+        Changed?.Invoke(this, updatedValue);
+    }
+}

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

@@ -0,0 +1,3 @@
+## Hints
+In this exercise the following C# feature is used:
+- [Events](https://msdn.microsoft.com/en-us/library/9aackb16(v=vs.110).aspx).

data/tracks/csharp/exercises/react/ReactTest.cs

@@ -0,0 +1,121 @@
+using NUnit.Framework;
+using System.Collections.Generic;
+
+public class ReactTest
+{
+    [Test]
+    public void Setting_the_value_of_an_input_cell_changes_the_observable_value()
+    {
+        var reactor = new Reactor();
+        var inputCell1 = reactor.CreateInputCell(1);
+
+        Assert.That(inputCell1.Value, Is.EqualTo(1));
+        inputCell1.Value = 2;
+        Assert.That(inputCell1.Value, Is.EqualTo(2));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void The_value_of_a_compute_is_determined_by_the_value_of_the_dependencies()
+    {
+        var reactor = new Reactor();
+        var inputCell1 = reactor.CreateInputCell(1);
+        var computeCell1 = reactor.CreateComputeCell(new[] { inputCell1 }, (values) => values[0] + 1);
+
+        Assert.That(computeCell1.Value, Is.EqualTo(2));
+        inputCell1.Value = 2;
+        Assert.That(computeCell1.Value, Is.EqualTo(3));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Compute_cells_can_depend_on_other_compute_cells()
+    {
+        var reactor = new Reactor();
+        var inputCell1 = reactor.CreateInputCell(1);
+        var computeCell1 = reactor.CreateComputeCell(new[] { inputCell1 }, (values) => values[0] + 1);
+        var computeCell2 = reactor.CreateComputeCell(new[] { inputCell1 }, (values) => values[0] - 1);
+        var computeCell3 = reactor.CreateComputeCell(new[] { computeCell1, computeCell2 }, (values) => values[0] * values[1]);
+
+        Assert.That(computeCell3.Value, Is.EqualTo(0));
+        inputCell1.Value = 3;
+        Assert.That(computeCell3.Value, Is.EqualTo(8));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Compute_cells_can_have_callbacks()
+    {
+        var reactor = new Reactor();
+        var inputCell1 = reactor.CreateInputCell(1);
+        var computeCell1 = reactor.CreateComputeCell(new[] { inputCell1 }, (values) => values[0] + 1);
+        var observed = new List<int>();
+        computeCell1.Changed += (sender, value) => observed.Add(value);
+
+        Assert.That(observed, Is.Empty);
+        inputCell1.Value = 2;
+        Assert.That(observed, Is.EquivalentTo(new[] { 3 }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Callbacks_only_trigger_on_change()
+    {
+        var reactor = new Reactor();
+        var inputCell1 = reactor.CreateInputCell(1);
+        var computecell1 = reactor.CreateComputeCell(new[] { inputCell1 }, (values) => values[0] > 2 ? values[0] + 1 : 2);
+        var observerCalled = 0;
+        computecell1.Changed += (sender, value) => observerCalled++;
+
+        inputCell1.Value = 1;
+        Assert.That(observerCalled, Is.EqualTo(0));
+        inputCell1.Value = 2;
+        Assert.That(observerCalled, Is.EqualTo(0));
+        inputCell1.Value = 3;
+        Assert.That(observerCalled, Is.EqualTo(1));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Callbacks_can_be_removed()
+    {
+        var reactor = new Reactor();
+        var inputCell1 = reactor.CreateInputCell(1);
+        var computeCell1 = reactor.CreateComputeCell(new[] { inputCell1 }, (values) => values[0] + 1);
+        var observed1 = new List<int>();
+        var observed2 = new List<int>();
+
+        ChangedEventHandler changedHandler1 = (object sender, int value) => observed1.Add(value);
+        ChangedEventHandler changedHandler2 = (object sender, int value) => observed2.Add(value);
+
+        computeCell1.Changed += changedHandler1;
+        computeCell1.Changed += changedHandler2;
+
+        inputCell1.Value = 2;
+        Assert.That(observed1, Is.EquivalentTo(new[] { 3 }));
+        Assert.That(observed2, Is.EquivalentTo(new[] { 3 }));
+
+        computeCell1.Changed -= changedHandler1;
+        inputCell1.Value = 3;
+        Assert.That(observed1, Is.EquivalentTo(new[] { 3 }));
+        Assert.That(observed2, Is.EquivalentTo(new[] { 3, 4 }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Callbacks_should_only_be_called_once_even_if_multiple_dependencies_have_changed()
+    {
+        var reactor = new Reactor();
+        var inputCell1 = reactor.CreateInputCell(1);
+        var computeCell1 = reactor.CreateComputeCell(new[] { inputCell1 }, (values) => values[0] + 1);
+        var computeCell2 = reactor.CreateComputeCell(new[] { inputCell1 }, (values) => values[0] - 1);
+        var computeCell3 = reactor.CreateComputeCell(new[] { computeCell2 }, (values) => values[0] - 1);
+        var computeCell4 = reactor.CreateComputeCell(new[] { computeCell1, computeCell3 }, (values) => values[0] * values[1]);
+
+        var changed4 = 0;
+        computeCell4.Changed += (sender, value) => changed4++;
+
+        inputCell1.Value = 3;
+        Assert.That(changed4, Is.EqualTo(1));
+    }
+}

data/tracks/csharp/exercises/tree-building/Example.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public class TreeBuildingRecord
+{
+    private const int RootRecordId = 0;
+
+    public int ParentId { get; set; }
+    public int RecordId { get; set; }
+
+    public bool IsRoot => RecordId == RootRecordId;
+}
+
+public class Tree
+{
+    public Tree(int id)
+    {
+        Id = id;
+        Children = new List<Tree>();
+    }
+
+    public int Id { get; }
+
+    public List<Tree> Children { get; }
+
+    public bool IsLeaf => Children.Count == 0;
+}
+
+public static class TreeBuilder
+{
+    private const int RootRecordId = 0;
+
+    public static Tree BuildTree(IEnumerable<TreeBuildingRecord> records)
+    {
+        var orderedRecords = GetOrderedRecords(records);
+
+        if (orderedRecords.Count == 0)
+            throw new ArgumentException();
+
+        var nodes = new Dictionary<int, Tree>();
+        var previousRecordId = -1;
+
+        foreach (var record in orderedRecords)
+        {
+            ValidateRecord(record, previousRecordId);
+
+            nodes[record.RecordId] = new Tree(record.RecordId);
+
+            if (!record.IsRoot)
+                nodes[record.ParentId].Children.Add(nodes[record.RecordId]);
+
+            previousRecordId++;
+        }
+
+        return nodes[RootRecordId];
+    }
+
+    private static void ValidateRecord(TreeBuildingRecord record, int previousRecordId)
+    {
+        if (record.IsRoot && record.ParentId != RootRecordId)
+            throw new ArgumentException();
+        else if (!record.IsRoot && record.ParentId >= record.RecordId)
+            throw new ArgumentException();
+        else if (!record.IsRoot && record.RecordId != previousRecordId + 1)
+            throw new ArgumentException();
+    }
+
+    private static List<TreeBuildingRecord> GetOrderedRecords(IEnumerable<TreeBuildingRecord> records)
+    {
+        return records.OrderBy(record => record.RecordId).ToList();
+    }
+}

data/tracks/csharp/exercises/tree-building/TreeBuilding.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public class TreeBuildingRecord
+{
+    public int ParentId { get; set; }
+    public int RecordId { get; set; }
+}
+
+public class Tree
+{
+    public int Id { get; set; }
+    public int ParentId { get; set; }
+
+    public List<Tree> Children { get; set; }
+
+    public bool IsLeaf => Children.Count == 0;
+}
+
+public static class TreeBuilder
+{
+    public static Tree BuildTree(IEnumerable<TreeBuildingRecord> records)
+    {
+        var ordered = new SortedList<int, TreeBuildingRecord>();
+
+        foreach (var record in records)
+        {
+            ordered.Add(record.RecordId, record);
+        }
+
+        records = ordered.Values;
+
+        var trees = new List<Tree>();
+        var previousRecordId = -1;
+
+        foreach (var record in records)
+        {   
+            var t = new Tree { Children = new List<Tree>(), Id = record.RecordId, ParentId = record.ParentId };
+            trees.Add(t);
+
+            if ((t.Id == 0 && t.ParentId != 0) ||
+                (t.Id != 0 && t.ParentId >= t.Id) ||
+                (t.Id != 0 && t.Id != previousRecordId + 1))
+            {
+                throw new ArgumentException();
+            }
+
+            ++previousRecordId;
+        }
+        
+        if (trees.Count == 0)
+        {
+            throw new ArgumentException();
+        }
+
+        for (int i = 1; i < trees.Count; i++)
+        {
+            var t = trees.First(x => x.Id == i);
+            var parent = trees.First(x => x.Id == t.ParentId);
+            parent.Children.Add(t);
+        }
+
+        var r = trees.First(t => t.Id == 0);
+        return r;
+    }
+}