trackler 2.0.6.12 → 2.0.6.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa8f1408ac09a98a6c3586666f197c85efa0b7cb
-  data.tar.gz: 71653c98fd6b510de72b238db40cdee9ac0ed1d2
+  metadata.gz: 908196b422992f0a5116328c5efcd82340322c89
+  data.tar.gz: 88112e4cf238d4590f497bbba04f9cf21087f873
 SHA512:
-  metadata.gz: 3cceac782125c988061568125f85e50bccdb0da21583c36279a48e0b885b265bc3b47a542dbaf5379844b025a4d54c81e462b4e03cb051e7012471242b0aa0fc
-  data.tar.gz: 50ca76ed02285f8230a10d7f5c3b099ce78c18d10aa1bc93726cae239eae45e5a90cb1fbe11707bcf86c4066a9a51726fb235da36ca3469683a25c78ce91d350
+  metadata.gz: 10fb6193269541b0dce8c9f4cd44749a83e06a251cae0a5fcae35b8edc3122aeda761754f08addc071c627c65cb0560c531254737a49b0a81dd24a523e20e1b6
+  data.tar.gz: 1d5ac6a45f0c7d9bd0c11ebf5f6abbb327b39481f3fad8195ed4bf9dafa13f6d6ef86cdd9bcad93c9330acbe4347fb28013fac11840f88df11fd93e90708270a

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.6.12"
+  VERSION = "2.0.6.13"
 end

data/tracks/c/docs/ABOUT.md

@@ -0,0 +1,5 @@
+C is a general-purpose, imperative computer programming language, supporting structured programming, lexical variable scope and recursion, while a static type system prevents many unintended operations. By design, C provides constructs that map efficiently to typical machine instructions, and therefore it has found lasting use in applications that had formerly been coded in assembly language, including operating systems, as well as various application software for computers ranging from supercomputers to embedded systems.
+
+C was originally developed by Dennis Ritchie between 1969 and 1973 at Bell Labs, and used to re-implement the Unix operating system. It has since become one of the most widely used programming languages of all time, with C compilers from various vendors available for the majority of existing computer architectures and operating systems. C has been standardized by the American National Standards Institute (ANSI) since 1989 (see ANSI C) and subsequently by the International Organization for Standardization (ISO).
+
+Taken from https://en.wikipedia.org/wiki/C_(programming_language)

data/tracks/c/docs/INSTALLATION.md

@@ -15,21 +15,20 @@ build system as separate command-line tools.
 Linux users will need gcc or clang for the compiler, and `make` will be needed
 for the native build. Make is pre-installed on most unix systems, but is most
 likely available via your package manager. On Debian and Ubuntu based
-distributions it can be installed with `sudo apt-get install make` if not
-present.
+distributions everything you need can be installed with `sudo apt-get install build-essential`
+if not present.
 
 
 #### MacOS
 
