trackler 2.0.8.14 → 2.0.8.15

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

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Drawing;
 using System.Linq;
 
 public class WordSearch
@@ -9,16 +8,16 @@ public class WordSearch
     private readonly int width;
     private readonly int height;
 
-    private static readonly Point[] Directions =
+    private static readonly Tuple<int, int>[] Directions =
     {
-        new Point( 1,  0),
-        new Point( 0,  1),
-        new Point(-1,  0),
-        new Point( 0, -1),
-        new Point( 1,  1),
-        new Point( 1, -1),
-        new Point(-1,  1),
-        new Point(-1, -1)
+        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)
     };
 
     public WordSearch(string puzzle)
@@ -28,7 +27,7 @@ public class WordSearch
         height = rows.Length;
     }
 
-    public Tuple<Point, Point> Find(string word)
+    public Tuple<Tuple<int, int>, Tuple<int, int>> Find(string word)
     {
         return
             Positions()
@@ -36,7 +35,7 @@ public class WordSearch
                 .FirstOrDefault();
     }
 
-    private IEnumerable<Tuple<Point, Point>> Find(string word, Point position, Point direction)
+    private IEnumerable<Tuple<Tuple<int, int>, Tuple<int, int>>> Find(string word, Tuple<int, int> position, Tuple<int, int> direction)
     {
         var current = position;
 
@@ -47,26 +46,25 @@ public class WordSearch
                 yield break;
             }
 
-            current.X += direction.X;
-            current.Y += direction.Y;
+            current = new Tuple<int, int>(current.Item1 + direction.Item1, current.Item2 + direction.Item2);
         }
 
-        yield return Tuple.Create(position, new Point(current.X - direction.X, current.Y - direction.Y));
+        yield return Tuple.Create(position, new Tuple<int, int>(current.Item1 - direction.Item1, current.Item2 - direction.Item2));
     }
 
-    private char? FindChar(Point coordinate)
+    private char? FindChar(Tuple<int, int> coordinate)
     {
-        if (coordinate.X > 0 && coordinate.X <= width && coordinate.Y > 0 && coordinate.Y <= height)
+        if (coordinate.Item1 > 0 && coordinate.Item1 <= width && coordinate.Item2 > 0 && coordinate.Item2 <= height)
         {
-            return rows[coordinate.Y - 1][coordinate.X - 1];
+            return rows[coordinate.Item2 - 1][coordinate.Item1 - 1];
         }
 
         return null;
     }
 
