trackler 2.0.0.1 → 2.0.0.2

data/tracks/csharp/config.json

@@ -659,6 +659,14 @@
         "Arrays"        
       ]
     },
+    {
+      "slug": "rectangles",
+      "difficulty": 7,
+      "topics": [
+        "Parsing",
+        "Transforming"
+      ]
+    },
     {
       "slug": "wordy",
       "difficulty": 7,

data/tracks/csharp/exercises/bowling/BowlingTest.cs

@@ -1,75 +1,230 @@
-using NUnit.Framework;
+using System.Collections.Generic;
+using NUnit.Framework;
 
 public class BowlingTest
 {
     [Test]
-    public void Gutter_game()
+    public void Should_be_able_to_score_a_game_with_all_zeros()
     {
-        var game = new BowlingGame();
-        RollMany(0, 20, game);
+        var rolls = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        var game = RollMany(rolls, new BowlingGame());
         Assert.That(game.Score(), Is.EqualTo(0));
     }
 
     [Ignore("Remove to run test")]
     [Test]
-    public void All_ones_game()
+    public void Should_be_able_to_score_a_game_with_no_strikes_or_spares()
     {
-        var game = new BowlingGame();
-        RollMany(1, 20, game);
-        Assert.That(game.Score(), Is.EqualTo(20));
+        var rolls = new[] { 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.EqualTo(90));
     }
 
     [Ignore("Remove to run test")]
     [Test]
-    public void One_spare_game()
+    public void A_spare_followed_by_zeros_is_worth_ten_points()
     {
-        var game = new BowlingGame();
-        RollSpare(game);
-        game.Roll(3);
-        RollMany(0, 17, game);
+        var rolls = new[] { 6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.EqualTo(10));
+    }
 
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Points_scored_in_the_roll_after_a_spare_are_counted_twice()
+    {
+        var rolls = new[] { 6, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        var game = RollMany(rolls, new BowlingGame());
         Assert.That(game.Score(), Is.EqualTo(16));
     }
 
     [Ignore("Remove to run test")]
     [Test]
-    public void One_strike_game()
+    public void Consecutive_spares_each_get_a_one_roll_bonus()
+    {
+        var rolls = new[] { 5, 5, 3, 7, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.EqualTo(31));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void A_spare_in_the_last_frame_gets_a_one_roll_bonus_that_is_counted_once()
+    {
+        var rolls = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 7 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.EqualTo(17));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void A_strike_earns_ten_points_in_frame_with_a_single_roll()
+    {
+        var rolls = new[] { 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.EqualTo(10));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Points_scored_in_the_two_rolls_after_a_strike_are_counted_twice_as_a_bonus()
+    {
+        var rolls = new[] { 10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.EqualTo(26));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Consecutive_strikes_each_get_the_two_roll_bonus()
+    {
+        var rolls = new[] { 10, 10, 10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.EqualTo(81));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void A_strike_in_the_last_frame_gets_a_two_roll_bonus_that_is_counted_once()
     {
-        var game = new BowlingGame();
-        RollStrike(game);
-        game.Roll(3);
-        game.Roll(4);
-        RollMany(0, 16, game);
+        var rolls = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 1 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.EqualTo(18));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Rolling_a_spare_with_the_two_roll_bonus_does_not_get_a_bonus_roll()
+    {
+        var rolls = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 3 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.EqualTo(20));
+    }
 
-        Assert.That(game.Score(), Is.EqualTo(24));
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Strikes_with_the_two_roll_bonus_do_not_get_bonus_rolls()
+    {
+        var rolls = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 10 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.EqualTo(30));
     }
 
     [Ignore("Remove to run test")]
     [Test]
-    public void Perfect_game()
+    public void A_strike_with_the_one_roll_bonus_after_a_spare_in_the_last_frame_does_not_get_a_bonus()
     {
-        var game = new BowlingGame();
-        RollMany(10, 12, game);
+        var rolls = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 10 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.EqualTo(20));
+    }
 
+    [Ignore("Remove to run test")]
+    [Test]
+    public void All_strikes_is_a_perfect_game()
+    {
+        var rolls = new[] { 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 };
+        var game = RollMany(rolls, new BowlingGame());
         Assert.That(game.Score(), Is.EqualTo(300));
     }
 
-    private static void RollMany(int pins, int count, BowlingGame game)
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Rolls_can_not_score_negative_points()
     {
-        for (var i = 0; i < count; i++)
-        {
-            game.Roll(pins);
-        }
+        var rolls = new[] { -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.Null);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void A_roll_can_not_score_more_than_10_points()
+    {
+        var rolls = new[] { 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.Null);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Two_rolls_in_a_frame_can_not_score_more_than_10_points()
+    {
+        var rolls = new[] { 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.Null);
     }
 
-    private static void RollSpare(BowlingGame game)
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Two_bonus_rolls_after_a_strike_in_the_last_frame_can_not_score_more_than_10_points()
+    {
+        var rolls = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 5, 6 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.Null);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void An_unstarted_game_can_not_be_scored()
     {
-        game.Roll(5);
-        game.Roll(5);
+        var rolls = new int[0];
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.Null);
     }
 
-    private static void RollStrike(BowlingGame game)
+    [Ignore("Remove to run test")]
+    [Test]
+    public void An_incomplete_game_can_not_be_scored()
     {
-        game.Roll(10);
+        var rolls = new[] { 0, 0 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.Null);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void A_game_with_more_than_ten_frames_can_not_be_scored()
+    {
+        var rolls = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.Null);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Bonus_rolls_for_a_strike_in_the_last_frame_must_be_rolled_before_score_can_be_calculated()
+    {
+        var rolls = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.Null);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Both_bonus_rolls_for_a_strike_in_the_last_frame_must_be_rolled_before_score_can_be_calculated()
+    {
+        var rolls = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.Null);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Bonus_roll_for_a_spare_in_the_last_frame_must_be_rolled_before_score_can_be_calculated()
+    {
+        var rolls = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3 };
+        var game = RollMany(rolls, new BowlingGame());
+        Assert.That(game.Score(), Is.Null);
+    }
+    
+    private static BowlingGame RollMany(IEnumerable<int> rolls, BowlingGame game)
+    {
+        foreach (var pins in rolls)
+        {
+            game.Roll(pins);
+        }
+
+        return game;
     }
 }

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

@@ -9,38 +9,67 @@ public class BowlingGame
 
     public void Roll(int pins) => rolls.Add(pins);
 
-    public int Score()
+    public int? Score()
     {
         var score = 0;
         var frameIndex = 0;
 
-        for (int i = 0; i < NumberOfFrames; i++)
+        for (var i = 1; i <= NumberOfFrames; i++)
         {
+            if (rolls.Count <= frameIndex)
+            {
+                return null;
+            }
+
             if (IsStrike(frameIndex))
             {
-                score += 10 + StrikeBonus(frameIndex);
-                frameIndex += 1;
+                if (rolls.Count <= frameIndex + 2)
+                {
+                    return null;
+                }
+
+                var strikeBonus = StrikeBonus(frameIndex);
+                if (strikeBonus > MaximumFrameScore && !IsStrike(frameIndex + 1))
+                {
+                    return null;
+                }
+
+                score += 10 + strikeBonus;
+                frameIndex += i == NumberOfFrames ? 3 : 1;
             }
             else if (IsSpare(frameIndex))
             {
+                if (rolls.Count <= frameIndex + 2)
+                {
+                    return null;
+                }
+
                 score += 10 + SpareBonus(frameIndex);
-                frameIndex += 2;
+                frameIndex += i == NumberOfFrames ? 3 : 2;
             }
             else
             {
-                score += SumOfPinsInFrame(frameIndex);
+                var frameScore = FrameScore(frameIndex);
+                if (frameScore < 0 || frameScore > 10)
+                {
+                    return null;
+                }
+
+                score += frameScore;
                 frameIndex += 2;
             }
         }
-
-        return score;
+        
+        return CorrectNumberOfRolls(frameIndex) ? score : (int?)null;
     }
 
+    private bool CorrectNumberOfRolls(int frameIndex) => frameIndex == rolls.Count;
+
     private bool IsStrike(int frameIndex) => rolls[frameIndex] == MaximumFrameScore;
     private bool IsSpare(int frameIndex) => rolls[frameIndex] + rolls[frameIndex + 1] == MaximumFrameScore;
 
     private int StrikeBonus(int frameIndex) => rolls[frameIndex + 1] + rolls[frameIndex + 2];
     private int SpareBonus(int frameIndex) => rolls[frameIndex + 2];
 
-    private int SumOfPinsInFrame(int frameIndex) => rolls[frameIndex] + rolls[frameIndex + 1];
+    private int FrameScore(int frameIndex) => rolls[frameIndex] + rolls[frameIndex + 1];
 }

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

@@ -0,0 +1,91 @@
+using System;
+using System.Drawing;
+using System.Linq;
+
+public static class Rectangles
+{
+    public static int Count(string[] rows)
+    {
+        var grid = ParseGrid(rows);
+        var corners = FindCorners(grid);
+        return corners.Sum(corner => RectangleForCorner(corner, corners, grid));
+    }
+
+    private static CellType[][] ParseGrid(string[] rows)
+        => rows.Select(row => row.Select(ParseCell).ToArray()).ToArray();
+
+    private static CellType ParseCell(char cell)
+    {
+        switch (cell)
+        {
+            case '+':
+                return CellType.Corner;
+            case '-':
+                return CellType.HorizontalLine;
+            case '|':
+                return CellType.VerticalLine;
+            case ' ':
+                return CellType.Empty;
+            default:
+                throw new ArgumentException();
+        }
+    }
+
+    private static int Rows(CellType[][] grid) => grid.Length;
+
+    private static int Cols(CellType[][] grid) => grid[0].Length;
+
+    private static CellType Cell(Point point, CellType[][] grid) => grid[point.Y][point.X];
+
+    private static Point[] FindCorners(CellType[][] grid) =>
+        Enumerable.Range(0, Rows(grid)).SelectMany(y =>
+                    Enumerable.Range(0, Cols(grid)).Select(x => new Point(x, y)))
+            .Where(point => Cell(point, grid) == CellType.Corner)
+            .ToArray();
+
+    private static bool ConnectsVertically(Point point, CellType[][] grid) =>
+        (Cell(point, grid) == CellType.VerticalLine) ||
+        (Cell(point, grid) == CellType.Corner);
+
+    private static bool ConnectedVertically(Point top, Point bottom, CellType[][] grid) =>
+        Enumerable.Range(top.Y + 1, bottom.Y - top.Y - 1).All(y => ConnectsVertically(new Point(top.X, y), grid));
+
+    private static bool ConnectsHorizontally(Point point, CellType[][] grid) =>
+        (Cell(point, grid) == CellType.HorizontalLine) ||
+        (Cell(point, grid) == CellType.Corner);
+
+    private static bool ConnectedHorizontally(Point left, Point right, CellType[][] grid) =>
+        Enumerable.Range(left.X + 1, right.X - left.X - 1).All(x => ConnectsHorizontally(new Point(x, left.Y), grid));
+
+    private static bool IsTopLineOfRectangle(Point topLeft, Point topRight, CellType[][] grid) =>
+        (topRight.X > topLeft.X) && (topRight.Y == topLeft.Y) && ConnectedHorizontally(topLeft, topRight, grid);
+
+    private static bool IsRightLineOfRectangle(Point topRight, Point bottomRight, CellType[][] grid) =>
+        (bottomRight.X == topRight.X) && (bottomRight.Y > topRight.Y) &&
+        ConnectedVertically(topRight, bottomRight, grid);
+
+    private static bool IsBottomLineOfRectangle(Point bottomLeft, Point bottomRight, CellType[][] grid) =>
+        (bottomRight.X > bottomLeft.X) && (bottomRight.Y == bottomLeft.Y) &&
+        ConnectedHorizontally(bottomLeft, bottomRight, grid);
+
+    private static bool IsLeftLineOfRectangle(Point topLeft, Point bottomLeft, CellType[][] grid) =>
+        (bottomLeft.X == topLeft.X) && (bottomLeft.Y > topLeft.Y) && ConnectedVertically(topLeft, bottomLeft, grid);
+
+    private static int RectangleForCorner(Point topLeft, Point[] corners, CellType[][] grid)
+    {
+        return (from topRight in corners.Where(corner => IsTopLineOfRectangle(topLeft, corner, grid))
+                from bottomLeft in corners.Where(corner => IsLeftLineOfRectangle(topLeft, corner, grid))
+                from bottomRight in corners.Where(corner => IsRightLineOfRectangle(topRight, corner, grid) &&
+                                                            IsBottomLineOfRectangle(bottomLeft, corner, grid))
+                select 1)
+            .Count();
+    }
+
+    private enum CellType
+    {
+        Empty,
+        Corner,
+        HorizontalLine,
+        VerticalLine
+    }
+}

data/tracks/csharp/exercises/rectangles/RectanglesTest.cs

@@ -0,0 +1,133 @@
+using NUnit.Framework;
+
+public class RectanglesTest
+{
+    [Test]
+    public void No_rows()
+    {
+        var input = new string[0];
+        Assert.That(Rectangles.Count(input), Is.EqualTo(0));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void No_columns()
+    {
+        var input = new[] { "" };
+        Assert.That(Rectangles.Count(input), Is.EqualTo(0));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void No_rectangles()
+    {
+        var input = new[] { " " };
+        Assert.That(Rectangles.Count(input), Is.EqualTo(0));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void One_rectangle()
+    {
+        var input = new[]
+        {
+            "+-+",
+            "| |",
+            "+-+"
+        };
+        Assert.That(Rectangles.Count(input), Is.EqualTo(1));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Two_rectangles_without_shared_parts()
+    {
+        var input = new[]
+        {
+            "  +-+",
+            "  | |",
+            "+-+-+",
+            "| |  ",
+            "+-+  "
+        };
+        Assert.That(Rectangles.Count(input), Is.EqualTo(2));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Five_rectangles_with_shared_parts()
+    {
+        var input = new[]
+        {
+            "  +-+",
+            "  | |",
+            "+-+-+",
+            "| | |",
+            "+-+-+"
+        };
+        Assert.That(Rectangles.Count(input), Is.EqualTo(5));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Only_complete_rectangles_are_counted()
+    {
+        var input = new[]
+        {
+            "  +-+",
+            "    |",
+            "+-+-+",
+            "| | -",
+            "+-+-+"
+        };
+        Assert.That(Rectangles.Count(input), Is.EqualTo(1));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Rectangles_can_be_of_different_sizes()
+    {
+        var input = new[]
+        {
+            "+------+----+",
+            "|      |    |",
+            "+---+--+    |",
+            "|   |       |",
+            "+---+-------+"
+        };
+        Assert.That(Rectangles.Count(input), Is.EqualTo(3));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Corner_is_required_for_a_rectangle_to_be_complete()
+    {
+        var input = new[]
+        {
+            "+------+----+",
+            "|      |    |",
+            "+------+    |",
+            "|   |       |",
+            "+---+-------+"
+        };
+        Assert.That(Rectangles.Count(input), Is.EqualTo(2));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Large_input_with_many_rectangles()
+    {
+        var input = new[]
+        {
+            "+---+--+----+",
+            "|   +--+----+",
+            "+---+--+    |",
+            "|   +--+----+",
+            "+---+--+--+-+",
+            "+---+--+--+-+",
+            "+------+  | |",
+            "          +-+"
+        };
+        Assert.That(Rectangles.Count(input), Is.EqualTo(60));
+    }
+}

data/tracks/elisp/docs/INSTALLATION.org

@@ -43,7 +43,7 @@ manager or build from source as appropriate.
 *** Windows
 So you've decided to install Emacs on Windows.
 
-[[http:/www.zeldauniverse.net/wp-content/uploads/2012/01/83-Image-2.jpg]]
+[[http://www.zeldauniverse.net/wp-content/uploads/2012/01/83-Image-2.jpg]]
 
 I've never done it, but the prevailing wisdom is that you just need to visit the
 [[http://ftp.wayne.edu/gnu/emacs/windows/][FTP archive]], grab the correct binary (=emacs-24.x-bin-xxx.zip=), unzip it and

data/tracks/elixir/config.json

@@ -3,72 +3,6 @@
   "language": "Elixir",
   "repository": "https://github.com/exercism/xelixir",
   "active": true,
-  "problems": [
-    "hello-world",
-    "nucleotide-count",
-    "space-age",
-    "bob",
-    "word-count",
-    "accumulate",
-    "acronym",
-    "raindrops",
-    "run-length-encoding",
-    "sublist",
-    "scrabble-score",
-    "sum-of-multiples",
-    "anagram",
-    "bracket-push",
-    "rna-transcription",
-    "phone-number",
-    "nth-prime",
-    "roman-numerals",
-    "hamming",
-    "triangle",
-    "beer-song",
-    "isogram",
-    "grade-school",
-    "list-ops",
-    "flatten-array",
-    "leap",
-    "kindergarten-garden",
-    "etl",
-    "meetup",
-    "grains",
-    "change",
-    "parallel-letter-frequency",
-    "binary",
-    "luhn",
-    "markdown",
-    "gigasecond",
-    "queen-attack",
-    "pascals-triangle",
-    "saddle-points",
-    "hexadecimal",
-    "diamond",
-    "binary-search",
-    "prime-factors",
-    "sieve",
-    "wordy",
-    "robot-simulator",
-    "atbash-cipher",
-    "bank-account",
-    "largest-series-product",
-    "crypto-square",
-    "pythagorean-triplet",
-    "allergies",
-    "palindrome-products",
-    "rail-fence-cipher",
-    "zipper",
-    "minesweeper",
-    "connect",
-    "difference-of-squares",
-    "bowling",
-    "dot-dsl",
-    "custom-set",
-    "forth",
-    "pangram",
-    "clock"
-  ],
   "exercises": [
     {
       "slug": "hello-world",
@@ -460,6 +394,14 @@
         "Transforming",
         "Integers"
       ]
+    },
+    {
+      "slug": "grep",
+      "difficulty": 1,
+      "topics": [
+        "Strings",
+        "Enumerations"
+      ]
     }
   ],
   "deprecated": [

data/tracks/elixir/docs/LEARNING.md

@@ -2,7 +2,7 @@ Exercism provides exercises and feedback but can be difficult to jump into for t
 
 * [Elixir Getting Started Guide](http://elixir-lang.org/getting-started/introduction.html)
 * [Elixir Documentation](http://elixir-lang.org/docs/stable/elixir/)
-* [Programming Elixir](http://pragprog.com/book/elixir/programming-elixir), by Dave Thomas
+* [Programming Elixir](https://pragprog.com/book/elixir13/programming-elixir-1-3), by Dave Thomas
 * [StackOverflow](http://stackoverflow.com/questions/tagged/elixir)
 * [Introducing Elixir](http://shop.oreilly.com/product/0636920030584.do), by Simon St. Laurent, J. David Eisenberg
 * [Etudes for Elixir](http://chimera.labs.oreilly.com/books/1234000001642), by J. David Eisenberg (exercise companion for Intro to Elixir)