trackler 2.2.1.14 → 2.2.1.15

data/tracks/csharp/exercises/raindrops/RaindropsTest.cs

@@ -59,13 +59,13 @@ public void The_sound_for_14_is_plong_as_it_has_a_factor_of_7()
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void The_sound_for_15_is_pling_plang_as_it_has_factors_3_and_5()
+    public void The_sound_for_15_is_plingplang_as_it_has_factors_3_and_5()
     {
         Assert.Equal("PlingPlang", Raindrops.Convert(15));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void The_sound_for_21_is_pling_plong_as_it_has_factors_3_and_7()
+    public void The_sound_for_21_is_plingplong_as_it_has_factors_3_and_7()
     {
         Assert.Equal("PlingPlong", Raindrops.Convert(21));
     }
@@ -83,7 +83,7 @@ public void The_sound_for_27_is_pling_as_it_has_a_factor_3()
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void The_sound_for_35_is_plang_plong_as_it_has_factors_5_and_7()
+    public void The_sound_for_35_is_plangplong_as_it_has_factors_5_and_7()
     {
         Assert.Equal("PlangPlong", Raindrops.Convert(35));
     }
@@ -101,7 +101,7 @@ public void The_sound_for_52_is_52()
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void The_sound_for_105_is_pling_plang_plong_as_it_has_factors_3_5_and_7()
+    public void The_sound_for_105_is_plingplangplong_as_it_has_factors_3_5_and_7()
     {
         Assert.Equal("PlingPlangPlong", Raindrops.Convert(105));
     }

data/tracks/csharp/exercises/roman-numerals/RomanNumeralsTest.cs

@@ -11,13 +11,13 @@ public void Number_1_is_a_single_i()
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Number_2_is_two_i_s()
+    public void Number_2_is_two_is()
     {
         Assert.Equal("II", 2.ToRoman());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Number_3_is_three_i_s()
+    public void Number_3_is_three_is()
     {
         Assert.Equal("III", 3.ToRoman());
     }
@@ -47,7 +47,7 @@ public void Number_9_being_10_1_is_ix()
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Number_20_is_two_x_s()
+    public void Number_20_is_two_xs()
     {
         Assert.Equal("XXVII", 27.ToRoman());
     }
@@ -107,7 +107,7 @@ public void Number_1000_is_a_single_m()
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Number_3000_is_three_m_s()
+    public void Number_3000_is_three_ms()
     {
         Assert.Equal("MMM", 3000.ToRoman());
     }

data/tracks/csharp/exercises/word-count/Example.cs

@@ -2,9 +2,9 @@
 using System.Text.RegularExpressions;
 using System.Collections.Generic;
 
-public static class Phrase
+public static class WordCount
 {
-    public static IDictionary<string, int> WordCount(string phrase)
+    public static IDictionary<string, int> Countwords(string phrase)
     {
         if (phrase == null) throw new ArgumentNullException("phrase");
 

data/tracks/csharp/exercises/word-count/WordCount.cs

@@ -1,9 +1,9 @@
 using System;
 using System.Collections.Generic;
 
-public static class Phrase
+public static class WordCount
 {
-    public static IDictionary<string, int> WordCount(string phrase)
+    public static IDictionary<string, int> Countwords(string phrase)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

data/tracks/csharp/exercises/word-count/WordCountTest.cs

@@ -1,145 +1,143 @@
-using System.Collections.Generic;
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 using Xunit;
+using System.Collections.Generic;
 
 public class WordCountTest
 {
     [Fact]
     public void Count_one_word()
     {
-        var counts = new Dictionary<string,int> {
-            { "word", 1 }
+        var actual = WordCount.Countwords("word");
+        var expected = new Dictionary<string, int>
+        {
+            ["word"] = 1
         };
-
-        Assert.Equal(counts, Phrase.WordCount("word"));
+        Assert.Equal(expected, actual);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Count_one_of_each()
+    public void Count_one_of_each_word()
     {
-        var counts = new Dictionary<string,int> {
-            { "one",  1 },
-            { "of",   1 },
-            { "each", 1 }
+        var actual = WordCount.Countwords("one of each");
+        var expected = new Dictionary<string, int>
+        {
+            ["one"] = 1,
+            ["of"] = 1,
+            ["each"] = 1
         };
-
-        Assert.Equal(counts, Phrase.WordCount("one of each"));
+        Assert.Equal(expected, actual);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Count_multiple_occurrences()
+    public void Multiple_occurrences_of_a_word()
     {
-        var counts = new Dictionary<string,int> {
-            { "one",  1 },
-            { "fish", 4 },
-            { "two",  1 },
-            { "red",  1 },
-            { "blue", 1 },
+        var actual = WordCount.Countwords("one fish two fish red fish blue fish");
+        var expected = new Dictionary<string, int>
+        {
+            ["one"] = 1,
+            ["fish"] = 4,
+            ["two"] = 1,
+            ["red"] = 1,
+            ["blue"] = 1
         };
-
-        Assert.Equal(counts, Phrase.WordCount("one fish two fish red fish blue fish"));
+        Assert.Equal(expected, actual);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Count_everything_just_once()
+    public void Handles_cramped_lists()
     {
-        var counts = new Dictionary<string,int> {
-            { "all",    2 },
-            { "the",    2 },
-            { "kings",  2 },
-            { "horses", 1 },
-            { "and",    1 },
-            { "men",    1 },
+        var actual = WordCount.Countwords("one,two,three");
+        var expected = new Dictionary<string, int>
+        {
+            ["one"] = 1,
+            ["two"] = 1,
+            ["three"] = 1
         };
-
-        Assert.Equal(counts, Phrase.WordCount("all the kings horses and all the kings men"));
+        Assert.Equal(expected, actual);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Ignore_punctuation()
+    public void Handles_expanded_lists()
     {
-        var counts = new Dictionary<string,int> {
-            { "car",        1 },
-            { "carpet",     1 },
-            { "as",         1 },
-            { "java",       1 },
-            { "javascript", 1 },
+        var actual = WordCount.Countwords("one,\ntwo,\nthree");
+        var expected = new Dictionary<string, int>
+        {
+            ["one"] = 1,
+            ["two"] = 1,
+            ["three"] = 1
         };
-
-        Assert.Equal(counts, Phrase.WordCount("car : carpet as java : javascript!!&@$%^&"));
+        Assert.Equal(expected, actual);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Handles_cramped_list()
+    public void Ignore_punctuation()
     {
-        var counts = new Dictionary<string,int> {
-            { "one",   1 },
-            { "two",   1 },
-            { "three", 1 },
+        var actual = WordCount.Countwords("car: carpet as java: javascript!!&@$%^&");
+        var expected = new Dictionary<string, int>
+        {
+            ["car"] = 1,
+            ["carpet"] = 1,
+            ["as"] = 1,
+            ["java"] = 1,
+            ["javascript"] = 1
         };
-
-        Assert.Equal(counts, Phrase.WordCount("one,two,three"));
+        Assert.Equal(expected, actual);
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Include_numbers()
     {
-        var counts = new Dictionary<string,int> {
-            { "testing", 2 },
-            { "1",       1 },
-            { "2",       1 },
+        var actual = WordCount.Countwords("testing, 1, 2 testing");
+        var expected = new Dictionary<string, int>
+        {
+            ["testing"] = 2,
+            ["1"] = 1,
+            ["2"] = 1
         };
-
-        Assert.Equal(counts, Phrase.WordCount("testing, 1, 2 testing"));
+        Assert.Equal(expected, actual);
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Normalize_case()
     {
-        var counts = new Dictionary<string,int> {
-            { "go", 3 },
+        var actual = WordCount.Countwords("go Go GO Stop stop");
+        var expected = new Dictionary<string, int>
+        {
+            ["go"] = 3,
+            ["stop"] = 2
         };
-
-        Assert.Equal(counts, Phrase.WordCount("go Go GO"));
+        Assert.Equal(expected, actual);
     }
 
     [Fact(Skip = "Remove to run test")]
     public void With_apostrophes()
     {
-        var counts = new Dictionary<string,int> {
-            { "first", 1 },
-            { "don't", 2 },
-            { "laugh", 1 },
-            { "then",  1 },
-            { "cry",   1 },
+        var actual = WordCount.Countwords("First: don't laugh. Then: don't cry.");
+        var expected = new Dictionary<string, int>
+        {
+            ["first"] = 1,
+            ["don't"] = 2,
+            ["laugh"] = 1,
+            ["then"] = 1,
+            ["cry"] = 1
         };
-
-        Assert.Equal(counts, Phrase.WordCount("First: don't laugh. Then: don't cry."));
+        Assert.Equal(expected, actual);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void With_free_standing_apostrophes()
+    public void With_quotations()
     {
-        var counts = new Dictionary<string, int> {
-            { "go", 3 },
+        var actual = WordCount.Countwords("Joe can't tell between 'large' and large.");
+        var expected = new Dictionary<string, int>
+        {
+            ["joe"] = 1,
+            ["can't"] = 1,
+            ["tell"] = 1,
+            ["between"] = 1,
+            ["large"] = 2,
+            ["and"] = 1
         };
-
-        Assert.Equal(counts, Phrase.WordCount("go ' Go '' GO"));
+        Assert.Equal(expected, actual);
     }
-
-    [Fact(Skip = "Remove to run test")]
-    public void With_apostrophes_as_quotes()
-    {
-        var counts = new Dictionary<string, int> {
-            { "she", 1 },
-            { "said", 1 },
-            { "let's", 1 },
-            { "meet", 1 },
-            { "at", 1 },
-            { "twelve", 1 },
-            { "o'clock", 1 },
-        };
-
-        Assert.Equal(counts, Phrase.WordCount("She said, 'let's meet at twelve o'clock'"));
-    }
-
 }

data/tracks/csharp/generators/Exercises/Pangram.cs

@@ -8,7 +8,6 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
         {
             foreach (var canonicalDataCase in CanonicalData.Cases)
             {
-                canonicalDataCase.Description = canonicalDataCase.Description.Replace("'", string.Empty);
                 canonicalDataCase.UseVariablesForInput = true;
                 canonicalDataCase.Input["input"] = ((string)canonicalDataCase.Input["input"]).Replace("\"", "\\\"");
             }

data/tracks/csharp/generators/Exercises/Poker.cs

@@ -0,0 +1,19 @@
+using Generators.Input;
+
+namespace Generators.Exercises
+{
+    public class Poker : Exercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                canonicalDataCase.UseVariableForExpected = true;
+                canonicalDataCase.UseVariableForTested = true;
+
+                canonicalDataCase.Expected = canonicalDataCase.Expected.ConvertToEnumerable<string>();
+                canonicalDataCase.Input["input"] = canonicalDataCase.Input["input"].ConvertToEnumerable<string>();
+            }
+        }
+    }
+}

data/tracks/csharp/generators/Exercises/RomanNumerals.cs

@@ -10,7 +10,6 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
             {
                 canonicalDataCase.TestedMethodType = TestedMethodType.Extension;
                 canonicalDataCase.Property = "ToRoman";
-                canonicalDataCase.Description = "Number_" + canonicalDataCase.Description;
             }
         }
     }

data/tracks/csharp/generators/Exercises/WordCount.cs

@@ -0,0 +1,27 @@
+using Generators.Input;
+using Newtonsoft.Json.Linq;
+using System.Collections.Generic;
+
+namespace Generators.Exercises
+{
+    public class WordCount : Exercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in CanonicalData.Cases)
+            {
+                canonicalDataCase.UseVariableForExpected = true;
+                canonicalDataCase.UseVariableForTested = true;
+                canonicalDataCase.Expected = ((JObject)canonicalDataCase.Expected).ToObject<Dictionary<string, int>>();
+            }
+        }
+
+        protected override HashSet<string> GetUsingNamespaces()
+        {
+            var usingNamespaces = base.GetUsingNamespaces();
+            usingNamespaces.Add(typeof(Dictionary<string, int>).Namespace);
+
+            return usingNamespaces;
+        }
+    }
+}

data/tracks/csharp/generators/Output/NameExtensions.cs

@@ -14,10 +14,12 @@ public static class NameExtensions
 
         public static string ToTestMethodName(this string input)
         {
-            var methodName = 
-                Regex.Replace(input.Replace(":", " is"), @"[^\w]+", "_", RegexOptions.Compiled)
-                    .Underscore()
-                    .Transform(To.TitleCase);
+            var methodName = input
+                .Replace(":", " is")
+                .Replace("'", "");
+
+            methodName = Regex.Replace(methodName, @"[^\w]+", "_", RegexOptions.Compiled)
+                .Transform(To.TitleCase);
 
             if (char.IsDigit(methodName[0]))
                 return "Number_" + methodName;

data/tracks/go/config.json

@@ -1,1048 +1,1059 @@
 {
-  "language": "Go",
   "active": true,
   "blurb": "Go is a compiled, open source programming language with a small, consistent syntax, a powerful standard library, and fantastic tooling. It's a great fit for web backends and command-line tools.",
-  "ignore_pattern": "example(?!.*test)",
-  "foregone": [
-    "space-age",
-    "linked-list",
-    "simple-linked-list"
-  ],
   "exercises": [
     {
-      "uuid": "19957346-dedf-441e-85ea-656cac0d96d8",
-      "slug": "hello-world",
       "core": true,
-      "unlocked_by": null,
       "difficulty": 1,
+      "slug": "hello-world",
       "topics": [
-        "Strings"
-      ]
+        "strings"
+      ],
+      "unlocked_by": null,
+      "uuid": "19957346-dedf-441e-85ea-656cac0d96d8"
     },
     {
-      "uuid": "52582415-8f7f-4ac5-857f-5c160ec48134",
-      "slug": "hamming",
       "core": true,
-      "unlocked_by":null,
       "difficulty": 1,
+      "slug": "two-fer",
       "topics": [
-        "Control-flow (loops)",
-        "Equality",
-        "Strings"
-      ]
+        "control-flow-(conditionals)",
+        "strings"
+      ],
+      "unlocked_by": null,
+      "uuid": "dc4ad67d-0fe4-0880-5a13-3aebb8759bcc3095de1"
     },
     {
-      "uuid": "2f51e32a-9b1f-4100-9eec-517115c858e9",
-      "slug": "raindrops",
       "core": true,
-      "unlocked_by": null,
       "difficulty": 1,
+      "slug": "hamming",
       "topics": [
-        "Control-flow (conditionals)",
-        "Strings",
-        "Filtering"
-      ]
+        "control-flow-(loops)",
+        "equality",
+        "strings"
+      ],
+      "unlocked_by": null,
+      "uuid": "52582415-8f7f-4ac5-857f-5c160ec48134"
     },
     {
-      "uuid": "20cbd8f9-f8e3-4767-a0f5-94810ba3f902",
-      "slug": "scrabble-score",
       "core": true,
-      "unlocked_by": null,
       "difficulty": 1,
+      "slug": "raindrops",
       "topics": [
-        "Control-flow (loops)",
-        "Maps",
-        "Strings"
-      ]
+        "control-flow-(conditionals)",
+        "filtering",
+        "strings"
+      ],
+      "unlocked_by": null,
+      "uuid": "2f51e32a-9b1f-4100-9eec-517115c858e9"
     },
     {
-      "uuid": "73da448c-33b7-4565-ab48-1de5020d65ab",
-      "slug": "etl",
       "core": true,
-      "unlocked_by": null,
       "difficulty": 1,
+      "slug": "scrabble-score",
       "topics": [
-        "Control-flow (loops)",
-        "Maps",
-        "Transforming"
-      ]
+        "control-flow-(loops)",
+        "maps",
+        "strings"
+      ],
+      "unlocked_by": null,
+      "uuid": "20cbd8f9-f8e3-4767-a0f5-94810ba3f902"
     },
     {
-      "uuid": "19628c8a-a89f-457e-9526-3d400024a927",
-      "slug": "difference-of-squares",
       "core": true,
+      "difficulty": 1,
+      "slug": "etl",
+      "topics": [
+        "control-flow-(loops)",
+        "maps",
+        "transforming"
+      ],
       "unlocked_by": null,
+      "uuid": "73da448c-33b7-4565-ab48-1de5020d65ab"
+    },
+    {
+      "core": true,
       "difficulty": 2,
+      "slug": "difference-of-squares",
       "topics": [
-        "Algorithms",
-        "Mathematics"
-      ]
+        "algorithms",
+        "mathematics"
+      ],
+      "unlocked_by": null,
+      "uuid": "19628c8a-a89f-457e-9526-3d400024a927"
     },
     {
-      "uuid": "7fbb0d9d-71d1-4654-8ca0-bb07ddbe6cb5",
-      "slug": "strain",
       "core": true,
-      "unlocked_by": null,
       "difficulty": 2,
+      "slug": "strain",
       "topics": [
-        "Filtering",
-        "Control-flow (loops)",
-        "Arrays"
-      ]
+        "arrays",
+        "control-flow-(loops)",
+        "filtering"
+      ],
+      "unlocked_by": null,
+      "uuid": "7fbb0d9d-71d1-4654-8ca0-bb07ddbe6cb5"
     },
     {
-      "uuid": "b39d9e79-dee0-4c70-a6c3-114bee8083f2",
-      "slug": "acronym",
       "core": true,
-      "unlocked_by": null,
       "difficulty": 3,
+      "slug": "acronym",
       "topics": [
-        "Strings",
-        "Transforming",
-        "Regular Expressions"
-      ]
+        "regular-expressions",
+        "strings",
+        "transforming"
+      ],
+      "unlocked_by": null,
+      "uuid": "b39d9e79-dee0-4c70-a6c3-114bee8083f2"
     },
     {
-      "uuid": "6769557a-33fa-4257-adbf-e66dc8c06f85",
-      "slug": "triangle",
       "core": true,
-      "unlocked_by": null,
       "difficulty": 3,
+      "slug": "triangle",
       "topics": [
-        "Control-flow (conditionals)",
-        "Booleans",
-        "Logic"
-      ]
+        "booleans",
+        "control-flow-(conditionals)",
+        "logic"
+      ],
+      "unlocked_by": null,
+      "uuid": "6769557a-33fa-4257-adbf-e66dc8c06f85"
     },
     {
-      "uuid": "7d2de21e-bf67-495e-8d90-05e1a35d5b99",
-      "slug": "clock",
       "core": true,
-      "unlocked_by": null,
       "difficulty": 3,
+      "slug": "clock",
       "topics": [
-        "Time",
-        "Mathematics",
-        "Text formatting",
-        "Equality"
-      ]
+        "equality",
+        "mathematics",
+        "text-formatting",
+        "time"
+      ],
+      "unlocked_by": null,
+      "uuid": "7d2de21e-bf67-495e-8d90-05e1a35d5b99"
     },
     {
-      "uuid": "b765fde9-84b4-44cc-bdf1-f66ac1ab8e2c",
-      "slug": "word-count",
       "core": true,
-      "unlocked_by": null,
       "difficulty": 3,
+      "slug": "word-count",
       "topics": [
-        "Strings",
-        "Sorting"
-      ]
+        "sorting",
+        "strings"
+      ],
+      "unlocked_by": null,
+      "uuid": "b765fde9-84b4-44cc-bdf1-f66ac1ab8e2c"
     },
     {
-      "uuid": "bf366b19-63bf-4a75-9a35-08b881af6951",
-      "slug": "parallel-letter-frequency",
       "core": true,
-      "unlocked_by": null,
       "difficulty": 3,
+      "slug": "parallel-letter-frequency",
       "topics": [
-        "Concurrency"
-      ]
+        "concurrency"
+      ],
+      "unlocked_by": null,
+      "uuid": "bf366b19-63bf-4a75-9a35-08b881af6951"
     },
     {
-      "uuid": "b4f6b08b-a132-447b-b447-66bf37ab20c6",
-      "slug": "grains",
       "core": true,
-      "unlocked_by": null,
       "difficulty": 2,
+      "slug": "grains",
       "topics": [
-        "Control-flow (if-else statements)",
-        "Bitwise operations",
-        "Mathematics",
-        "Type conversion",
-        "Integers"
-      ]
+        "bitwise-operations",
+        "control-flow-(if-else-statements)",
+        "integers",
+        "mathematics",
+        "type-conversion"
+      ],
+      "unlocked_by": null,
+      "uuid": "b4f6b08b-a132-447b-b447-66bf37ab20c6"
     },
     {
-      "uuid": "2c5fb577-a9ce-4c4c-8fc8-fffb38d020d6",
-      "slug": "series",
       "core": true,
-      "unlocked_by": null,
       "difficulty": 3,
+      "slug": "series",
       "topics": [
-        "Strings",
-        "Arrays",
-        "Refactoring"
-      ]
+        "arrays",
+        "refactoring",
+        "strings"
+      ],
+      "unlocked_by": null,
+      "uuid": "2c5fb577-a9ce-4c4c-8fc8-fffb38d020d6"
     },
     {
-      "uuid": "31c77516-6702-417e-9c6e-19c7e965d513",
-      "slug": "binary-search",
       "core": true,
-      "unlocked_by": null,
       "difficulty": 5,
+      "slug": "binary-search",
       "topics": [
-        "Algorithms",
-        "Arrays",
-        "Searching",
-        "Sorting"
-      ]
+        "algorithms",
+        "arrays",
+        "searching",
+        "sorting"
+      ],
+      "unlocked_by": null,
+      "uuid": "31c77516-6702-417e-9c6e-19c7e965d513"
     },
     {
-      "uuid": "75b6e2e8-1e20-4f53-b7c5-e32f9f7eea58",
-      "slug": "twelve-days",
       "core": true,
-      "unlocked_by": null,
       "difficulty": 4,
+      "slug": "twelve-days",
       "topics": [
-        "Strings",
-        "Sequences",
-        "Algorithms",
-        "Pattern recognition",
-        "Text formatting"
-      ]
+        "algorithms",
+        "pattern-recognition",
+        "sequences",
+        "strings",
+        "text-formatting"
+      ],
+      "unlocked_by": null,
+      "uuid": "75b6e2e8-1e20-4f53-b7c5-e32f9f7eea58"
     },
     {
-      "uuid": "62aa3d20-65d8-440f-9d08-48bbc823f4fe",
-      "slug": "matrix",
       "core": true,
-      "unlocked_by": null,
       "difficulty": 4,
+      "slug": "matrix",
       "topics": [
-        "Matrices",
-        "Type conversion",
-        "Arrays",
-        "Exception handling",
-        "Strings"
-      ]
+        "arrays",
+        "exception-handling",
+        "matrices",
+        "strings",
+        "type-conversion"
+      ],
+      "unlocked_by": null,
+      "uuid": "62aa3d20-65d8-440f-9d08-48bbc823f4fe"
     },
     {
-      "uuid": "92e2a192-5ee9-422a-8699-c231a7136b10",
-      "slug": "pascals-triangle",
       "core": false,
-      "unlocked_by": "series",
       "difficulty": 4,
+      "slug": "pascals-triangle",
       "topics": [
-        "Arrays",
-        "Mathematics"
-      ]
+        "arrays",
+        "mathematics"
+      ],
+      "unlocked_by": "series",
+      "uuid": "92e2a192-5ee9-422a-8699-c231a7136b10"
     },
     {
-      "uuid": "95f49a88-6f01-4905-a8b1-a3fcec1f535a",
-      "slug": "queen-attack",
       "core": true,
-      "unlocked_by": null,
       "difficulty": 5,
+      "slug": "queen-attack",
       "topics": [
-        "Booleans",
-        "Logic",
-        "Games",
-        "Errors"
-      ]
+        "booleans",
+        "errors",
+        "games",
+        "logic"
+      ],
+      "unlocked_by": null,
+      "uuid": "95f49a88-6f01-4905-a8b1-a3fcec1f535a"
     },
     {
-      "uuid": "fee57b09-2b67-4483-a2e5-3dfec0568b15",
-      "slug": "leap",
       "core": false,
-      "unlocked_by": "hamming",
       "difficulty": 1,
+      "slug": "leap",
       "topics": [
-        "Control-flow (conditionals)",
-        "Booleans",
-        "Integers",
-        "Logic"
-      ]
+        "booleans",
+        "control-flow-(conditionals)",
+        "integers",
+        "logic"
+      ],
+      "unlocked_by": "hamming",
+      "uuid": "fee57b09-2b67-4483-a2e5-3dfec0568b15"
     },
     {
-      "uuid": "ea390e58-6ac5-4219-89bb-648852712a6a",
-      "slug": "gigasecond",
       "core": false,
-      "unlocked_by": "hamming",
       "difficulty": 1,
+      "slug": "gigasecond",
       "topics": [
-        "Time"
-      ]
+        "time"
+      ],
+      "unlocked_by": "hamming",
+      "uuid": "ea390e58-6ac5-4219-89bb-648852712a6a"
     },
     {
-      "uuid": "fb03948c-11e8-440d-9a5d-979396451270",
-      "slug": "accumulate",
       "core": false,
-      "unlocked_by": "raindrops",
       "difficulty": 1,
+      "slug": "accumulate",
       "topics": [
-        "Lists"
-      ]
+        "lists"
+      ],
+      "unlocked_by": "raindrops",
+      "uuid": "fb03948c-11e8-440d-9a5d-979396451270"
     },
     {
-      "uuid": "d14c6283-e57c-472c-8181-87f82d9088dd",
-      "slug": "pangram",
       "core": false,
-      "unlocked_by": "raindrops",
       "difficulty": 2,
+      "slug": "pangram",
       "topics": [
-        "Control-flow (loops)",
-        "Strings"
-      ]
+        "control-flow-(loops)",
+        "strings"
+      ],
+      "unlocked_by": "raindrops",
+      "uuid": "d14c6283-e57c-472c-8181-87f82d9088dd"
     },
     {
-      "uuid": "efdf07a1-e329-4d0f-90a1-374b9b8af748",
-      "slug": "bob",
       "core": false,
-      "unlocked_by": "raindrops",
       "difficulty": 2,
+      "slug": "bob",
       "topics": [
-        "Control-flow (conditionals)",
-        "Strings"
-      ]
+        "control-flow-(conditionals)",
+        "strings"
+      ],
+      "unlocked_by": "raindrops",
+      "uuid": "efdf07a1-e329-4d0f-90a1-374b9b8af748"
     },
     {
-      "uuid": "cd05b63b-df20-4c8d-8743-53033acf7696",
-      "slug": "error-handling",
       "core": false,
-      "unlocked_by": "queen-attack",
       "difficulty": 5,
+      "slug": "error-handling",
       "topics": [
-        "Exception handling"
-      ]
+        "exception-handling"
+      ],
+      "unlocked_by": "queen-attack",
+      "uuid": "cd05b63b-df20-4c8d-8743-53033acf7696"
     },
     {
-      "uuid": "9a1870e0-dce7-496e-9521-2f2b606ac6c5",
-      "slug": "secret-handshake",
       "core": false,
-      "unlocked_by": "grains",
       "difficulty": 5,
+      "slug": "secret-handshake",
       "topics": [
-        "Bitwise operations",
-        "Arrays",
-        "Integers"
-      ]
+        "arrays",
+        "bitwise-operations",
+        "integers"
+      ],
+      "unlocked_by": "grains",
+      "uuid": "9a1870e0-dce7-496e-9521-2f2b606ac6c5"
     },
     {
-      "uuid": "11008fb0-4ef9-4aff-befb-c56f4084f96e",
-      "slug": "house",
       "core": false,
-      "unlocked_by": "twelve-days",
       "difficulty": 4,
+      "slug": "house",
       "topics": [
-        "Strings",
-        "Text formatting",
-        "Recursion"
-      ]
+        "recursion",
+        "strings",
+        "text-formatting"
+      ],
+      "unlocked_by": "twelve-days",
+      "uuid": "11008fb0-4ef9-4aff-befb-c56f4084f96e"
     },
     {
-      "uuid": "f0c25fde-960e-4161-a642-4414925b4d0a",
-      "slug": "sum-of-multiples",
       "core": false,
-      "unlocked_by": "difference-of-squares",
       "difficulty": 5,
+      "slug": "sum-of-multiples",
       "topics": [
-        "Control-flow (loops)",
-        "Mathematics"
-      ]
+        "control-flow-(loops)",
+        "mathematics"
+      ],
+      "unlocked_by": "difference-of-squares",
+      "uuid": "f0c25fde-960e-4161-a642-4414925b4d0a"
     },
     {
-      "uuid": "6c919eab-7c63-444a-a485-db74d51c3430",
-      "slug": "pythagorean-triplet",
       "core": false,
-      "unlocked_by": "difference-of-squares",
       "difficulty": 5,
+      "slug": "pythagorean-triplet",
       "topics": [
-        "Algorithms",
-        "Mathematics"
-      ]
+        "algorithms",
+        "mathematics"
+      ],
+      "unlocked_by": "difference-of-squares",
+      "uuid": "6c919eab-7c63-444a-a485-db74d51c3430"
     },
     {
-      "uuid": "c2064df8-cce5-4f03-9d85-0818b4e34112",
-      "slug": "isogram",
       "core": false,
-      "unlocked_by": "pangram",
       "difficulty": 3,
+      "slug": "isogram",
       "topics": [
-        "Strings",
-        "Sequences"
-      ]
+        "sequences",
+        "strings"
+      ],
+      "unlocked_by": "pangram",
+      "uuid": "c2064df8-cce5-4f03-9d85-0818b4e34112"
     },
     {
-      "uuid": "7cb6c78e-44e9-499b-a745-3ecb73bea3ab",
-      "slug": "bank-account",
       "core": false,
-      "unlocked_by": "parallel-letter-frequency",
       "difficulty": 4,
+      "slug": "bank-account",
       "topics": [
-        "Concurrency",
-        "Integers"
-      ]
+        "concurrency",
+        "integers"
+      ],
+      "unlocked_by": "parallel-letter-frequency",
+      "uuid": "7cb6c78e-44e9-499b-a745-3ecb73bea3ab"
     },
     {
-      "uuid": "a1c065d9-6971-4286-8413-c944e2dddefa",
-      "slug": "crypto-square",
       "core": false,
-      "unlocked_by": "luhn",
       "difficulty": 3,
+      "slug": "crypto-square",
       "topics": [
-        "Cryptography",
-        "Filtering",
-        "Strings",
-        "Text Formatting",
-        "Transforming"
-      ]
+        "cryptography",
+        "filtering",
+        "strings",
+        "text-formatting",
+        "transforming"
+      ],
+      "unlocked_by": "luhn",
+      "uuid": "a1c065d9-6971-4286-8413-c944e2dddefa"
     },
     {
-      "uuid": "8b29da0e-8ead-4e72-a12a-d448c8434767",
-      "slug": "luhn",
       "core": false,
-      "unlocked_by": "acronym",
       "difficulty": 2,
+      "slug": "luhn",
       "topics": [
-        "Algorithms",
-        "Integers",
-        "Strings"
-      ]
+        "algorithms",
+        "integers",
+        "strings"
+      ],
+      "unlocked_by": "acronym",
+      "uuid": "8b29da0e-8ead-4e72-a12a-d448c8434767"
     },
     {
-      "uuid": "12a16ab5-35fc-4fb2-a018-504953f3ad80",
-      "slug": "food-chain",
       "core": false,
-      "unlocked_by": "twelve-days",
       "difficulty": 4,
+      "slug": "food-chain",
       "topics": [
-        "Control-flow (conditionals)",
-        "Control-flow (loops)",
-        "Recursion",
-        "Strings",
-        "Text Formatting"
-      ]
+        "control-flow-(conditionals)",
+        "control-flow-(loops)",
+        "recursion",
+        "strings",
+        "text-formatting"
+      ],
+      "unlocked_by": "twelve-days",
+      "uuid": "12a16ab5-35fc-4fb2-a018-504953f3ad80"
     },
     {
-      "uuid": "8ec72d61-d830-48cf-819d-cd4faf0cf67d",
-      "slug": "largest-series-product",
       "core": false,
-      "unlocked_by": "difference-of-squares",
       "difficulty": 3,
+      "slug": "largest-series-product",
       "topics": [
-        "Integers",
-        "Sequences",
-        "Algorithms"
-      ]
+        "algorithms",
+        "integers",
+        "sequences"
+      ],
+      "unlocked_by": "difference-of-squares",
+      "uuid": "8ec72d61-d830-48cf-819d-cd4faf0cf67d"
     },
     {
-      "uuid": "c3469a26-b133-43b4-ab7d-32ea04fa5ce4",
-      "slug": "sieve",
       "core": false,
-      "unlocked_by": "strain",
       "difficulty": 3,
+      "slug": "sieve",
       "topics": [
-        "Algorithms",
-        "Integers",
-        "Mathematics",
-        "Sorting",
-        "Control-flow (loops)"
-      ]
+        "algorithms",
+        "control-flow-(loops)",
+        "integers",
+        "mathematics",
+        "sorting"
+      ],
+      "unlocked_by": "strain",
+      "uuid": "c3469a26-b133-43b4-ab7d-32ea04fa5ce4"
     },
     {
-      "uuid": "10f091b1-deda-4fec-8e3c-9dabb080d473",
-      "slug": "palindrome-products",
       "core": false,
-      "unlocked_by": "perfect-numbers",
       "difficulty": 6,
+      "slug": "palindrome-products",
       "topics": [
-        "Mathematics",
-        "Algorithms"
-      ]
+        "algorithms",
+        "mathematics"
+      ],
+      "unlocked_by": "perfect-numbers",
+      "uuid": "10f091b1-deda-4fec-8e3c-9dabb080d473"
     },
     {
-      "uuid": "0b9e07de-c8e4-4d28-b589-897a7ef8062a",
-      "slug": "protein-translation",
       "core": false,
-      "unlocked_by": "rna-transcription",
       "difficulty": 3,
+      "slug": "protein-translation",
       "topics": [
-        "Filtering",
-        "Maps",
-        "Sequences"
-      ]
+        "filtering",
+        "maps",
+        "sequences"
+      ],
+      "unlocked_by": "rna-transcription",
+      "uuid": "0b9e07de-c8e4-4d28-b589-897a7ef8062a"
     },
     {
-      "uuid": "362f93ab-51e8-4d6a-bd2f-b46432843eb9",
-      "slug": "perfect-numbers",
       "core": false,
-      "unlocked_by": "clock",
       "difficulty": 4,
+      "slug": "perfect-numbers",
       "topics": [
-        "Integers",
-        "Algorithms",
-        "Mathematics",
-        "Filtering"
-      ]
+        "algorithms",
+        "filtering",
+        "integers",
+        "mathematics"
+      ],
+      "unlocked_by": "clock",
+      "uuid": "362f93ab-51e8-4d6a-bd2f-b46432843eb9"
     },
     {
-      "uuid": "6c2499f7-d42c-4d0f-9680-f5f7650023ff",
-      "slug": "bracket-push",
       "core": false,
-      "unlocked_by": "poker",
       "difficulty": 7,
+      "slug": "bracket-push",
       "topics": [
-        "Parsing",
-        "Strings"
-      ]
+        "parsing",
+        "strings"
+      ],
+      "unlocked_by": "poker",
+      "uuid": "6c2499f7-d42c-4d0f-9680-f5f7650023ff"
     },
     {
-      "uuid": "f1db7190-a53d-411d-b538-8dc3f75ddc32",
-      "slug": "anagram",
       "core": false,
-      "unlocked_by": "scrabble-score",
       "difficulty": 3,
+      "slug": "anagram",
       "topics": [
-        "Strings",
-        "Parsing",
-        "Filtering"
-      ]
+        "filtering",
+        "parsing",
+        "strings"
+      ],
+      "unlocked_by": "scrabble-score",
+      "uuid": "f1db7190-a53d-411d-b538-8dc3f75ddc32"
     },
     {
-      "uuid": "cbfd4cfb-abe7-45f9-80e4-3de3b2639fc8",
-      "slug": "allergies",
       "core": false,
-      "unlocked_by": "grains",
       "difficulty": 4,
+      "slug": "allergies",
       "topics": [
-        "Enumeration",
-        "Bitwise operations"
-      ]
+        "bitwise-operations",
+        "enumeration"
+      ],
+      "unlocked_by": "grains",
+      "uuid": "cbfd4cfb-abe7-45f9-80e4-3de3b2639fc8"
     },
     {
-      "uuid": "9bef2163-2a24-4d50-9610-e3cac2e7772a",
-      "slug": "rna-transcription",
       "core": false,
-      "unlocked_by": "scrabble-score",
       "difficulty": 2,
+      "slug": "rna-transcription",
       "topics": [
-          "Maps",
-          "Transforming"
-      ]
+        "maps",
+        "transforming"
+      ],
+      "unlocked_by": "scrabble-score",
+      "uuid": "9bef2163-2a24-4d50-9610-e3cac2e7772a"
     },
     {
-      "uuid": "eccfd2b3-93cf-41a8-b39b-c29596469e8e",
-      "slug": "roman-numerals",
       "core": false,
-      "unlocked_by": "acronym",
       "difficulty": 2,
+      "slug": "roman-numerals",
       "topics": [
-        "Numbers",
-        "Transforming"
-      ]
+        "numbers",
+        "transforming"
+      ],
+      "unlocked_by": "acronym",
+      "uuid": "eccfd2b3-93cf-41a8-b39b-c29596469e8e"
     },
     {
-      "uuid": "5d742499-b130-458a-ba3e-a4c3d75419c3",
-      "slug": "say",
       "core": false,
-      "unlocked_by": "meetup",
       "difficulty": 7,
+      "slug": "say",
       "topics": [
-        "Numbers",
-        "Strings",
-        "Transforming",
-        "Text Formatting"
-      ]
+        "numbers",
+        "strings",
+        "text-formatting",
+        "transforming"
+      ],
+      "unlocked_by": "meetup",
+      "uuid": "5d742499-b130-458a-ba3e-a4c3d75419c3"
     },
     {
-      "uuid": "c13edd0a-cd39-4f25-970c-c1f9e32bac2c",
-      "slug": "circular-buffer",
       "core": false,
-      "unlocked_by": "grade-school",
       "difficulty": 5,
+      "slug": "circular-buffer",
       "topics": [
-        "Queues",
-        "Structs"
-      ]
+        "queues",
+        "structs"
+      ],
+      "unlocked_by": "grade-school",
+      "uuid": "c13edd0a-cd39-4f25-970c-c1f9e32bac2c"
     },
     {
-      "uuid": "86b8f1e6-e088-403e-984a-abd360f5dcef",
-      "slug": "robot-name",
       "core": false,
-      "unlocked_by": "scrabble-score",
       "difficulty": 3,
+      "slug": "robot-name",
       "topics": [
-        "Randomness"
-      ]
+        "randomness"
+      ],
+      "unlocked_by": "scrabble-score",
+      "uuid": "86b8f1e6-e088-403e-984a-abd360f5dcef"
     },
     {
-      "uuid": "47b9ad32-e9d9-4cbc-b106-540f3afbfa80",
-      "slug": "diamond",
       "core": false,
-      "unlocked_by": "series",
       "difficulty": 4,
+      "slug": "diamond",
       "topics": [
-        "Strings",
-        "Text formatting",
-        "Algorithms",
-        "Control-flow (conditionals)",
-        "Control-flow (loops)"
-      ]
+        "algorithms",
+        "control-flow-(conditionals)",
+        "control-flow-(loops)",
+        "strings",
+        "text-formatting"
+      ],
+      "unlocked_by": "series",
+      "uuid": "47b9ad32-e9d9-4cbc-b106-540f3afbfa80"
     },
     {
-      "uuid": "4b168cb9-605b-465d-8f89-3a3b760c1402",
-      "slug": "react",
       "core": false,
-      "unlocked_by": "queen-attack",
       "difficulty": 9,
+      "slug": "react",
       "topics": [
-        "Reactive programming"
-      ]
+        "reactive-programming"
+      ],
+      "unlocked_by": "queen-attack",
+      "uuid": "4b168cb9-605b-465d-8f89-3a3b760c1402"
     },
     {
-      "uuid": "ad12bbf9-e0c8-433a-8a6b-847ff2d36acf",
-      "slug": "custom-set",
       "core": false,
-      "unlocked_by": "strain",
       "difficulty": 4,
+      "slug": "custom-set",
       "topics": [
-        "Sets",
-        "Control-flow (loops)",
-        "Filtering"
-      ]
+        "control-flow-(loops)",
+        "filtering",
+        "sets"
+      ],
+      "unlocked_by": "strain",
+      "uuid": "ad12bbf9-e0c8-433a-8a6b-847ff2d36acf"
     },
     {
-      "uuid": "84bda80c-b82c-45f6-95d4-5568d23a22dd",
-      "slug": "atbash-cipher",
       "core": false,
-      "unlocked_by": "luhn",
       "difficulty": 3,
+      "slug": "atbash-cipher",
       "topics": [
-        "Algorithms",
-        "Strings",
-        "Transforming",
-        "Cryptography"
-      ]
+        "algorithms",
+        "cryptography",
+        "strings",
+        "transforming"
+      ],
+      "unlocked_by": "luhn",
+      "uuid": "84bda80c-b82c-45f6-95d4-5568d23a22dd"
     },
     {
-      "uuid": "458053ea-43a9-409f-a1a6-a7f31329aca4",
-      "slug": "phone-number",
       "core": false,
-      "unlocked_by": "etl",
       "difficulty": 3,
+      "slug": "phone-number",
       "topics": [
-        "Control-flow (conditionals)",
-        "Strings",
-        "Transforming",
-        "Text formatting"
-      ]
+        "control-flow-(conditionals)",
+        "strings",
+        "text-formatting",
+        "transforming"
+      ],
+      "unlocked_by": "etl",
+      "uuid": "458053ea-43a9-409f-a1a6-a7f31329aca4"
     },
     {
-      "uuid": "4fe8ba14-20ba-4aa3-b134-7aed799a7522",
-      "slug": "pig-latin",
       "core": false,
-      "unlocked_by": "phone-number",
       "difficulty": 4,
+      "slug": "pig-latin",
       "topics": [
-        "Strings",
-        "Transforming",
-        "Control-flow (conditionals)"
-      ]
+        "control-flow-(conditionals)",
+        "strings",
+        "transforming"
+      ],
+      "unlocked_by": "phone-number",
+      "uuid": "4fe8ba14-20ba-4aa3-b134-7aed799a7522"
     },
     {
-      "uuid": "dbf4d64e-c02d-4bdf-8be1-43f9acb5f2ad",
-      "slug": "prime-factors",
       "core": false,
-      "unlocked_by": "clock",
       "difficulty": 3,
+      "slug": "prime-factors",
       "topics": [
-        "Mathematics",
-        "Algorithms",
-        "Integers"
-      ]
+        "algorithms",
+        "integers",
+        "mathematics"
+      ],
+      "unlocked_by": "clock",
+      "uuid": "dbf4d64e-c02d-4bdf-8be1-43f9acb5f2ad"
     },
     {
-      "uuid": "7f19ebbd-b072-45e5-ad67-2fff8ad1c9e2",
-      "slug": "transpose",
       "core": false,
-      "unlocked_by": "roman-numerals",
       "difficulty": 5,
+      "slug": "transpose",
       "topics": [
-        "Control-flow (loops)",
-        "Strings",
-        "Transforming"
-      ]
+        "control-flow-(loops)",
+        "strings",
+        "transforming"
+      ],
+      "unlocked_by": "roman-numerals",
+      "uuid": "7f19ebbd-b072-45e5-ad67-2fff8ad1c9e2"
     },
     {
-      "uuid": "128e0b12-0ad2-431a-971c-ad4ab098b42d",
-      "slug": "nth-prime",
       "core": false,
-      "unlocked_by": "difference-of-squares",
       "difficulty": 3,
+      "slug": "nth-prime",
       "topics": [
-        "Mathematics",
-        "Algorithms",
-        "Integers"
-      ]
+        "algorithms",
+        "integers",
+        "mathematics"
+      ],
+      "unlocked_by": "difference-of-squares",
+      "uuid": "128e0b12-0ad2-431a-971c-ad4ab098b42d"
     },
     {
-      "uuid": "f3058f8b-7e0e-4adb-9add-1df23607d4ed",
-      "slug": "diffie-hellman",
       "core": false,
-      "unlocked_by": "luhn",
       "difficulty": 5,
+      "slug": "diffie-hellman",
       "topics": [
-        "Cryptography",
-        "Integers",
-        "Algorithms",
-        "Transforming"
-      ]
+        "algorithms",
+        "cryptography",
+        "integers",
+        "transforming"
+      ],
+      "unlocked_by": "luhn",
+      "uuid": "f3058f8b-7e0e-4adb-9add-1df23607d4ed"
     },
     {
-      "uuid": "094ea17e-1759-443a-9117-7c72c6f68b8d",
-      "slug": "beer-song",
       "core": false,
-      "unlocked_by": "twelve-days",
       "difficulty": 3,
+      "slug": "beer-song",
       "topics": [
-          "Strings",
-          "Text formatting",
-          "Control-flow (loops)"
-      ]
+        "control-flow-(loops)",
+        "strings",
+        "text-formatting"
+      ],
+      "unlocked_by": "twelve-days",
+      "uuid": "094ea17e-1759-443a-9117-7c72c6f68b8d"
     },
     {
-      "uuid": "13e58d89-4dbb-4384-9268-2f8083588d7a",
-      "slug": "ocr-numbers",
       "core": false,
-      "unlocked_by": "poker",
       "difficulty": 7,
+      "slug": "ocr-numbers",
       "topics": [
-        "Parsing",
-        "Pattern recognition"
-      ]
+        "parsing",
+        "pattern-recognition"
+      ],
+      "unlocked_by": "poker",
+      "uuid": "13e58d89-4dbb-4384-9268-2f8083588d7a"
     },
     {
-      "uuid": "1eb7d7b2-6367-4038-bb86-7dc6c682b6a3",
-      "slug": "wordy",
       "core": false,
-      "unlocked_by": "triangle",
       "difficulty": 3,
+      "slug": "wordy",
       "topics": [
-        "Parsing",
-        "Control-flow (conditionals)",
-        "Type conversion",
-        "Integers",
-        "Strings"
-      ]
+        "control-flow-(conditionals)",
+        "integers",
+        "parsing",
+        "strings",
+        "type-conversion"
+      ],
+      "unlocked_by": "triangle",
+      "uuid": "1eb7d7b2-6367-4038-bb86-7dc6c682b6a3"
     },
     {
-      "uuid": "5911d90f-ba2f-482f-8c92-c01c112d6fdd",
-      "slug": "nucleotide-count",
       "core": false,
-      "unlocked_by": "scrabble-score",
       "difficulty": 2,
+      "slug": "nucleotide-count",
       "topics": [
-        "Strings",
-        "Parsing",
-        "Maps"
-      ]
+        "maps",
+        "parsing",
+        "strings"
+      ],
+      "unlocked_by": "scrabble-score",
+      "uuid": "5911d90f-ba2f-482f-8c92-c01c112d6fdd"
     },
     {
-      "uuid": "aa598f3e-9d2b-4f9f-8c14-46e0ac27d5be",
-      "slug": "grade-school",
       "core": false,
-      "unlocked_by": "word-count",
       "difficulty": 5,
+      "slug": "grade-school",
       "topics": [
-        "Sorting",
-        "Structs",
-        "Lists"
-      ]
+        "lists",
+        "sorting",
+        "structs"
+      ],
+      "unlocked_by": "word-count",
+      "uuid": "aa598f3e-9d2b-4f9f-8c14-46e0ac27d5be"
     },
     {
-      "uuid": "c78102b0-aaa3-4edb-a315-4fcdc26ccae8",
-      "slug": "saddle-points",
       "core": false,
-      "unlocked_by": "matrix",
       "difficulty": 5,
+      "slug": "saddle-points",
       "topics": [
-        "Arrays",
-        "Integers",
-        "Matrices",
-        "Searching"
-      ]
+        "arrays",
+        "integers",
+        "matrices",
+        "searching"
+      ],
+      "unlocked_by": "matrix",
+      "uuid": "c78102b0-aaa3-4edb-a315-4fcdc26ccae8"
     },
     {
-      "uuid": "fcf735fe-a659-40ae-858e-6d1e834a4faf",
-      "slug": "meetup",
       "core": false,
-      "unlocked_by": "roman-numerals",
       "difficulty": 3,
+      "slug": "meetup",
       "topics": [
-        "Dates",
-        "Time",
-        "Transforming",
-        "Type conversion"
-      ]
+        "dates",
+        "time",
+        "transforming",
+        "type-conversion"
+      ],
+      "unlocked_by": "roman-numerals",
+      "uuid": "fcf735fe-a659-40ae-858e-6d1e834a4faf"
     },
     {
-      "uuid": "ac680609-4e52-468d-bf17-afbf7b2fa74b",
-      "slug": "binary-search-tree",
       "core": false,
-      "unlocked_by": "binary-search",
       "difficulty": 5,
+      "slug": "binary-search-tree",
       "topics": [
-        "Algorithms",
-        "Recursion",
-        "Searching",
-        "Sorting",
-        "Structs",
-        "Trees"
-      ]
+        "algorithms",
+        "recursion",
+        "searching",
+        "sorting",
+        "structs",
+        "trees"
+      ],
+      "unlocked_by": "binary-search",
+      "uuid": "ac680609-4e52-468d-bf17-afbf7b2fa74b"
     },
     {
-      "uuid": "d0a2afab-e30d-4617-b646-413a44ecf2ed",
-      "slug": "tree-building",
       "core": false,
-      "unlocked_by": "series",
       "difficulty": 3,
+      "slug": "tree-building",
       "topics": [
-        "Records",
-        "Refactoring",
-        "Sorting",
-        "Trees"
-      ]
+        "records",
+        "refactoring",
+        "sorting",
+        "trees"
+      ],
+      "unlocked_by": "series",
+      "uuid": "d0a2afab-e30d-4617-b646-413a44ecf2ed"
     },
     {
-      "uuid": "4282b1f6-d1a2-41b4-9a7f-a9a145fb283b",
-      "slug": "kindergarten-garden",
       "core": false,
-      "unlocked_by": "clock",
       "difficulty": 3,
+      "slug": "kindergarten-garden",
       "topics": [
-        "Parsing",
-        "Records",
-        "Searching",
-        "Strings",
-        "Structs"
-      ]
+        "parsing",
+        "records",
+        "searching",
+        "strings",
+        "structs"
+      ],
+      "unlocked_by": "clock",
+      "uuid": "4282b1f6-d1a2-41b4-9a7f-a9a145fb283b"
     },
     {
-      "uuid": "7b9201fa-92d2-43fd-8b35-4c552336570b",
-      "slug": "simple-cipher",
       "core": false,
-      "unlocked_by": "luhn",
       "difficulty": 3,
+      "slug": "simple-cipher",
       "topics": [
-        "Algorithms",
-        "Cryptography",
-        "Interfaces",
-        "Strings",
-        "Transforming"
-      ]
+        "algorithms",
+        "cryptography",
+        "interfaces",
+        "strings",
+        "transforming"
+      ],
+      "unlocked_by": "luhn",
+      "uuid": "7b9201fa-92d2-43fd-8b35-4c552336570b"
     },
     {
-      "uuid": "5dbec590-7a50-4398-987b-7252734216a2",
-      "slug": "paasio",
       "core": false,
-      "unlocked_by": "parallel-letter-frequency",
       "difficulty": 5,
+      "slug": "paasio",
       "topics": [
-        "Concurrency",
-        "Interfaces",
-        "Networking"
-      ]
+        "concurrency",
+        "interfaces",
+        "networking"
+      ],
+      "unlocked_by": "parallel-letter-frequency",
+      "uuid": "5dbec590-7a50-4398-987b-7252734216a2"
     },
     {
-      "uuid": "cdbadf95-66ff-455f-bea3-eff5024afcb7",
-      "slug": "pov",
       "core": false,
-      "unlocked_by": "tree-building",
       "difficulty": 7,
+      "slug": "pov",
       "topics": [
-        "Graphs",
-        "Recursion",
-        "Structs",
-        "Transforming",
-        "Trees"
-      ]
+        "graphs",
+        "recursion",
+        "structs",
+        "transforming",
+        "trees"
+      ],
+      "unlocked_by": "tree-building",
+      "uuid": "cdbadf95-66ff-455f-bea3-eff5024afcb7"
     },
     {
-      "uuid": "3bf049f8-7283-4370-aa0c-e10e99d9ef80",
-      "slug": "minesweeper",
       "core": false,
-      "unlocked_by": "sieve",
       "difficulty": 5,
+      "slug": "minesweeper",
       "topics": [
-        "Arrays",
-        "Control-flow (loops)",
-        "Matrices",
-        "Games",
-        "Transforming"
-      ]
+        "arrays",
+        "control-flow-(loops)",
+        "games",
+        "matrices",
+        "transforming"
+      ],
+      "unlocked_by": "sieve",
+      "uuid": "3bf049f8-7283-4370-aa0c-e10e99d9ef80"
     },
     {
-      "uuid": "fc0e4034-0744-43f8-9969-7789cff0607f",
-      "slug": "robot-simulator",
       "core": false,
-      "unlocked_by": "queen-attack",
       "difficulty": 6,
+      "slug": "robot-simulator",
       "topics": [
-        "Concurrency",
-        "Control-flow (loops)",
-        "Sequences",
-        "Strings",
-        "Structs"
-      ]
+        "concurrency",
+        "control-flow-(loops)",
+        "sequences",
+        "strings",
+        "structs"
+      ],
+      "unlocked_by": "queen-attack",
+      "uuid": "fc0e4034-0744-43f8-9969-7789cff0607f"
     },
     {
-      "uuid": "572d03ec-d763-400e-ba4f-5a6a92d5af98",
-      "slug": "tournament",
       "core": false,
-      "unlocked_by": "kindergarten-garden",
       "difficulty": 3,
+      "slug": "tournament",
       "topics": [
-        "Integers",
-        "Parsing",
-        "Records",
-        "Sorting",
-        "Strings",
-        "Text formatting",
-        "Transforming"
-      ]
+        "integers",
+        "parsing",
+        "records",
+        "sorting",
+        "strings",
+        "text-formatting",
+        "transforming"
+      ],
+      "unlocked_by": "kindergarten-garden",
+      "uuid": "572d03ec-d763-400e-ba4f-5a6a92d5af98"
     },
     {
-      "uuid": "7fdf352b-e5a3-452e-91a2-03587be48ad0",
-      "slug": "word-search",
       "core": false,
-      "unlocked_by": "matrix",
       "difficulty": 4,
+      "slug": "word-search",
       "topics": [
-        "Matrices",
-        "Searching",
-        "Strings"
-      ]
+        "matrices",
+        "searching",
+        "strings"
+      ],
+      "unlocked_by": "matrix",
+      "uuid": "7fdf352b-e5a3-452e-91a2-03587be48ad0"
     },
     {
-      "uuid": "932a7ed0-c331-49b1-917b-a197198f642a",
-      "slug": "all-your-base",
       "core": false,
-      "unlocked_by": "wordy",
       "difficulty": 3,
+      "slug": "all-your-base",
       "topics": [
-        "Integers",
-        "Mathematics",
-        "Transforming"
-      ]
+        "integers",
+        "mathematics",
+        "transforming"
+      ],
+      "unlocked_by": "wordy",
+      "uuid": "932a7ed0-c331-49b1-917b-a197198f642a"
     },
     {
-      "uuid": "395116bc-5be9-4140-a2ef-c7e8689149f2",
-      "slug": "connect",
       "core": false,
-      "unlocked_by": "bowling",
       "difficulty": 9,
+      "slug": "connect",
       "topics": [
-        "Arrays",
-        "Control-flow (loops)",
-        "Games",
-        "Graphs",
-        "Searching"
-      ]
+        "arrays",
+        "control-flow-(loops)",
+        "games",
+        "graphs",
+        "searching"
+      ],
+      "unlocked_by": "bowling",
+      "uuid": "395116bc-5be9-4140-a2ef-c7e8689149f2"
     },
     {
-      "uuid": "7aa53a27-4ff3-4891-809f-2af728eb55a0",
-      "slug": "ledger",
       "core": false,
-      "unlocked_by": "series",
       "difficulty": 4,
+      "slug": "ledger",
       "topics": [
-        "Dates",
-        "Integers",
-        "Records",
-        "Refactoring",
-        "Sorting",
-        "Strings",
-        "Text formatting"
-      ]
+        "dates",
+        "integers",
+        "records",
+        "refactoring",
+        "sorting",
+        "strings",
+        "text-formatting"
+      ],
+      "unlocked_by": "series",
+      "uuid": "7aa53a27-4ff3-4891-809f-2af728eb55a0"
     },
     {
-      "uuid": "9be60690-39bb-4173-a2ed-faa4acd8f38f",
-      "slug": "poker",
       "core": false,
-      "unlocked_by": "tournament",
       "difficulty": 5,
+      "slug": "poker",
       "topics": [
-        "Equality",
-        "Games",
-        "Parsing",
-        "Pattern matching",
-        "Sequences",
-        "Strings"
-      ]
+        "equality",
+        "games",
+        "parsing",
+        "pattern-matching",
+        "sequences",
+        "strings"
+      ],
+      "unlocked_by": "tournament",
+      "uuid": "9be60690-39bb-4173-a2ed-faa4acd8f38f"
     },
     {
-      "uuid": "333231db-2605-438e-9eb0-d1bdc51c7419",
-      "slug": "variable-length-quantity",
       "core": false,
-      "unlocked_by": "grains",
       "difficulty": 5,
+      "slug": "variable-length-quantity",
       "topics": [
-        "Bitwise operations",
-        "Integers",
-        "Transforming"
-      ]
+        "bitwise-operations",
+        "integers",
+        "transforming"
+      ],
+      "unlocked_by": "grains",
+      "uuid": "333231db-2605-438e-9eb0-d1bdc51c7419"
     },
     {
-      "uuid": "09d0d78f-f262-4f34-b1de-c2acd7ed80cd",
-      "slug": "forth",
       "core": false,
-      "unlocked_by": "bracket-push",
       "difficulty": 8,
+      "slug": "forth",
       "topics": [
-        "Domain-specific languages",
-        "Parsing",
-        "Stacks"
-      ]
+        "domain-specific-languages",
+        "parsing",
+        "stacks"
+      ],
+      "unlocked_by": "bracket-push",
+      "uuid": "09d0d78f-f262-4f34-b1de-c2acd7ed80cd"
     },
     {
-      "uuid": "94a21509-ebd5-4a66-bb0e-0341e57e3c73",
-      "slug": "change",
       "core": false,
-      "unlocked_by": "kindergarten-garden",
       "difficulty": 5,
+      "slug": "change",
       "topics": [
-        "Algorithms",
-        "Arrays",
-        "Control-flow (loops)",
-        "Mathematics",
-        "Searching"
-      ]
+        "algorithms",
+        "arrays",
+        "control-flow-(loops)",
+        "mathematics",
+        "searching"
+      ],
+      "unlocked_by": "kindergarten-garden",
+      "uuid": "94a21509-ebd5-4a66-bb0e-0341e57e3c73"
     },
     {
-      "uuid": "8d5aaf47-7503-4797-85ed-d35a8755cfd4",
-      "slug": "bowling",
       "core": false,
-      "unlocked_by": "queen-attack",
       "difficulty": 5,
+      "slug": "bowling",
       "topics": [
-        "Algorithms",
-        "Arrays",
-        "Control-flow (conditionals)"
-      ]
+        "algorithms",
+        "arrays",
+        "control-flow-(conditionals)"
+      ],
+      "unlocked_by": "queen-attack",
+      "uuid": "8d5aaf47-7503-4797-85ed-d35a8755cfd4"
     },
     {
-      "uuid": "bf2dcbc4-266f-4cad-9cd7-76d446360a5d",
+      "deprecated": true,
       "slug": "binary",
-      "deprecated": true
+      "uuid": "bf2dcbc4-266f-4cad-9cd7-76d446360a5d"
     },
     {
-      "uuid": "9a06556b-a661-4329-97a1-b5d0f0c7590c",
+      "deprecated": true,
       "slug": "counter",
-      "deprecated": true
+      "uuid": "9a06556b-a661-4329-97a1-b5d0f0c7590c"
     },
     {
-      "uuid": "0c9cef3d-57f6-479a-aca4-25f310426d6a",
+      "deprecated": true,
       "slug": "hexadecimal",
-      "deprecated": true
+      "uuid": "0c9cef3d-57f6-479a-aca4-25f310426d6a"
     },
     {
-      "uuid": "4840c889-ebe5-4082-98c0-b9ed8618f6eb",
+      "deprecated": true,
       "slug": "octal",
-      "deprecated": true
+      "uuid": "4840c889-ebe5-4082-98c0-b9ed8618f6eb"
     },
     {
-      "uuid": "52af9f03-8b6b-4d75-a363-124f3269dccd",
+      "deprecated": true,
       "slug": "trinary",
-      "deprecated": true
+      "uuid": "52af9f03-8b6b-4d75-a363-124f3269dccd"
     }
-  ]
-}
+  ],
+  "foregone": [
+    "space-age",
+    "linked-list",
+    "simple-linked-list"
+  ],
+  "ignore_pattern": "example(?!.*test)",
+  "language": "Go"
+}