trackler 2.2.1.33 → 2.2.1.34

data/tracks/common-lisp/exercises/collatz-conjecture/collatz-conjecture.lisp

@@ -0,0 +1,7 @@
+(defpackage #:collatz-conjecture
+  (:use #:common-lisp)
+  (:export #:collatz))
+
+(in-package #:collatz-conjecture)
+
+(defun collatz (n))

data/tracks/common-lisp/exercises/collatz-conjecture/example.lisp

@@ -0,0 +1,14 @@
+(defpackage #:collatz-conjecture
+  (:use #:common-lisp)
+  (:export #:collatz))
+
+(in-package #:collatz-conjecture)
+
+(defun collatz-helper (a n)
+  (cond ((= n 1)   a)
+        ((evenp n) (collatz-helper (+ 1 a) (floor n 2)))
+        (T         (collatz-helper (+ 1 a) (+ 1 (* 3 n))))))
+
+(defun collatz (n)
+  (when (> n 0)
+    (collatz-helper 0 n)))

data/tracks/csharp/exercises/clock/Clock.cs

@@ -1,15 +1,26 @@
 using System;
 
-public class Clock
+public struct Clock
 {
-    public Clock(int hours)
+    public Clock(int hours, int minutes)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public Clock(int hours, int minutes)
+    public int Hours
     {
-        throw new NotImplementedException("You need to implement this function.");
+        get
+        {
+            throw new NotImplementedException("You need to implement this function.");
+        }
+    }
+
+    public int Minutes
+    {
+        get
+        {
+            throw new NotImplementedException("You need to implement this function.");
+        }
     }
 
     public Clock Add(int minutesToAdd)
@@ -21,4 +32,9 @@ public Clock Subtract(int minutesToSubtract)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
+
+    public override string ToString()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
 }

data/tracks/csharp/exercises/clock/ClockTest.cs

@@ -1,121 +1,356 @@
+// This file was auto-generated based on version 1.0.1 of the canonical data.
+
 using Xunit;
 
 public class ClockTest
 {
-    [Theory]
-    [InlineData(8, "08:00")]
-    [InlineData(9, "09:00")]
-    public void Prints_the_hour(int hours, string expected)
+    [Fact]
+    public void On_the_hour()
     {
-        Assert.Equal(expected, new Clock(hours).ToString());
+        var sut = new Clock(8, 0);
+        Assert.Equal("08:00", sut.ToString());
     }
 
-    [Theory(Skip = "Remove to run test")]
-    [InlineData(11, 9, "11:09")]
-    [InlineData(11, 19, "11:19")]
-    public void Prints_past_the_hour(int hours, int minutes, string expected)
+    [Fact(Skip = "Remove to run test")]
+    public void Past_the_hour()
     {
-        Assert.Equal(expected, new Clock(hours, minutes).ToString());
+        var sut = new Clock(11, 9);
+        Assert.Equal("11:09", sut.ToString());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_add_minutes()
+    public void Midnight_is_zero_hours()
     {
-        var clock = new Clock(10).Add(3);
-        Assert.Equal("10:03", clock.ToString());
+        var sut = new Clock(24, 0);
+        Assert.Equal("00:00", sut.ToString());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_add_over_an_hour()
+    public void Hour_rolls_over()
     {
-        var clock = new Clock(10).Add(63);
-        Assert.Equal("11:03", clock.ToString());
+        var sut = new Clock(25, 0);
+        Assert.Equal("01:00", sut.ToString());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_add_over_more_than_one_day()
+    public void Hour_rolls_over_continuously()
     {
-        var clock = new Clock(10).Add(7224);
-        Assert.Equal("10:24", clock.ToString());
+        var sut = new Clock(100, 0);
+        Assert.Equal("04:00", sut.ToString());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_subtract_minutes()
+    public void Sixty_minutes_is_next_hour()
     {
-        var clock = new Clock(10, 3).Subtract(3);
-        Assert.Equal("10:00", clock.ToString());
+        var sut = new Clock(1, 60);
+        Assert.Equal("02:00", sut.ToString());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_subtract_to_previous_hour()
+    public void Minutes_roll_over()
     {
-        var clock = new Clock(10, 3).Subtract(30);
-        Assert.Equal("09:33", clock.ToString());
+        var sut = new Clock(0, 160);
+        Assert.Equal("02:40", sut.ToString());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_subtract_over_an_hour()
+    public void Minutes_roll_over_continuously()
     {
-        var clock = new Clock(10, 3).Subtract(70);
-        Assert.Equal("08:53", clock.ToString());
+        var sut = new Clock(0, 1723);
+        Assert.Equal("04:43", sut.ToString());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Wraps_around_midnight()
+    public void Hour_and_minutes_roll_over()
     {
-        var clock = new Clock(23, 59).Add(2);
-        Assert.Equal("00:01", clock.ToString());
+        var sut = new Clock(25, 160);
+        Assert.Equal("03:40", sut.ToString());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Wraps_around_midnight_backwards()
+    public void Hour_and_minutes_roll_over_continuously()
     {
-        var clock = new Clock(0, 1).Subtract(2);
-        Assert.Equal("23:59", clock.ToString());
+        var sut = new Clock(201, 3001);
+        Assert.Equal("11:01", sut.ToString());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Midnight_is_zero_hundred_hours()
+    public void Hour_and_minutes_roll_over_to_exactly_midnight()
     {
-        var clock = new Clock(24);
-        Assert.Equal("00:00", clock.ToString());
+        var sut = new Clock(72, 8640);
+        Assert.Equal("00:00", sut.ToString());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Sixty_minutes_is_next_hour()
+    public void Negative_hour()
+    {
+        var sut = new Clock(-1, 15);
+        Assert.Equal("23:15", sut.ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Negative_hour_rolls_over()
+    {
+        var sut = new Clock(-25, 0);
+        Assert.Equal("23:00", sut.ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Negative_hour_rolls_over_continuously()
+    {
+        var sut = new Clock(-91, 0);
+        Assert.Equal("05:00", sut.ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Negative_minutes()
+    {
+        var sut = new Clock(1, -40);
+        Assert.Equal("00:20", sut.ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Negative_minutes_roll_over()
+    {
+        var sut = new Clock(1, -160);
+        Assert.Equal("22:20", sut.ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Negative_minutes_roll_over_continuously()
+    {
+        var sut = new Clock(1, -4820);
+        Assert.Equal("16:40", sut.ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Negative_hour_and_minutes_both_roll_over()
+    {
+        var sut = new Clock(-25, -160);
+        Assert.Equal("20:20", sut.ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Negative_hour_and_minutes_both_roll_over_continuously()
+    {
+        var sut = new Clock(-121, -5810);
+        Assert.Equal("22:10", sut.ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Add_minutes()
+    {
+        var sut = new Clock(10, 0);
+        Assert.Equal("10:03", sut.Add(3).ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Add_no_minutes()
+    {
+        var sut = new Clock(6, 41);
+        Assert.Equal("06:41", sut.Add(0).ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Add_to_next_hour()
+    {
+        var sut = new Clock(0, 45);
+        Assert.Equal("01:25", sut.Add(40).ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Add_more_than_one_hour()
+    {
+        var sut = new Clock(10, 0);
+        Assert.Equal("11:01", sut.Add(61).ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Add_more_than_two_hours_with_carry()
+    {
+        var sut = new Clock(0, 45);
+        Assert.Equal("03:25", sut.Add(160).ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Add_across_midnight()
+    {
+        var sut = new Clock(23, 59);
+        Assert.Equal("00:01", sut.Add(2).ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Add_more_than_one_day_1500_min_25_hrs_()
+    {
+        var sut = new Clock(5, 32);
+        Assert.Equal("06:32", sut.Add(1500).ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Add_more_than_two_days()
+    {
+        var sut = new Clock(1, 1);
+        Assert.Equal("11:21", sut.Add(3500).ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Subtract_minutes()
+    {
+        var sut = new Clock(10, 3);
+        Assert.Equal("10:00", sut.Add(-3).ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Subtract_to_previous_hour()
+    {
+        var sut = new Clock(10, 3);
+        Assert.Equal("09:33", sut.Add(-30).ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Subtract_more_than_an_hour()
+    {
+        var sut = new Clock(10, 3);
+        Assert.Equal("08:53", sut.Add(-70).ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Subtract_across_midnight()
+    {
+        var sut = new Clock(0, 3);
+        Assert.Equal("23:59", sut.Add(-4).ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Subtract_more_than_two_hours()
+    {
+        var sut = new Clock(0, 0);
+        Assert.Equal("21:20", sut.Add(-160).ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Subtract_more_than_two_hours_with_borrow()
+    {
+        var sut = new Clock(6, 15);
+        Assert.Equal("03:35", sut.Add(-160).ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Subtract_more_than_one_day_1500_min_25_hrs_()
+    {
+        var sut = new Clock(5, 32);
+        Assert.Equal("04:32", sut.Add(-1500).ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Subtract_more_than_two_days()
+    {
+        var sut = new Clock(2, 20);
+        Assert.Equal("00:20", sut.Add(-3000).ToString());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Clocks_with_same_time()
+    {
+        var sut = new Clock(15, 37);
+        Assert.True(sut.Equals(new Clock(15, 37)));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Clocks_a_minute_apart()
+    {
+        var sut = new Clock(15, 36);
+        Assert.False(sut.Equals(new Clock(15, 37)));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Clocks_an_hour_apart()
+    {
+        var sut = new Clock(14, 37);
+        Assert.False(sut.Equals(new Clock(15, 37)));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Clocks_with_hour_overflow()
+    {
+        var sut = new Clock(10, 37);
+        Assert.True(sut.Equals(new Clock(34, 37)));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Clocks_with_hour_overflow_by_several_days()
+    {
+        var sut = new Clock(3, 11);
+        Assert.True(sut.Equals(new Clock(99, 11)));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Clocks_with_negative_hour()
+    {
+        var sut = new Clock(22, 40);
+        Assert.True(sut.Equals(new Clock(-2, 40)));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Clocks_with_negative_hour_that_wraps()
+    {
+        var sut = new Clock(17, 3);
+        Assert.True(sut.Equals(new Clock(-31, 3)));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Clocks_with_negative_hour_that_wraps_multiple_times()
+    {
+        var sut = new Clock(13, 49);
+        Assert.True(sut.Equals(new Clock(-83, 49)));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Clocks_with_minute_overflow()
+    {
+        var sut = new Clock(0, 1);
+        Assert.True(sut.Equals(new Clock(0, 1441)));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Clocks_with_minute_overflow_by_several_days()
+    {
+        var sut = new Clock(2, 2);
+        Assert.True(sut.Equals(new Clock(2, 4322)));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Clocks_with_negative_minute()
     {
-        var clock = new Clock(1, 60);
-        Assert.Equal("02:00", clock.ToString());
+        var sut = new Clock(2, 40);
+        Assert.True(sut.Equals(new Clock(3, -20)));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Clocks_with_same_time_are_equal()
+    public void Clocks_with_negative_minute_that_wraps()
     {
-        var clock1 = new Clock(14, 30);
-        var clock2 = new Clock(14, 30);
-        Assert.Equal(clock2, clock1);
+        var sut = new Clock(4, 10);
+        Assert.True(sut.Equals(new Clock(5, -1490)));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Clocks_with_different_time_are_not_equal()
+    public void Clocks_with_negative_minute_that_wraps_multiple_times()
     {
-        var clock1 = new Clock(15, 30);
-        var clock2 = new Clock(14, 30);
-        Assert.NotEqual(clock2, clock1);
+        var sut = new Clock(6, 15);
+        Assert.True(sut.Equals(new Clock(6, -4305)));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Overflown_clocks_with_same_time_are_equal()
+    public void Clocks_with_negative_hours_and_minutes()
     {
-        var clock1 = new Clock(14, 30);
-        var clock2 = new Clock(38, 30);
-        Assert.Equal(clock2, clock1);
+        var sut = new Clock(7, 32);
+        Assert.True(sut.Equals(new Clock(-12, -268)));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_wrap_around_more_than_one_day()
+    public void Clocks_with_negative_hours_and_minutes_that_wrap()
     {
-        var clock = new Clock(10).Subtract(7224);
-        Assert.Equal("09:36", clock.ToString());
+        var sut = new Clock(18, 7);
+        Assert.True(sut.Equals(new Clock(-54, -11513)));
     }
 }