-    private IEnumerable<Point> Positions()
+    private IEnumerable<Tuple<int, int>> Positions()
     {
         return Enumerable.Range(1, width).SelectMany(x =>
-               Enumerable.Range(1, height).Select(y =>new Point(x, y)));
+               Enumerable.Range(1, height).Select(y => new Tuple<int, int>(x, y)));
     }
 }

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

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public class WordSearch
+{
+    public WordSearch(string puzzle)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public Tuple<Tuple<int, int>, Tuple<int, int>> Find(string word)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

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

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp1.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="Example.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
+    <PackageReference Include="xunit" Version="2.2.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
+  </ItemGroup>
+
+</Project>

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

@@ -1,6 +1,5 @@
 using System;
-using System.Drawing;
-using NUnit.Framework;
+using Xunit;
 
 public class WordSearchTest
 {
@@ -16,88 +15,87 @@ public class WordSearchTest
         "jalaycalmp\n" +
         "clojurermt";
 
-    [Test]
+    [Fact]
     public void Should_find_horizontal_words_written_left_to_right()
     {
         var wordSearch = new WordSearch(Puzzle);
         var actual = wordSearch.Find("clojure");
-        Assert.That(actual, Is.EqualTo(Tuple.Create(new Point(1, 10), new Point(7, 10))));
+        Assert.Equal(new Tuple<int, int>(1, 10), actual.Item1);
+        Assert.Equal(new Tuple<int, int>(7, 10), actual.Item2);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Should_find_horizontal_words_written_right_to_left()
     {
         var wordSearch = new WordSearch(Puzzle);
         var actual = wordSearch.Find("elixir");
-        Assert.That(actual, Is.EqualTo(Tuple.Create(new Point(6, 5), new Point(1, 5))));
+        Assert.Equal(new Tuple<int, int>(6, 5), actual.Item1);
+        Assert.Equal(new Tuple<int, int>(1, 5), actual.Item2);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Should_find_vertical_words_written_top_to_bottom()
     {
         var wordSearch = new WordSearch(Puzzle);
         var actual = wordSearch.Find("ecmascript");
-        Assert.That(actual, Is.EqualTo(Tuple.Create(new Point(10, 1), new Point(10, 10))));
+        Assert.Equal(new Tuple<int, int>(10, 1), actual.Item1);
+        Assert.Equal(new Tuple<int, int>(10, 10), actual.Item2);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Should_find_vertical_words_written_bottom_to_top()
     {
         var wordSearch = new WordSearch(Puzzle);
         var actual = wordSearch.Find("rust");
-        Assert.That(actual, Is.EqualTo(Tuple.Create(new Point(9, 5), new Point(9, 2))));
+        Assert.Equal(new Tuple<int, int>(9, 5), actual.Item1);
+        Assert.Equal(new Tuple<int, int>(9, 2), actual.Item2);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Should_find_diagonal_words_written_top_left_to_bottom_right()
     {
         var wordSearch = new WordSearch(Puzzle);
         var actual = wordSearch.Find("java");
-        Assert.That(actual, Is.EqualTo(Tuple.Create(new Point(1, 1), new Point(4, 4))));
+        Assert.Equal(new Tuple<int, int>(1, 1), actual.Item1);
+        Assert.Equal(new Tuple<int, int>(4, 4), actual.Item2);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Should_find_diagonal_upper_written_bottom_right_to_top_left()
     {
         var wordSearch = new WordSearch(Puzzle);
         var actual = wordSearch.Find("lua");
-        Assert.That(actual, Is.EqualTo(Tuple.Create(new Point(8, 9), new Point(6, 7))));
+        Assert.Equal(new Tuple<int, int>(8, 9), actual.Item1);
+        Assert.Equal(new Tuple<int, int>(6, 7), actual.Item2);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Should_find_diagonal_upper_written_bottom_left_to_top_right()
     {
         var wordSearch = new WordSearch(Puzzle);
         var actual = wordSearch.Find("lisp");
-        Assert.That(actual, Is.EqualTo(Tuple.Create(new Point(3, 6), new Point(6, 3))));
+        Assert.Equal(new Tuple<int, int>(3, 6), actual.Item1);
+        Assert.Equal(new Tuple<int, int>(6, 3), actual.Item2);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Should_find_diagonal_upper_written_top_right_to_bottom_left()
     {
         var wordSearch = new WordSearch(Puzzle);
         var actual = wordSearch.Find("ruby");
-        Assert.That(actual, Is.EqualTo(Tuple.Create(new Point(8, 6), new Point(5, 9))));
+        Assert.Equal(new Tuple<int, int>(8, 6), actual.Item1);
+        Assert.Equal(new Tuple<int, int>(5, 9), actual.Item2);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Should_not_find_words_that_are_not_in_the_puzzle()
     {
         var wordSearch = new WordSearch(Puzzle);
         var actual = wordSearch.Find("haskell");
-        Assert.That(actual, Is.Null);
+        Assert.Null(actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Should_be_able_to_search_differently_sized_puzzles()
     {
         const string differentSizePuzzle =
@@ -107,6 +105,7 @@ public class WordSearchTest
         var wordSearch = new WordSearch(differentSizePuzzle);
 
         var actual = wordSearch.Find("exercism");
-        Assert.That(actual, Is.EqualTo(Tuple.Create(new Point(11, 2), new Point(4, 2))));
+        Assert.Equal(new Tuple<int, int>(11, 2), actual.Item1);
+        Assert.Equal(new Tuple<int, int>(4, 2), actual.Item2);
     }
 }

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

@@ -2,7 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Text.RegularExpressions;
 
-public class WordProblem
+public static class WordProblem
 {
     private static readonly Regex VariableAndOperatorGroupsRegex =
         new Regex(string.Format(@"{0} {1} {0}\s*{1}*\s*{0}*", @"(-?\d+)", "(plus|minus|multiplied by|divided by)"));

data/tracks/csharp/exercises/wordy/Wordy.cs

@@ -0,0 +1,9 @@
+using System;
+
+public static class WordProblem
+{
+    public static int Solve(string problem)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/wordy/Wordy.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp1.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="Example.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
+    <PackageReference Include="xunit" Version="2.2.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
+  </ItemGroup>
+
+</Project>

data/tracks/csharp/exercises/wordy/WordyTest.cs

@@ -1,116 +1,101 @@
-using NUnit.Framework;
+using System;
+using Xunit;
 
-[TestFixture]
 public class WordProblemTest
 {
-    [Test]
+    [Fact]
     public void Can_parse_and_solve_addition_problems()
     {
-        Assert.That(WordProblem.Solve("What is 1 plus 1?"), Is.EqualTo(2));
+        Assert.Equal(2, WordProblem.Solve("What is 1 plus 1?"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_add_double_digit_numbers()
     {
-        Assert.That(WordProblem.Solve("What is 53 plus 2?"), Is.EqualTo(55));
+        Assert.Equal(55, WordProblem.Solve("What is 53 plus 2?"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_add_negative_numbers()
     {
-        Assert.That(WordProblem.Solve("What is -1 plus -10?"), Is.EqualTo(-11));
+        Assert.Equal(-11, WordProblem.Solve("What is -1 plus -10?"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_add_large_numbers()
     {
-        Assert.That(WordProblem.Solve("What is 123 plus 45678?"), Is.EqualTo(45801));
+        Assert.Equal(45801, WordProblem.Solve("What is 123 plus 45678?"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_parse_and_solve_subtraction_problems()
     {
-        Assert.That(WordProblem.Solve("What is 4 minus -12"), Is.EqualTo(16));
+        Assert.Equal(16, WordProblem.Solve("What is 4 minus -12"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_parse_and_solve_multiplication_problems()
     {
-        Assert.That(WordProblem.Solve("What is -3 multiplied by 25?"), Is.EqualTo(-75));
+        Assert.Equal(-75, WordProblem.Solve("What is -3 multiplied by 25?"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_parse_and_solve_division_problems()
     {
-        Assert.That(WordProblem.Solve("What is 33 divided by -3?"), Is.EqualTo(-11));
+        Assert.Equal(-11, WordProblem.Solve("What is 33 divided by -3?"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_add_twice()
     {
-        Assert.That(WordProblem.Solve("What is 1 plus 1 plus 1?"), Is.EqualTo(3));
+        Assert.Equal(3, WordProblem.Solve("What is 1 plus 1 plus 1?"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_add_then_subtract()
     {
-        Assert.That(WordProblem.Solve("What is 1 plus 5 minus -2?"), Is.EqualTo(8));
+        Assert.Equal(8, WordProblem.Solve("What is 1 plus 5 minus -2?"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_subtract_twice()
     {
-        Assert.That(WordProblem.Solve("What is 20 minus 4 minus 13?"), Is.EqualTo(3));
+        Assert.Equal(3, WordProblem.Solve("What is 20 minus 4 minus 13?"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_subtract_then_add()
     {
-        Assert.That(WordProblem.Solve("What is 17 minus 6 plus 3?"), Is.EqualTo(14));
+        Assert.Equal(14, WordProblem.Solve("What is 17 minus 6 plus 3?"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_multiply_twice()
     {
-        Assert.That(WordProblem.Solve("What is 2 multiplied by -2 multiplied by 3?"), Is.EqualTo(-12));
+        Assert.Equal(-12, WordProblem.Solve("What is 2 multiplied by -2 multiplied by 3?"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_add_then_multiply()
     {
-        Assert.That(WordProblem.Solve("What is -3 plus 7 multiplied by -2?"), Is.EqualTo(-8));
+        Assert.Equal(-8, WordProblem.Solve("What is -3 plus 7 multiplied by -2?"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_divide_twice()
     {
-        Assert.That(WordProblem.Solve("What is -12 divided by 2 divided by -3?"), Is.EqualTo(2));
+        Assert.Equal(2, WordProblem.Solve("What is -12 divided by 2 divided by -3?"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cubed_is_too_advanced()
     {
-        Assert.That(() => WordProblem.Solve("What is 53 cubed?"), Throws.ArgumentException);
+        Assert.Throws<ArgumentException>(() => WordProblem.Solve("What is 53 cubed?"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Irrelevant_problems_are_not_valid()
     {
-        Assert.That(() => WordProblem.Solve("Who is the president of the United States?"), Throws.ArgumentException);
+        Assert.Throws<ArgumentException>(() => WordProblem.Solve("Who is the president of the United States?"));
     }
 }

data/tracks/csharp/exercises/zebra-puzzle/ZebraPuzzle.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public enum Color { Red , Green , Ivory , Yellow , Blue }
+public enum Nationality { Englishman , Spaniard , Ukranian , Japanese , Norwegian }
+public enum Pet { Dog , Snails , Fox , Horse , Zebra }
+public enum Drink { Coffee , Tea , Milk , OrangeJuice , Water }
+public enum Smoke { OldGold , Kools , Chesterfields , LuckyStrike , Parliaments }
+
+public static class ZebraPuzzle
+{
+    public static Nationality WhoDrinks(Drink drink)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public static Nationality WhoOwns(Pet pet)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}