trackler 2.2.1.20 → 2.2.1.21

data/tracks/csharp/exercises/complex-numbers/ComplexNumbers.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/complex-numbers/ComplexNumbersTest.cs

@@ -0,0 +1,255 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
+using Xunit;
+using System;
+
+public class ComplexNumbersTest
+{
+    [Fact]
+    public void Real_part_of_a_purely_real_number()
+    {
+        var sut = new ComplexNumber(1, 0);
+        Assert.Equal(1, sut.Real());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Real_part_of_a_purely_imaginary_number()
+    {
+        var sut = new ComplexNumber(0, 1);
+        Assert.Equal(0, sut.Real());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Real_part_of_a_number_with_real_and_imaginary_part()
+    {
+        var sut = new ComplexNumber(1, 2);
+        Assert.Equal(1, sut.Real());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Imaginary_part_of_a_purely_real_number()
+    {
+        var sut = new ComplexNumber(1, 0);
+        Assert.Equal(0, sut.Imaginary());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Imaginary_part_of_a_purely_imaginary_number()
+    {
+        var sut = new ComplexNumber(0, 1);
+        Assert.Equal(1, sut.Imaginary());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Imaginary_part_of_a_number_with_real_and_imaginary_part()
+    {
+        var sut = new ComplexNumber(1, 2);
+        Assert.Equal(2, sut.Imaginary());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Imaginary_unit()
+    {
+        var sut = new ComplexNumber(0, 1);
+        var expected = new ComplexNumber(-1, 0);
+        Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(0, 1)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(0, 1)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Add_purely_real_numbers()
+    {
+        var sut = new ComplexNumber(1, 0);
+        var expected = new ComplexNumber(3, 0);
+        Assert.Equal(expected.Real(), sut.Add(new ComplexNumber(2, 0)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Add(new ComplexNumber(2, 0)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Add_purely_imaginary_numbers()
+    {
+        var sut = new ComplexNumber(0, 1);
+        var expected = new ComplexNumber(0, 3);
+        Assert.Equal(expected.Real(), sut.Add(new ComplexNumber(0, 2)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Add(new ComplexNumber(0, 2)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Add_numbers_with_real_and_imaginary_part()
+    {
+        var sut = new ComplexNumber(1, 2);
+        var expected = new ComplexNumber(4, 6);
+        Assert.Equal(expected.Real(), sut.Add(new ComplexNumber(3, 4)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Add(new ComplexNumber(3, 4)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Subtract_purely_real_numbers()
+    {
+        var sut = new ComplexNumber(1, 0);
+        var expected = new ComplexNumber(-1, 0);
+        Assert.Equal(expected.Real(), sut.Sub(new ComplexNumber(2, 0)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Sub(new ComplexNumber(2, 0)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Subtract_purely_imaginary_numbers()
+    {
+        var sut = new ComplexNumber(0, 1);
+        var expected = new ComplexNumber(0, -1);
+        Assert.Equal(expected.Real(), sut.Sub(new ComplexNumber(0, 2)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Sub(new ComplexNumber(0, 2)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Subtract_numbers_with_real_and_imaginary_part()
+    {
+        var sut = new ComplexNumber(1, 2);
+        var expected = new ComplexNumber(-2, -2);
+        Assert.Equal(expected.Real(), sut.Sub(new ComplexNumber(3, 4)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Sub(new ComplexNumber(3, 4)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Multiply_purely_real_numbers()
+    {
+        var sut = new ComplexNumber(1, 0);
+        var expected = new ComplexNumber(2, 0);
+        Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(2, 0)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(2, 0)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Multiply_purely_imaginary_numbers()
+    {
+        var sut = new ComplexNumber(0, 1);
+        var expected = new ComplexNumber(-2, 0);
+        Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(0, 2)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(0, 2)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Multiply_numbers_with_real_and_imaginary_part()
+    {
+        var sut = new ComplexNumber(1, 2);
+        var expected = new ComplexNumber(-5, 10);
+        Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(3, 4)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(3, 4)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Divide_purely_real_numbers()
+    {
+        var sut = new ComplexNumber(1, 0);
+        var expected = new ComplexNumber(0.5, 0);
+        Assert.Equal(expected.Real(), sut.Div(new ComplexNumber(2, 0)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Div(new ComplexNumber(2, 0)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Divide_purely_imaginary_numbers()
+    {
+        var sut = new ComplexNumber(0, 1);
+        var expected = new ComplexNumber(0.5, 0);
+        Assert.Equal(expected.Real(), sut.Div(new ComplexNumber(0, 2)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Div(new ComplexNumber(0, 2)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Divide_numbers_with_real_and_imaginary_part()
+    {
+        var sut = new ComplexNumber(1, 2);
+        var expected = new ComplexNumber(0.44, 0.08);
+        Assert.Equal(expected.Real(), sut.Div(new ComplexNumber(3, 4)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Div(new ComplexNumber(3, 4)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Absolute_value_of_a_positive_purely_real_number()
+    {
+        var sut = new ComplexNumber(5, 0);
+        Assert.Equal(5, sut.Abs());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Absolute_value_of_a_negative_purely_real_number()
+    {
+        var sut = new ComplexNumber(-5, 0);
+        Assert.Equal(5, sut.Abs());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Absolute_value_of_a_purely_imaginary_number_with_positive_imaginary_part()
+    {
+        var sut = new ComplexNumber(0, 5);
+        Assert.Equal(5, sut.Abs());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Absolute_value_of_a_purely_imaginary_number_with_negative_imaginary_part()
+    {
+        var sut = new ComplexNumber(0, -5);
+        Assert.Equal(5, sut.Abs());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Absolute_value_of_a_number_with_real_and_imaginary_part()
+    {
+        var sut = new ComplexNumber(3, 4);
+        Assert.Equal(5, sut.Abs());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Conjugate_a_purely_real_number()
+    {
+        var sut = new ComplexNumber(5, 0);
+        var expected = new ComplexNumber(5, 0);
+        Assert.Equal(expected.Real(), sut.Conjugate().Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Conjugate().Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Conjugate_a_purely_imaginary_number()
+    {
+        var sut = new ComplexNumber(0, 5);
+        var expected = new ComplexNumber(0, -5);
+        Assert.Equal(expected.Real(), sut.Conjugate().Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Conjugate().Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Conjugate_a_number_with_real_and_imaginary_part()
+    {
+        var sut = new ComplexNumber(1, 1);
+        var expected = new ComplexNumber(1, -1);
+        Assert.Equal(expected.Real(), sut.Conjugate().Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Conjugate().Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Eulers_identity_formula()
+    {
+        var sut = new ComplexNumber(0, Math.PI);
+        var expected = new ComplexNumber(-1, 0);
+        Assert.Equal(expected.Real(), sut.Exp().Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Exponential_of_0()
+    {
+        var sut = new ComplexNumber(0, 0);
+        var expected = new ComplexNumber(1, 0);
+        Assert.Equal(expected.Real(), sut.Exp().Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Exponential_of_a_purely_real_number()
+    {
+        var sut = new ComplexNumber(1, 0);
+        var expected = new ComplexNumber(Math.E, 0);
+        Assert.Equal(expected.Real(), sut.Exp().Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), 15);
+    }
+}

data/tracks/csharp/exercises/complex-numbers/Example.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Diagnostics;
+
+[DebuggerDisplay("{_real} + {_imaginary}i")]
+public struct ComplexNumber
+{
+    private readonly double _real;
+    private readonly double _imaginary;
+
+    public ComplexNumber(double real, double imaginary)
+    {
+        _real = real;
+        _imaginary = imaginary;
+    }
+    
+    public double Real()
+    {
+        return _real;
+    }
+
+    public double Imaginary()
+    {
+        return _imaginary;
+    }
+
+    public ComplexNumber Mul(ComplexNumber other)
+    {
+        return new ComplexNumber(
+            _real * other._real - _imaginary * other._imaginary,
+            _imaginary * other._real + _real * other._imaginary);
+    }
+
+    public ComplexNumber Add(ComplexNumber other)
+    {
+        return new ComplexNumber(
+            _real + other._real,
+            _imaginary + other._imaginary);
+    }
+
+    public ComplexNumber Sub(ComplexNumber other)
+    {
+        return new ComplexNumber(
+            _real - other._real,
+            _imaginary - other._imaginary);
+    }
+
+    public ComplexNumber Div(ComplexNumber other)
+    {
+        var denominator = other._real * other._real + other._imaginary * other._imaginary;
+        var real = (_real * other._real + _imaginary * other._imaginary) / denominator;
+        var imaginary = (_imaginary * other._real - _real * _real * other._imaginary) / denominator;
+
+        return new ComplexNumber(real, imaginary);
+    }
+
+    public double Abs()
+    {
+        return Math.Sqrt(_real * _real + _imaginary * _imaginary);
+    }
+
+    public ComplexNumber Conjugate()
+    {
+        return new ComplexNumber(
+            _real,
+            -1 * _imaginary);
+    }
+
+    public ComplexNumber Exp()
+    {
+        var real = Math.Cos(_imaginary);
+        var imaginary = Math.Sin(_imaginary);
+        var factor = Math.Exp(_real);
+
+        return new ComplexNumber(
+            real * factor,
+            imaginary * factor);
+    }
+}

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

@@ -1,7 +1,14 @@
-public static class Grains
+using System;
+
+public static class Grains
 {
     public static ulong Square(int n)
     {
+        if (n <= 0 || n > 64)
+        {
+            throw new ArgumentOutOfRangeException(nameof(n));
+        }
+
         return n == 1
             ? 1
             : 2 * Square(n - 1);

data/tracks/csharp/exercises/grains/GrainsTest.cs

@@ -1,52 +1,73 @@
-using Xunit;
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
+using Xunit;
+using System;
 
 public class GrainsTest
 {
     [Fact]
-    public void Test_square_1()
+    public void Returns_the_total_number_of_grains_on_the_board()
+    {
+        Assert.Equal(18446744073709551615UL, Grains.Total());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_1()
+    {
+        Assert.Equal(1UL, Grains.Square(1));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_2()
+    {
+        Assert.Equal(2UL, Grains.Square(2));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_3()
     {
-        Assert.Equal(1ul, Grains.Square(1));
+        Assert.Equal(4UL, Grains.Square(3));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_square_2()
+    public void Number_4()
     {
-        Assert.Equal(2ul, Grains.Square(2));
+        Assert.Equal(8UL, Grains.Square(4));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_square_3()
+    public void Number_16()
     {
-        Assert.Equal(4ul, Grains.Square(3));
+        Assert.Equal(32768UL, Grains.Square(16));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_square_4()
+    public void Number_32()
     {
-        Assert.Equal(8ul, Grains.Square(4));
+        Assert.Equal(2147483648UL, Grains.Square(32));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_square_16()
+    public void Number_64()
     {
-        Assert.Equal(32768ul, Grains.Square(16));
+        Assert.Equal(9223372036854775808UL, Grains.Square(64));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_square_32()
+    public void Square_0_raises_an_exception()
     {
-        Assert.Equal(2147483648ul, Grains.Square(32));
+        Assert.Throws<ArgumentOutOfRangeException>(() => Grains.Square(0));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_square_64()
+    public void Negative_square_raises_an_exception()
     {
-        Assert.Equal(9223372036854775808ul, Grains.Square(64));
+        Assert.Throws<ArgumentOutOfRangeException>(() => Grains.Square(-1));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_total_grains()
+    public void Square_greater_than_64_raises_an_exception()
     {
-        Assert.Equal(18446744073709551615ul, Grains.Total());
+        Assert.Throws<ArgumentOutOfRangeException>(() => Grains.Square(65));
     }
 }