trackler 2.2.1.153 → 2.2.1.154

data/tracks/csharp/exercises/palindrome-products/Example.cs

@@ -2,61 +2,52 @@
 using System.Collections.Generic;
 using System.Linq;
 
-public class Palindrome
+public static class PalindromeProducts
 {
-    private Palindrome(int value, ISet<Tuple<int, int>> factors)
-    {
-        Value = value;
-        Factors = factors;
-    }
-
-    public int Value { get; }
-
-    public ISet<Tuple<int, int>> Factors { get; }
-
-    public static Palindrome Largest(int maxFactor)
-    {
-        return Largest(1, maxFactor);
-    }
-
-    public static Palindrome Largest(int minFactor, int maxFactor)
+    public static (int, IEnumerable<(int,int)>) Largest(int minFactor, int maxFactor)
     {
         return FindPalindrome(minFactor, maxFactor, x => x.Max(p => p.Item1));
     }
 
-    public static Palindrome Smallest(int maxFactor)
-    {
-        return Smallest(1, maxFactor);
-    }
-
-    public static Palindrome Smallest(int minFactor, int maxFactor)
+    public static (int, IEnumerable<(int,int)>) Smallest(int minFactor, int maxFactor)
     {
         return FindPalindrome(minFactor, maxFactor, x => x.Min(p => p.Item1));
     }
-    
-    private static Palindrome FindPalindrome(int minFactor, int maxFactor, Func<List<Tuple<int, Tuple<int, int>>>, int> valueSelector)
-    {
-        var palindromes = FindAllPalindromes(minFactor, maxFactor);
-        var value = valueSelector(palindromes);
-        var factors = new HashSet<Tuple<int, int>>(palindromes.Where(p => p.Item1 == value).Select(p => p.Item2));
 
-        return new Palindrome(value, factors);
+    private static (int, IEnumerable<(int, int)>) FindPalindrome(int minFactor, int maxFactor,
+        Func<List<(int, (int, int))>, int> valueSelector)
+    {
+        if (minFactor > maxFactor || maxFactor < minFactor)
+        {
+            throw new ArgumentException();    
+        }
+        
+        try
+        {
+            var palindromes = FindAllPalindromes(minFactor, maxFactor);
+            var value = valueSelector(palindromes);
+            var factors = new HashSet<(int, int)>(palindromes.Where(p => p.Item1 == value).Select(p => p.Item2));
+            return (value, factors);
+        } catch (InvalidOperationException)
+        {
+            throw new ArgumentException();
+        }
     }
 
-    private static List<Tuple<int, Tuple<int, int>>> FindAllPalindromes(int minFactor, int maxFactor)
+    private static List<(int, (int, int))> FindAllPalindromes(int minFactor, int maxFactor)
     {
         return (from pair in Pairs(minFactor, maxFactor)
                 let product = pair.Item1 * pair.Item2
                 where IsPalindrome(product)
-                select Tuple.Create(product, pair))
+                select (product, pair))
                 .ToList();
     }
 
-    private static IEnumerable<Tuple<int, int>> Pairs(int minFactor, int maxFactor)
+    private static IEnumerable<(int, int)> Pairs(int minFactor, int maxFactor)
     {
         return from x in Enumerable.Range(minFactor, maxFactor + 1 - minFactor)
                from y in Enumerable.Range(x, maxFactor + 1 - x)
-               select Tuple.Create(x, y);
+               select (x, y);
     }
 
     private static bool IsPalindrome(int num)

data/tracks/csharp/exercises/palindrome-products/PalindromeProducts.cs

@@ -2,40 +2,14 @@
 using System.Collections.Generic;
 using System.Linq;
 
-public class Palindrome
+public static class PalindromeProducts
 {
-    public int Value
-    {
-        get
-        {
-            throw new NotImplementedException("You need to implement this function.");
-        }
-    }
-
-    public ISet<Tuple<int, int>> Factors
-    {
-        get
-        {
-            throw new NotImplementedException("You need to implement this function.");
-        }
-    }
-
-    public static Palindrome Largest(int maxFactor)
-    {
-        throw new NotImplementedException("You need to implement this function.");
-    }
-
-    public static Palindrome Largest(int minFactor, int maxFactor)
-    {
-        throw new NotImplementedException("You need to implement this function.");
-    }
-
-    public static Palindrome Smallest(int maxFactor)
+    public static (int, IEnumerable<(int,int)>) Largest(int minFactor, int maxFactor)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public static Palindrome Smallest(int minFactor, int maxFactor)
+    public static (int, IEnumerable<(int,int)>) Smallest(int minFactor, int maxFactor)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

data/tracks/csharp/exercises/palindrome-products/PalindromeProductsTest.cs

@@ -0,0 +1,103 @@
+// This file was auto-generated based on version 1.1.0 of the canonical data.
+
+using Xunit;
+using System;
+
+public class PalindromeProductsTest
+{
+    [Fact]
+    public void Finds_the_smallest_palindrome_from_single_digit_factors()
+    {
+        var actual = PalindromeProducts.Smallest(1, 9);
+        var expected = (1, new[] { (1, 1) });
+        Assert.Equal(expected.Item1, actual.Item1);
+        Assert.Equal(expected.Item2, actual.Item2);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Finds_the_largest_palindrome_from_single_digit_factors()
+    {
+        var actual = PalindromeProducts.Largest(1, 9);
+        var expected = (9, new[] { (1, 9), (3, 3) });
+        Assert.Equal(expected.Item1, actual.Item1);
+        Assert.Equal(expected.Item2, actual.Item2);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Find_the_smallest_palindrome_from_double_digit_factors()
+    {
+        var actual = PalindromeProducts.Smallest(10, 99);
+        var expected = (121, new[] { (11, 11) });
+        Assert.Equal(expected.Item1, actual.Item1);
+        Assert.Equal(expected.Item2, actual.Item2);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Find_the_largest_palindrome_from_double_digit_factors()
+    {
+        var actual = PalindromeProducts.Largest(10, 99);
+        var expected = (9009, new[] { (91, 99) });
+        Assert.Equal(expected.Item1, actual.Item1);
+        Assert.Equal(expected.Item2, actual.Item2);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Find_smallest_palindrome_from_triple_digit_factors()
+    {
+        var actual = PalindromeProducts.Smallest(100, 999);
+        var expected = (10201, new[] { (101, 101) });
+        Assert.Equal(expected.Item1, actual.Item1);
+        Assert.Equal(expected.Item2, actual.Item2);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Find_the_largest_palindrome_from_triple_digit_factors()
+    {
+        var actual = PalindromeProducts.Largest(100, 999);
+        var expected = (906609, new[] { (913, 993) });
+        Assert.Equal(expected.Item1, actual.Item1);
+        Assert.Equal(expected.Item2, actual.Item2);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Find_smallest_palindrome_from_four_digit_factors()
+    {
+        var actual = PalindromeProducts.Smallest(1000, 9999);
+        var expected = (1002001, new[] { (1001, 1001) });
+        Assert.Equal(expected.Item1, actual.Item1);
+        Assert.Equal(expected.Item2, actual.Item2);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Find_the_largest_palindrome_from_four_digit_factors()
+    {
+        var actual = PalindromeProducts.Largest(1000, 9999);
+        var expected = (99000099, new[] { (9901, 9999) });
+        Assert.Equal(expected.Item1, actual.Item1);
+        Assert.Equal(expected.Item2, actual.Item2);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Empty_result_for_smallest_if_no_palindrome_in_the_range()
+    {
+        Assert.Throws<ArgumentException>(() => PalindromeProducts.Smallest(1002, 1003));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Empty_result_for_largest_if_no_palindrome_in_the_range()
+    {
+        Assert.Throws<ArgumentException>(() => PalindromeProducts.Largest(15, 15));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Error_result_for_smallest_if_min_is_more_than_max()
+    {
+        Assert.Throws<ArgumentException>(() => PalindromeProducts.Smallest(10000, 1));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Error_result_for_largest_if_min_is_more_than_max()
+    {
+        Assert.Throws<ArgumentException>(() => PalindromeProducts.Largest(2, 1));
+    }
+}

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

@@ -7,17 +7,18 @@ public class WordSearch
     private readonly string[] rows;
     private readonly int width;
     private readonly int height;
+    private (int, int)[] positions;
 
-    private static readonly Tuple<int, int>[] Directions =
+    private static readonly ValueTuple<int, int>[] Directions =
     {
-        new Tuple<int, int>( 1,  0),
-        new Tuple<int, int>( 0,  1),
-        new Tuple<int, int>(-1,  0),
-        new Tuple<int, int>( 0, -1),
-        new Tuple<int, int>( 1,  1),
-        new Tuple<int, int>( 1, -1),
-        new Tuple<int, int>(-1,  1),
-        new Tuple<int, int>(-1, -1)
+        ( 1,  0),
+        ( 0,  1),
+        (-1,  0),
+        ( 0, -1),
+        ( 1,  1),
+        ( 1, -1),
+        (-1,  1),
+        (-1, -1)
     };
 
     public WordSearch(string puzzle)
@@ -25,9 +26,15 @@ public WordSearch(string puzzle)
         rows = puzzle.Split('\n');
         width = rows[0].Length;
         height = rows.Length;
+        positions = Positions();
     }
 
-    public Tuple<Tuple<int, int>, Tuple<int, int>> Find(string word)
+    public Dictionary<string, ValueTuple<ValueTuple<int, int>, ValueTuple<int, int>>?> Search(IEnumerable<string> words)
+    {
+        return words.ToDictionary(word => word, Search);
+    }
+
+    private ValueTuple<ValueTuple<int, int>, ValueTuple<int, int>>? Search(string word)
     {
         return
             Positions()
@@ -35,7 +42,7 @@ public WordSearch(string puzzle)
                 .FirstOrDefault();
     }
 
-    private IEnumerable<Tuple<Tuple<int, int>, Tuple<int, int>>> Find(string word, Tuple<int, int> position, Tuple<int, int> direction)
+    private IEnumerable<ValueTuple<ValueTuple<int, int>, ValueTuple<int, int>>> Find(string word, ValueTuple<int, int> position, ValueTuple<int, int> direction)
     {
         var current = position;
 
@@ -46,13 +53,13 @@ public WordSearch(string puzzle)
                 yield break;
             }
 
-            current = new Tuple<int, int>(current.Item1 + direction.Item1, current.Item2 + direction.Item2);
+            current = (current.Item1 + direction.Item1, current.Item2 + direction.Item2);
         }
 
-        yield return Tuple.Create(position, new Tuple<int, int>(current.Item1 - direction.Item1, current.Item2 - direction.Item2));
+        yield return ValueTuple.Create(position, (current.Item1 - direction.Item1, current.Item2 - direction.Item2));
     }
 
-    private char? FindChar(Tuple<int, int> coordinate)
+    private char? FindChar(ValueTuple<int, int> coordinate)
     {
         if (coordinate.Item1 > 0 && coordinate.Item1 <= width && coordinate.Item2 > 0 && coordinate.Item2 <= height)
         {
@@ -62,9 +69,10 @@ public WordSearch(string puzzle)
         return null;
     }
 
-    private IEnumerable<Tuple<int, int>> Positions()
+    private ValueTuple<int, int>[] Positions()
     {
         return Enumerable.Range(1, width).SelectMany(x =>
-               Enumerable.Range(1, height).Select(y => new Tuple<int, int>(x, y)));
+               Enumerable.Range(1, height).Select(y => (x, y)))
+                .ToArray();
     }
 }

data/tracks/csharp/exercises/word-search/WordSearch.cs

@@ -4,12 +4,12 @@
 
 public class WordSearch
 {
-    public WordSearch(string puzzle)
+    public WordSearch(string grid)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public Tuple<Tuple<int, int>, Tuple<int, int>> Find(string word)
+    public ((int, int), (int, int)) Search(string wordsToSearchFor)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

data/tracks/csharp/exercises/word-search/WordSearchTest.cs

@@ -1,111 +1,584 @@
-using System;
+// This file was auto-generated based on version 1.2.0 of the canonical data.
+
 using Xunit;
+using System;
+using System.Collections.Generic;
 
 public class WordSearchTest
 {
-    private const string Puzzle =
-        "jefblpepre\n" +
-        "camdcimgtc\n" +
-        "oivokprjsm\n" +
-        "pbwasqroua\n" +
-        "rixilelhrs\n" +
-        "wolcqlirpc\n" +
-        "screeaumgr\n" +
-        "alxhpburyi\n" +
-        "jalaycalmp\n" +
-        "clojurermt";
-
     [Fact]
-    public void Should_find_horizontal_words_written_left_to_right()
+    public void Should_accept_an_initial_game_grid_and_a_target_search_word()
+    {
+        var wordsToSearchFor = new[]
+        {
+            "clojure"
+        };
+        var grid = "jefblpepre";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["clojure"] = null
+        };
+        Assert.Null(expected["clojure"]);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Should_locate_one_word_written_left_to_right()
     {
-        var wordSearch = new WordSearch(Puzzle);
-        var actual = wordSearch.Find("clojure");
-        Assert.Equal(new Tuple<int, int>(1, 10), actual.Item1);
-        Assert.Equal(new Tuple<int, int>(7, 10), actual.Item2);
+        var wordsToSearchFor = new[]
+        {
+            "clojure"
+        };
+        var grid = "clojurermt";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["clojure"] = ((1, 1), (7, 1))
+        };
+        Assert.Equal(expected["clojure"], actual["clojure"]);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Should_find_horizontal_words_written_right_to_left()
+    public void Should_locate_the_same_word_written_left_to_right_in_a_different_position()
     {
-        var wordSearch = new WordSearch(Puzzle);
-        var actual = wordSearch.Find("elixir");
-        Assert.Equal(new Tuple<int, int>(6, 5), actual.Item1);
-        Assert.Equal(new Tuple<int, int>(1, 5), actual.Item2);
+        var wordsToSearchFor = new[]
+        {
+            "clojure"
+        };
+        var grid = "mtclojurer";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["clojure"] = ((3, 1), (9, 1))
+        };
+        Assert.Equal(expected["clojure"], actual["clojure"]);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Should_find_vertical_words_written_top_to_bottom()
+    public void Should_locate_a_different_left_to_right_word()
     {
-        var wordSearch = new WordSearch(Puzzle);
-        var actual = wordSearch.Find("ecmascript");
-        Assert.Equal(new Tuple<int, int>(10, 1), actual.Item1);
-        Assert.Equal(new Tuple<int, int>(10, 10), actual.Item2);
+        var wordsToSearchFor = new[]
+        {
+            "coffee"
+        };
+        var grid = "coffeelplx";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["coffee"] = ((1, 1), (6, 1))
+        };
+        Assert.Equal(expected["coffee"], actual["coffee"]);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Should_find_vertical_words_written_bottom_to_top()
+    public void Should_locate_that_different_left_to_right_word_in_a_different_position()
     {
-        var wordSearch = new WordSearch(Puzzle);
-        var actual = wordSearch.Find("rust");
-        Assert.Equal(new Tuple<int, int>(9, 5), actual.Item1);
-        Assert.Equal(new Tuple<int, int>(9, 2), actual.Item2);
+        var wordsToSearchFor = new[]
+        {
+            "coffee"
+        };
+        var grid = "xcoffeezlp";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["coffee"] = ((2, 1), (7, 1))
+        };
+        Assert.Equal(expected["coffee"], actual["coffee"]);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Should_find_diagonal_words_written_top_left_to_bottom_right()
+    public void Should_locate_a_left_to_right_word_in_two_line_grid()
     {
-        var wordSearch = new WordSearch(Puzzle);
-        var actual = wordSearch.Find("java");
-        Assert.Equal(new Tuple<int, int>(1, 1), actual.Item1);
-        Assert.Equal(new Tuple<int, int>(4, 4), actual.Item2);
+        var wordsToSearchFor = new[]
+        {
+            "clojure"
+        };
+        var grid = 
+            "jefblpepre\n" +
+            "tclojurerm";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["clojure"] = ((2, 2), (8, 2))
+        };
+        Assert.Equal(expected["clojure"], actual["clojure"]);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Should_find_diagonal_upper_written_bottom_right_to_top_left()
+    public void Should_locate_a_left_to_right_word_in_three_line_grid()
     {
-        var wordSearch = new WordSearch(Puzzle);
-        var actual = wordSearch.Find("lua");
-        Assert.Equal(new Tuple<int, int>(8, 9), actual.Item1);
-        Assert.Equal(new Tuple<int, int>(6, 7), actual.Item2);
+        var wordsToSearchFor = new[]
+        {
+            "clojure"
+        };
+        var grid = 
+            "camdcimgtc\n" +
+            "jefblpepre\n" +
+            "clojurermt";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["clojure"] = ((1, 3), (7, 3))
+        };
+        Assert.Equal(expected["clojure"], actual["clojure"]);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Should_find_diagonal_upper_written_bottom_left_to_top_right()
+    public void Should_locate_a_left_to_right_word_in_ten_line_grid()
     {
-        var wordSearch = new WordSearch(Puzzle);
-        var actual = wordSearch.Find("lisp");
-        Assert.Equal(new Tuple<int, int>(3, 6), actual.Item1);
-        Assert.Equal(new Tuple<int, int>(6, 3), actual.Item2);
+        var wordsToSearchFor = new[]
+        {
+            "clojure"
+        };
+        var grid = 
+            "jefblpepre\n" +
+            "camdcimgtc\n" +
+            "oivokprjsm\n" +
+            "pbwasqroua\n" +
+            "rixilelhrs\n" +
+            "wolcqlirpc\n" +
+            "screeaumgr\n" +
+            "alxhpburyi\n" +
+            "jalaycalmp\n" +
+            "clojurermt";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["clojure"] = ((1, 10), (7, 10))
+        };
+        Assert.Equal(expected["clojure"], actual["clojure"]);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Should_find_diagonal_upper_written_top_right_to_bottom_left()
+    public void Should_locate_that_left_to_right_word_in_a_different_position_in_a_ten_line_grid()
     {
-        var wordSearch = new WordSearch(Puzzle);
-        var actual = wordSearch.Find("ruby");
-        Assert.Equal(new Tuple<int, int>(8, 6), actual.Item1);
-        Assert.Equal(new Tuple<int, int>(5, 9), actual.Item2);
+        var wordsToSearchFor = new[]
+        {
+            "clojure"
+        };
+        var grid = 
+            "jefblpepre\n" +
+            "camdcimgtc\n" +
+            "oivokprjsm\n" +
+            "pbwasqroua\n" +
+            "rixilelhrs\n" +
+            "wolcqlirpc\n" +
+            "screeaumgr\n" +
+            "alxhpburyi\n" +
+            "clojurermt\n" +
+            "jalaycalmp";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["clojure"] = ((1, 9), (7, 9))
+        };
+        Assert.Equal(expected["clojure"], actual["clojure"]);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Should_not_find_words_that_are_not_in_the_puzzle()
+    public void Should_locate_a_different_left_to_right_word_in_a_ten_line_grid()
     {
-        var wordSearch = new WordSearch(Puzzle);
-        var actual = wordSearch.Find("haskell");
-        Assert.Null(actual);
+        var wordsToSearchFor = new[]
+        {
+            "fortran"
+        };
+        var grid = 
+            "jefblpepre\n" +
+            "camdcimgtc\n" +
+            "oivokprjsm\n" +
+            "pbwasqroua\n" +
+            "rixilelhrs\n" +
+            "wolcqlirpc\n" +
+            "fortranftw\n" +
+            "alxhpburyi\n" +
+            "clojurermt\n" +
+            "jalaycalmp";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["fortran"] = ((1, 7), (7, 7))
+        };
+        Assert.Equal(expected["fortran"], actual["fortran"]);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Should_be_able_to_search_differently_sized_puzzles()
+    public void Should_locate_multiple_words()
     {
-        const string differentSizePuzzle =
-            "qwertyuiopz\n" +
-            "luamsicrexe\n" +
-            "abcdefghijk";
-        var wordSearch = new WordSearch(differentSizePuzzle);
+        var wordsToSearchFor = new[]
+        {
+            "fortran",
+            "clojure"
+        };
+        var grid = 
+            "jefblpepre\n" +
+            "camdcimgtc\n" +
+            "oivokprjsm\n" +
+            "pbwasqroua\n" +
+            "rixilelhrs\n" +
+            "wolcqlirpc\n" +
+            "fortranftw\n" +
+            "alxhpburyi\n" +
+            "jalaycalmp\n" +
+            "clojurermt";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["clojure"] = ((1, 10), (7, 10)),
+            ["fortran"] = ((1, 7), (7, 7))
+        };
+        Assert.Equal(expected["clojure"], actual["clojure"]);
+        Assert.Equal(expected["fortran"], actual["fortran"]);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Should_locate_a_single_word_written_right_to_left()
+    {
+        var wordsToSearchFor = new[]
+        {
+            "elixir"
+        };
+        var grid = "rixilelhrs";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["elixir"] = ((6, 1), (1, 1))
+        };
+        Assert.Equal(expected["elixir"], actual["elixir"]);
+    }
 
-        var actual = wordSearch.Find("exercism");
-        Assert.Equal(new Tuple<int, int>(11, 2), actual.Item1);
-        Assert.Equal(new Tuple<int, int>(4, 2), actual.Item2);
+    [Fact(Skip = "Remove to run test")]
+    public void Should_locate_multiple_words_written_in_different_horizontal_directions()
+    {
+        var wordsToSearchFor = new[]
+        {
+            "elixir",
+            "clojure"
+        };
+        var grid = 
+            "jefblpepre\n" +
+            "camdcimgtc\n" +
+            "oivokprjsm\n" +
+            "pbwasqroua\n" +
+            "rixilelhrs\n" +
+            "wolcqlirpc\n" +
+            "screeaumgr\n" +
+            "alxhpburyi\n" +
+            "jalaycalmp\n" +
+            "clojurermt";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["clojure"] = ((1, 10), (7, 10)),
+            ["elixir"] = ((6, 5), (1, 5))
+        };
+        Assert.Equal(expected["clojure"], actual["clojure"]);
+        Assert.Equal(expected["elixir"], actual["elixir"]);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Should_locate_words_written_top_to_bottom()
+    {
+        var wordsToSearchFor = new[]
+        {
+            "clojure",
+            "elixir",
+            "ecmascript"
+        };
+        var grid = 
+            "jefblpepre\n" +
+            "camdcimgtc\n" +
+            "oivokprjsm\n" +
+            "pbwasqroua\n" +
+            "rixilelhrs\n" +
+            "wolcqlirpc\n" +
+            "screeaumgr\n" +
+            "alxhpburyi\n" +
+            "jalaycalmp\n" +
+            "clojurermt";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["clojure"] = ((1, 10), (7, 10)),
+            ["elixir"] = ((6, 5), (1, 5)),
+            ["ecmascript"] = ((10, 1), (10, 10))
+        };
+        Assert.Equal(expected["clojure"], actual["clojure"]);
+        Assert.Equal(expected["elixir"], actual["elixir"]);
+        Assert.Equal(expected["ecmascript"], actual["ecmascript"]);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Should_locate_words_written_bottom_to_top()
+    {
+        var wordsToSearchFor = new[]
+        {
+            "clojure",
+            "elixir",
+            "ecmascript",
+            "rust"
+        };
+        var grid = 
+            "jefblpepre\n" +
+            "camdcimgtc\n" +
+            "oivokprjsm\n" +
+            "pbwasqroua\n" +
+            "rixilelhrs\n" +
+            "wolcqlirpc\n" +
+            "screeaumgr\n" +
+            "alxhpburyi\n" +
+            "jalaycalmp\n" +
+            "clojurermt";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["clojure"] = ((1, 10), (7, 10)),
+            ["elixir"] = ((6, 5), (1, 5)),
+            ["ecmascript"] = ((10, 1), (10, 10)),
+            ["rust"] = ((9, 5), (9, 2))
+        };
+        Assert.Equal(expected["clojure"], actual["clojure"]);
+        Assert.Equal(expected["elixir"], actual["elixir"]);
+        Assert.Equal(expected["ecmascript"], actual["ecmascript"]);
+        Assert.Equal(expected["rust"], actual["rust"]);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Should_locate_words_written_top_left_to_bottom_right()
+    {
+        var wordsToSearchFor = new[]
+        {
+            "clojure",
+            "elixir",
+            "ecmascript",
+            "rust",
+            "java"
+        };
+        var grid = 
+            "jefblpepre\n" +
+            "camdcimgtc\n" +
+            "oivokprjsm\n" +
+            "pbwasqroua\n" +
+            "rixilelhrs\n" +
+            "wolcqlirpc\n" +
+            "screeaumgr\n" +
+            "alxhpburyi\n" +
+            "jalaycalmp\n" +
+            "clojurermt";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["clojure"] = ((1, 10), (7, 10)),
+            ["elixir"] = ((6, 5), (1, 5)),
+            ["ecmascript"] = ((10, 1), (10, 10)),
+            ["rust"] = ((9, 5), (9, 2)),
+            ["java"] = ((1, 1), (4, 4))
+        };
+        Assert.Equal(expected["clojure"], actual["clojure"]);
+        Assert.Equal(expected["elixir"], actual["elixir"]);
+        Assert.Equal(expected["ecmascript"], actual["ecmascript"]);
+        Assert.Equal(expected["rust"], actual["rust"]);
+        Assert.Equal(expected["java"], actual["java"]);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Should_locate_words_written_bottom_right_to_top_left()
+    {
+        var wordsToSearchFor = new[]
+        {
+            "clojure",
+            "elixir",
+            "ecmascript",
+            "rust",
+            "java",
+            "lua"
+        };
+        var grid = 
+            "jefblpepre\n" +
+            "camdcimgtc\n" +
+            "oivokprjsm\n" +
+            "pbwasqroua\n" +
+            "rixilelhrs\n" +
+            "wolcqlirpc\n" +
+            "screeaumgr\n" +
+            "alxhpburyi\n" +
+            "jalaycalmp\n" +
+            "clojurermt";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["clojure"] = ((1, 10), (7, 10)),
+            ["elixir"] = ((6, 5), (1, 5)),
+            ["ecmascript"] = ((10, 1), (10, 10)),
+            ["rust"] = ((9, 5), (9, 2)),
+            ["java"] = ((1, 1), (4, 4)),
+            ["lua"] = ((8, 9), (6, 7))
+        };
+        Assert.Equal(expected["clojure"], actual["clojure"]);
+        Assert.Equal(expected["elixir"], actual["elixir"]);
+        Assert.Equal(expected["ecmascript"], actual["ecmascript"]);
+        Assert.Equal(expected["rust"], actual["rust"]);
+        Assert.Equal(expected["java"], actual["java"]);
+        Assert.Equal(expected["lua"], actual["lua"]);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Should_locate_words_written_bottom_left_to_top_right()
+    {
+        var wordsToSearchFor = new[]
+        {
+            "clojure",
+            "elixir",
+            "ecmascript",
+            "rust",
+            "java",
+            "lua",
+            "lisp"
+        };
+        var grid = 
+            "jefblpepre\n" +
+            "camdcimgtc\n" +
+            "oivokprjsm\n" +
+            "pbwasqroua\n" +
+            "rixilelhrs\n" +
+            "wolcqlirpc\n" +
+            "screeaumgr\n" +
+            "alxhpburyi\n" +
+            "jalaycalmp\n" +
+            "clojurermt";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["clojure"] = ((1, 10), (7, 10)),
+            ["elixir"] = ((6, 5), (1, 5)),
+            ["ecmascript"] = ((10, 1), (10, 10)),
+            ["rust"] = ((9, 5), (9, 2)),
+            ["java"] = ((1, 1), (4, 4)),
+            ["lua"] = ((8, 9), (6, 7)),
+            ["lisp"] = ((3, 6), (6, 3))
+        };
+        Assert.Equal(expected["clojure"], actual["clojure"]);
+        Assert.Equal(expected["elixir"], actual["elixir"]);
+        Assert.Equal(expected["ecmascript"], actual["ecmascript"]);
+        Assert.Equal(expected["rust"], actual["rust"]);
+        Assert.Equal(expected["java"], actual["java"]);
+        Assert.Equal(expected["lua"], actual["lua"]);
+        Assert.Equal(expected["lisp"], actual["lisp"]);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Should_locate_words_written_top_right_to_bottom_left()
+    {
+        var wordsToSearchFor = new[]
+        {
+            "clojure",
+            "elixir",
+            "ecmascript",
+            "rust",
+            "java",
+            "lua",
+            "lisp",
+            "ruby"
+        };
+        var grid = 
+            "jefblpepre\n" +
+            "camdcimgtc\n" +
+            "oivokprjsm\n" +
+            "pbwasqroua\n" +
+            "rixilelhrs\n" +
+            "wolcqlirpc\n" +
+            "screeaumgr\n" +
+            "alxhpburyi\n" +
+            "jalaycalmp\n" +
+            "clojurermt";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["clojure"] = ((1, 10), (7, 10)),
+            ["elixir"] = ((6, 5), (1, 5)),
+            ["ecmascript"] = ((10, 1), (10, 10)),
+            ["rust"] = ((9, 5), (9, 2)),
+            ["java"] = ((1, 1), (4, 4)),
+            ["lua"] = ((8, 9), (6, 7)),
+            ["lisp"] = ((3, 6), (6, 3)),
+            ["ruby"] = ((8, 6), (5, 9))
+        };
+        Assert.Equal(expected["clojure"], actual["clojure"]);
+        Assert.Equal(expected["elixir"], actual["elixir"]);
+        Assert.Equal(expected["ecmascript"], actual["ecmascript"]);
+        Assert.Equal(expected["rust"], actual["rust"]);
+        Assert.Equal(expected["java"], actual["java"]);
+        Assert.Equal(expected["lua"], actual["lua"]);
+        Assert.Equal(expected["lisp"], actual["lisp"]);
+        Assert.Equal(expected["ruby"], actual["ruby"]);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Should_fail_to_locate_a_word_that_is_not_in_the_puzzle()
+    {
+        var wordsToSearchFor = new[]
+        {
+            "clojure",
+            "elixir",
+            "ecmascript",
+            "rust",
+            "java",
+            "lua",
+            "lisp",
+            "ruby",
+            "haskell"
+        };
+        var grid = 
+            "jefblpepre\n" +
+            "camdcimgtc\n" +
+            "oivokprjsm\n" +
+            "pbwasqroua\n" +
+            "rixilelhrs\n" +
+            "wolcqlirpc\n" +
+            "screeaumgr\n" +
+            "alxhpburyi\n" +
+            "jalaycalmp\n" +
+            "clojurermt";
+        var sut = new WordSearch(grid);
+        var actual = sut.Search(wordsToSearchFor);
+        var expected = new Dictionary<string, ((int, int), (int, int))?>
+        {
+            ["clojure"] = ((1, 10), (7, 10)),
+            ["elixir"] = ((6, 5), (1, 5)),
+            ["ecmascript"] = ((10, 1), (10, 10)),
+            ["rust"] = ((9, 5), (9, 2)),
+            ["java"] = ((1, 1), (4, 4)),
+            ["lua"] = ((8, 9), (6, 7)),
+            ["lisp"] = ((3, 6), (6, 3)),
+            ["ruby"] = ((8, 6), (5, 9)),
+            ["haskell"] = null
+        };
+        Assert.Equal(expected["clojure"], actual["clojure"]);
+        Assert.Equal(expected["elixir"], actual["elixir"]);
+        Assert.Equal(expected["ecmascript"], actual["ecmascript"]);
+        Assert.Equal(expected["rust"], actual["rust"]);
+        Assert.Equal(expected["java"], actual["java"]);
+        Assert.Equal(expected["lua"], actual["lua"]);
+        Assert.Equal(expected["lisp"], actual["lisp"]);
+        Assert.Equal(expected["ruby"], actual["ruby"]);
+        Assert.Null(expected["haskell"]);
     }
 }