-MacOS users can install gcc or clangwith [Homebrew](http://brew.sh/) via
+MacOS users can install gcc or clang with [Homebrew](http://brew.sh/) via
 `brew install gcc` or `brew install llvm`.
 
 
 #### Windows
 
-Windows users can get [Visual Studio Community 2013][vs-1013], a free download
+Windows users can get [Visual Studio Community][vs], a free download
 that will give you the Visual Studio 2013 IDE and the latest version of the
 Microsoft Visual C compiler.
 
-[vs-1013]: http://www.visualstudio.com/en-us/products/visual-studio-community-vs
-
+[vs]: http://visualstudio.com

data/tracks/c/docs/LEARNING.md

@@ -0,0 +1,34 @@
+## Learning C From Ground Zero
+
+In general, exercism assumes you already know the syntax and mechanisms
+of a language in a particular track.  However, knowing the syntax of a
+language is merely the first step in gaining expertise in a language.
+Exercism allows you to practice solving problems and share discussion
+with other programmers who have solved the same problem.  It is from
+the shared discussion that we gain expertise and insight into becoming
+better programmers.
+
+If you are brand new to the C language, you should spend time learning
+the basics of the language first.  Here are a few resources that can
+help you get started:
+
+* [Learn C](http://www.learn-c.org/)
+* [CS50x](https://www.edx.org/course/introduction-computer-science-harvardx-cs50x)
+
+[CodeChef](https://www.codechef.com/ide) is a simple web form
+interface to a C compiler that will let you try out small programs.
+Sometimes this can be an easier way to perform a quick experiment than
+building something locally in an integrated development environment.
+
+## Test-Driven Development in C
+
+Exercism assumes that you are familiar with the concept of test-driven
+development.  Each exercise comes with a series of tests that are already
+written for you.  You progress through the exercise one test at a time,
+writing an implementation incrementally to satisfy the tests.
+
+If you are new to test-driven development, it is strongly recommended
+that you first work through a [quick overview of some test frameworks for C](http://www.drdobbs.com/testing/unit-testing-in-c-tools-and-conventions/240156344?pgno=2)
+or read the book [Test-Driven Development for Embedded C](https://pragprog.com/book/jgade/test-driven-development-for-embedded-c)
+by James Grenning. These resources cover [Unity](http://www.throwtheswitch.org/unity/)
+ and [CppUTest](http://cpputest.github.io/); this track uses Unity.

data/tracks/c/docs/RESOURCES.md

@@ -0,0 +1,3 @@
+- [C++ Reference](http://en.cppreference.com/w/): An online reference for C and C++ programming languages. You have a doubt what a method does? cppreference.com has you covered.
+- [The Definitive C Book Guide and List](http://stackoverflow.com/questions/562303/the-definitive-c-book-guide-and-list): The legendary StackOverflow's question about C books.
+- [`C` tag on StackOverflow](http://stackoverflow.com/questions/tagged/c)

data/tracks/csharp/config.json

@@ -821,6 +821,15 @@
         "Parsing",
         "Dictionaries"
       ]
+    },
+    {
+      "slug": "pov",
+      "difficulty": 10,
+      "topics": [
+        "Graphs",
+        "Recursion",
+        "Searching"
+      ]
     }
   ],
   "deprecated": [

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

@@ -0,0 +1,125 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public class Graph<T> : IEquatable<Graph<T>>
+{
+    public Graph(T value, IEnumerable<Graph<T>> children)
+    {
+        Value = value;
+        Children = children;
+    }
+
+    public T Value { get; }
+    public IEnumerable<Graph<T>> Children { get; }
+
+    public bool Equals(Graph<T> other) =>
+        Value.Equals(other.Value) && Children.SequenceEqual(other.Children);
+}
+
+public class Crumb<T>
+{
+    public Crumb(T value, IEnumerable<Graph<T>> left, IEnumerable<Graph<T>> right)
+    {
+        Value = value;
+        Left = left;
+        Right = right;
+    }
+
+    public T Value { get; }
+    public IEnumerable<Graph<T>> Left { get; }
+    public IEnumerable<Graph<T>> Right { get; }
+}
+
+public class Zipper<T>
+{
+    public Zipper(Graph<T> focus, IEnumerable<Crumb<T>> crumbs)
+    {
+        Focus = focus;
+        Crumbs = crumbs;
+    }
+
+    public Graph<T> Focus { get; }
+    public IEnumerable<Crumb<T>> Crumbs { get; }
+}
+
+public static class Pov
+{
+    public static Graph<T> CreateGraph<T>(T value, IEnumerable<Graph<T>> children) 
+        => new Graph<T>(value, children);
+
+    public static Graph<T> FromPOV<T>(T value, Graph<T> graph) where T : IComparable 
+        => ChangeParent(FindNode(value, GraphToZipper(graph)));
+
+    public static IEnumerable<T> TracePathBetween<T>(T value1, T value2, Graph<T> graph) where T : IComparable
+        => ZipperToPath(FindNode(value2, GraphToZipper(FromPOV(value1, graph))));
+
+    private static Zipper<T> GraphToZipper<T>(Graph<T> graph)
+    {
+        if (graph == null)
+            return null;
+
+        return new Zipper<T>(graph, Enumerable.Empty<Crumb<T>>());
+    }
+
+    private static IEnumerable<T> ZipperToPath<T>(Zipper<T> zipper)
+    {
+        if (zipper == null)
+            return null;
+
+        return zipper.Crumbs.Select(c => c.Value).Reverse().Concat(new[] { zipper.Focus.Value });
+    }
+
+    private static Zipper<T> GoDown<T>(Zipper<T> zipper)
+    {        
+        if (zipper == null || !zipper.Focus.Children.Any())
+            return null;
+
+        var focus = zipper.Focus;
+        var children = focus.Children;
+
+        var newCrumb = new Crumb<T>(focus.Value, Enumerable.Empty<Graph<T>>(), children.Skip(1));
+
+        return new Zipper<T>(children.First(), new[] { newCrumb }.Concat(zipper.Crumbs));
+    }
+
+    private static Zipper<T> GoRight<T>(Zipper<T> zipper)
+    {        
+        if (zipper == null || !zipper.Crumbs.Any() || !zipper.Crumbs.First().Right.Any())
+            return null;
+
+        var crumbs = zipper.Crumbs;
+        var firstCrumb = crumbs.First();
+
+        var newCrumb = new Crumb<T>(firstCrumb.Value, firstCrumb.Left.Concat(new[] { zipper.Focus }), firstCrumb.Right.Skip(1));
+
+        return new Zipper<T>(firstCrumb.Right.First(), new[] { newCrumb }.Concat(crumbs.Skip(1)));
+    }
+
+    private static Zipper<T> FindNode<T>(T value, Zipper<T> zipper)
+        where T : IComparable
+    {
+        if (zipper == null || zipper.Focus.Value.CompareTo(value) == 0)
+            return zipper;
+
+        return FindNode(value, GoDown(zipper)) ?? FindNode(value, GoRight(zipper));
+    }
+
+    private static Graph<T> ChangeParent<T>(Zipper<T> zipper)
+    {
+        if (zipper == null)
+            return null;
+
+        if (!zipper.Crumbs.Any())
+            return zipper.Focus;
+
+        var firstCrumb = zipper.Crumbs.First();
+        var focus = zipper.Focus;
+
+        var newZipper = new Zipper<T>(CreateGraph(firstCrumb.Value, firstCrumb.Left.Concat(firstCrumb.Right)), zipper.Crumbs.Skip(1));
+        var parentGraph = ChangeParent(newZipper);
+
+        var ys = focus.Children.Concat(new[] { parentGraph });
+        return CreateGraph(focus.Value, ys);
+    }
+}

data/tracks/csharp/exercises/pov/PovTest.cs

@@ -0,0 +1,160 @@
+using NUnit.Framework;
+using System.Linq;
+
+public class PovTest
+{
+    private const string x = "x";
+
+    private static Graph<T> leaf<T>(T v) => Pov.CreateGraph(v, new Graph<T>[0]);
+
+    private static readonly Graph<string> singleton = Pov.CreateGraph(x, new Graph<string>[0]);
+
+    private static readonly Graph<string> flat = Pov.CreateGraph("root", new[] { "a", "b", x, "c" }.Select(leaf));
+
+    private static readonly Graph<string> nested =
+        Pov.CreateGraph("level-0", new[] {
+            Pov.CreateGraph("level-1", new[] {
+                Pov.CreateGraph("level-2", new[] {
+                    Pov.CreateGraph("level-3", new[] {
+                        Pov.CreateGraph(x, new Graph<string>[0])
+                    })
+                })
+            })
+        });
+
+    private static readonly Graph<string> kids =
+        Pov.CreateGraph("root", new[] {
+            Pov.CreateGraph(x, new[] {
+                Pov.CreateGraph("kid-0", new Graph<string>[0]),
+                Pov.CreateGraph("kid-1", new Graph<string>[0])
+            })
+        });
+
+    private static readonly Graph<string> cousins =
+        Pov.CreateGraph("grandparent", new[] {
+            Pov.CreateGraph("parent", new [] {
+                Pov.CreateGraph(x, new [] {
+                    leaf("kid-a"),
+                    leaf("kid-b")
+                }),
+                leaf("sibling-0"),
+                leaf("sibling-1")
+            }),
+            Pov.CreateGraph("uncle", new [] {
+                leaf("cousin-0"),
+                leaf("cousin-1")
+            })
+        });
+
+    private static readonly Graph<string> singleton_ = singleton;
+
+    private static readonly Graph<string> flat_ = 
+        Pov.CreateGraph(x, new[] {
+            Pov.CreateGraph("root", new [] { "a", "b", "c" }.Select(leaf))
+        });
+
+    private static readonly Graph<string> nested_ = 
+        Pov.CreateGraph(x, new[] {
+            Pov.CreateGraph("level-3", new [] {
+                Pov.CreateGraph("level-2", new [] {
+                    Pov.CreateGraph("level-1", new [] {
+                        Pov.CreateGraph("level-0", new Graph<string>[0])
+                    })
+                })
+            })
+        });
+
+    private static readonly Graph<string> kids_ = 
+        Pov.CreateGraph(x, new[] {
+            Pov.CreateGraph("kid-0", new Graph<string>[0]),
+            Pov.CreateGraph("kid-1", new Graph<string>[0]),
+            Pov.CreateGraph("root", new Graph<string>[0])
+        });
+
+    private static readonly Graph<string> cousins_ = 
+        Pov.CreateGraph(x, new[] {
+            leaf("kid-a"),
+            leaf("kid-b"),
+            Pov.CreateGraph("parent", new [] {
+                Pov.CreateGraph("sibling-0", new Graph<string>[0]),
+                Pov.CreateGraph("sibling-1", new Graph<string>[0]),
+                Pov.CreateGraph("grandparent", new [] {
+                    Pov.CreateGraph("uncle", new [] {
+                        Pov.CreateGraph("cousin-0", new Graph<string>[0]),
+                        Pov.CreateGraph("cousin-1", new Graph<string>[0])
+                    })
+                })
+            })
+        });
+
+    [Test]
+    public void Reparent_singleton()
+    {
+        Assert.That(Pov.FromPOV(x, singleton), Is.EqualTo(singleton_));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Reparent_flat()
+    {
+        Assert.That(Pov.FromPOV(x, flat), Is.EqualTo(flat_));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Reparent_nested()
+    {
+        Assert.That(Pov.FromPOV(x, nested), Is.EqualTo(nested_));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Reparent_kids()
+    {
+        Assert.That(Pov.FromPOV(x, kids), Is.EqualTo(kids_));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Reparent_cousins()
+    {
+        Assert.That(Pov.FromPOV(x, cousins), Is.EqualTo(cousins_));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Reparent_from_POV_of_non_existent_node()
+    {
+        Assert.That(Pov.FromPOV(x, leaf("foo")), Is.Null);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Should_not_be_able_to_find_a_missing_node()
+    {
+        var nodes = new[] { singleton, flat, kids, nested, cousins }.Select(graph => Pov.FromPOV("NOT THERE", graph));
+    
+        Assert.That(nodes, Is.All.Null);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Cannot_trace_between_unconnected_nodes()
+    {
+        Assert.That(Pov.TracePathBetween(x, "NOT THERE", cousins), Is.Null);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Can_trace_a_path_from_x_to_cousin()
+    {
+        Assert.That(Pov.TracePathBetween(x, "cousin-1", cousins), Is.EquivalentTo(new[] { "x", "parent", "grandparent", "uncle", "cousin-1" }));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Can_trace_from_a_leaf_to_a_leaf()
+    {
+        Assert.That(Pov.TracePathBetween("kid-a", "cousin-0", cousins), Is.EquivalentTo(new[] { "kid-a", "x", "parent", "grandparent", "uncle", "cousin-0" }));
+    }
+}

data/tracks/csharp/exercises/sum-of-multiples/SumOfMultiplesTest.cs

@@ -8,37 +8,43 @@ public class SumOfMultiplesTest
     {
         Assert.That(SumOfMultiples.To(new[] { 3, 5 }, 1), Is.EqualTo(0));
     }
-    
+
+    [Ignore("Remove to run test")]
     [Test]
     public void Sum_to_3()
     {
         Assert.That(SumOfMultiples.To(new[] { 3, 5 }, 4), Is.EqualTo(3));
     }
-    
+
+    [Ignore("Remove to run test")]
     [Test]
     public void Sum_to_10()
     {
         Assert.That(SumOfMultiples.To(new[] { 3, 5 }, 10), Is.EqualTo(23));
     }
-    
+
+    [Ignore("Remove to run test")]
     [Test]
     public void Sum_to_100()
     {
        Assert.That(SumOfMultiples.To(new[] { 3, 5 }, 100), Is.EqualTo(2318));
     }
-    
+
+    [Ignore("Remove to run test")]
     [Test]
     public void Sum_to_1000()
     {
         Assert.That(SumOfMultiples.To(new[] { 3, 5 }, 1000), Is.EqualTo(233168));
     }
-    
+
+    [Ignore("Remove to run test")]
     [Test]
     public void Sum_to_20()
     {
         Assert.That(SumOfMultiples.To(new [] { 7, 13, 17 }, 20), Is.EqualTo(51));
     }
-    
+
+    [Ignore("Remove to run test")]
     [Test]
     public void Sum_to_10000()
     {