trackler 2.0.3.8 → 2.0.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 26859b54fc9507930d1491868635aa16867347f6
-  data.tar.gz: 9b58994afd40bf481622cad4dcc0bb4528078ff8
+  metadata.gz: 7a91f7979567f492ab8b002b66d7fcf8cd716625
+  data.tar.gz: 840ec796d75143f63a21446537e2c4e22f496cbd
 SHA512:
-  metadata.gz: 7f55463ac98a1e18ded0523c929796b44a226ead128bb7015de7161469b87e9dca58b4b2353ec203ce2e8e9f7d8c2deaa811991bcefa6beb32acf880312a684a
-  data.tar.gz: fd3ea88f64020af3af7fa037ef1de5afb2ad895873ef15d9e21efb0c94728c79faaeb30fada44974a6da4ee367789c6cfcee0f8d5d84d5d5177b2433540f41b8
+  metadata.gz: cda059d0a0316df945dc469f2900a469475254447508e10b91fdf51b07633a83e5c9f931fc4b2441be111168e03ef48bd5af8c79c3f7ce91e3f0504c121021ed
+  data.tar.gz: 952113e3d6b6b64e8a345fcb867dbe37a215f93e452b76f8d02ec93494d8cb622bbab4e7dbbacc7a532b2cf279f9611b10b2e21c8ddbdc58a1a65bae40bbd77a

data/common/exercises/book-store/description.md

@@ -0,0 +1,67 @@
+To try and encourage more sales of the 5 different books
+they sell of a popular series, a bookshop has decided to
+offer discounts of multi-book purchases. 
+
+One copy of any of the five books costs $8. 
+
+If, however, you buy two different books, you get a 5%
+discount on those two books.
+
+If you buy 3 different books, you get a 10% discount. 
+
+If you buy 4 different books, you get a 20% discount.
+
+If you buy all 5, you get a 25% discount. 
+
+Note: that if you buy four books, of which 3 are
+different titles, you get a 10% discount on the 3 that
+form part of a set, but the fourth book still costs $8. 
+
+Your mission is to write a piece of code to calculate the
+price of any conceivable shopping basket (containing only
+books of the same series), giving as big a discount as
+possible.
+
+For example, how much does this basket of books cost?
+
+- 2 copies of the first book
+- 2 copies of the second book
+- 2 copies of the third book
+- 1 copy of the fourth book
+- 1 copy of the fifth book
+ 
+One way of grouping these 8 books is:
+
+- 1 group of 5 --> 25% discount (1st,2nd,3rd,4th,5th)
+- +1 group of 3 --> 10% discount (1st,2nd,3rd)
+
+This would give a total of:
+
+- 5 books at a 25% discount
+- +3 books at a 10% discount
+
+Resulting in:
+
+- 5 x (8 - 2.00) == 5 x 6.00 == $30.00
+- +3 x (8 - 0.80) == 3 x 7.20 == $21.60
+
+For a total of $51.60
+
+However, a different way to group these 8 books is:
+
+- 1 group of 4 books --> 20% discount  (1st,2nd,3rd,4th)
+- +1 group of 4 books --> 20% discount  (1st,2nd,3rd,5th)
+
+This would give a total of:
+
+- 4 books at a 20% discount
+- +4 books at a 20% discount
+
+Resulting in:
+
+- 4 x (8 - 1.60) == 4 x 6.40 == $25.60
+- +4 x (8 - 1.60) == 4 x 6.40 == $25.60
+
+For a total of $51.20
+
+And $51.20 is the price with the biggest discount.

data/common/exercises/book-store/metadata.yml

@@ -0,0 +1,4 @@
+---
+blurb: "To try and encourage more sales of different books from a popular 5 book series, a bookshop has decided to offer discounts of multiple-book purchases."
+source: "Inspired by the harry potter kata from Cyber-Dojo."
+source_url: "http://cyber-dojo.org"

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.3.8"
+  VERSION = "2.0.3.9"
 end

data/tracks/crystal/exercises/difference-of-squares/src/difference_of_squares.cr

@@ -0,0 +1 @@
+# Please implement your solution to difference-of-squares in this file

data/tracks/ecmascript/exercises/custom-set/package.json

@@ -1,3 +1,4 @@
+{
   "name": "xecmascript",
   "version": "0.0.0",
   "description": "Exercism exercises in ECMAScript 6.",

data/tracks/ecmascript/exercises/palindrome-products/palindrome-products.js

@@ -1,18 +1,18 @@
--/**
- - * Generate palindrome-products table and calculate largest/smallest.
- - *
- - * @param {Number} [minFactor]
- - * Minimum Factor
- - *
- - * @param {Number} [maxFactor]
- - * Maximum Factor
- - *
- - * @return {{largest: number, smallest: number}}
- - */
- -function generate({ minFactor = 1, maxFactor = Number.MAX_VALUE }) {
- -//
- -// YOUR CODE GOES HERE
- -//
- -}
- -
- -export default generate;
+/**
+ * Generate palindrome-products table and calculate largest/smallest.
+ *
+ * @param {Number} [minFactor]
+ * Minimum Factor
+ *
+ * @param {Number} [maxFactor]
+ * Maximum Factor
+ *
+ * @return {{largest: number, smallest: number}}
+ */
+function generate({ minFactor = 1, maxFactor = Number.MAX_VALUE }) {
+  //
+  // YOUR CODE GOES HERE
+  //
+}
+
+export default generate;

data/tracks/fsharp/docs/INSTALLATION.md

@@ -5,10 +5,9 @@ Install [Xamarin Studio](http://xamarin.com/download).
 While Xamarin is most known for creating iOS and Android applications, it's still a perfect IDE to create F# console
 or library projects which is all that's needed for Exercism.
 
-Once installed and running, click on new solution and you'll find the library project to select. Don't forget to click the
-lanugage drop down to select F# since it defaults to C#.
+Once installed and running, you can validate the installation by starting Xamarin creating a new solution. On the left hand side select .NET, and on the right hand side select Library. Library should have a little button-shapped drop down box to it's right that says C#. Click it and you'll see you can also choose F#.
 
-![Xamarin New Project](http://x.exercism.io/v3/tracks/fsharp/docs/img/xamarin-fsharp.jpg)
+<img alt="Xamarin New Projct" src="http://x.exercism.io/v3/tracks/fsharp/docs/img/xamarin-fsharp.jpg" style="width:100%; height: 100%;">
 
 #### Linux
 The [F# Foundation](http://fsharp.org/) has detailed instructions on different options to install F# on [Linux](http://fsharp.org/use/linux/).

data/tracks/fsharp/docs/TESTS.md

@@ -28,7 +28,7 @@ Now you can have fun learning F# and run your code against the tests!
 ### Mac
 Xamarin Studio also ships with NUnit. From the new project dialog, just select an NUnit class library.
 
-![Xamarin NUnit](http://x.exercism.io/v3/tracks/fsharp/docs/img/xamarin-fsharp-nunit.jpg)
+<img alt="Xamarin NUnit" src=" http://x.exercism.io/v3/tracks/fsharp/docs/img/xamarin-fsharp-nunit.jpg" style="height: 100%; width: 100%;" />
 
 From here you can write NUnit tests right away. To run the tests open the `Unit Tests` pad within
 Xamarin (View -> Pads -> Unit Tests).

data/tracks/fsharp/exercises/accumulate/HINTS.md

@@ -0,0 +1,3 @@
+## Hints
+For this exercise the following F# feature comes in handy:
+- [Tail recursion](https://blogs.msdn.microsoft.com/fsharpteam/2011/07/08/tail-calls-in-f/) Prevent stack overflows with large input by using tail recursion. While there are no test cases checking explicitly for this, using tail recursion leads to a more performant solution. Another good resource on tail recursion is [this blog post](http://blog.ploeh.dk/2015/12/22/tail-recurse/).

data/tracks/fsharp/exercises/diamond/HINTS.md

@@ -0,0 +1,2 @@
+## Hints
+- Testing this one can be tricky without simply hardcoding a bunch of inputs and outputs. [Property based testing](https://fsharpforfunandprofit.com/posts/property-based-testing/) is another way to think about testing that allows you to more easily test this type of algorithm.

data/tracks/fsharp/exercises/grains/HINTS.md

@@ -1,4 +1,4 @@
 ## Hints
-For this exercise the following F# feature comes in handy:
+For this exercise the following F# features come in handy:
 - [BigInt](https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/numerics.biginteger-structure-%5Bfsharp%5D)
 - [Seq.sumBy](https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/seq.sumby%5B't,%5Eu%5D-function-%5Bfsharp%5D) is a condensed format to apply a function to a sequence and then sum the results

data/tracks/fsharp/exercises/hello-world/HINTS.md

@@ -1,5 +1,5 @@
 ## Hints
-For this exercise the following F# feature comes in handy:
+For this exercise the following F# features come in handy:
 - [Match Expressions](https://fsharpforfunandprofit.com/posts/match-expression/) Also known as pattern matching which is like a switch statement on steriods. It's a very powerful ability in the F# language and will come in handy in many of the exercises. While this example can be trivially solved with an if/else, pattern matching is more idiomatic.
 - [sprintf](https://fsharpforfunandprofit.com/posts/printf/) While F# supports string concatenation using sprintf leads to easier to read solutions and is also idiomatic
 - [defaultArg](https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/operators.defaultarg%5B't%5D-function-%5Bfsharp%5D) Default arg is useful when extracting a value from an option type and providing a value when None is encountered.

data/tracks/fsharp/exercises/parallel-letter-frequency/HINTS.md

@@ -0,0 +1,3 @@
+## Hints
+For this exercise the following F# feature comes in handy:
+- [Asynchronous programming](https://fsharpforfunandprofit.com/posts/concurrency-async-and-parallel/) .NET has asynchronous functionality built-in which enables you to run things in parallel (assuming you have a multi-core processor which is becoming more an more common) easily

data/tracks/fsharp/exercises/poker/HINTS.md

@@ -0,0 +1,2 @@
+## Hints
+- [Designing with types](http://fsharpforfunandprofit.com/series/designing-with-types.html) To come up with a clean and easy to read solution for this make sure to choose the right types to represent the different parts of the problem (think of suits, values, cards, etc)

data/tracks/fsharp/exercises/raindrops/HINTS.md

@@ -0,0 +1,2 @@
+## Hints
+- Think of this in a generic way. If you're familiar with the (fizz buzz)[https://en.wikipedia.org/wiki/Fizz_buzz] problem this is similar except there are three conditions instead of two. How would you implement this knowing that one day we might want to extend to four, five, or even ten types of raindrops?

data/tracks/fsharp/exercises/space-age/HINTS.md

@@ -0,0 +1,3 @@
+## Hints
+- Try to focus on minimizing the amount of code duplication. If you find yourself doing a lot of copy/paste take a step back and think about how the code can be refactored
+- [Pattern matching](https://fsharpforfunandprofit.com/posts/match-expression/) is more idiomatic than using dictionaries to translate values

data/tracks/javascript/exercises/bowling/bowling.spec.js

@@ -2,39 +2,44 @@ var Bowling = require('./bowling');
 
 describe('Bowling', function() {
   describe('Check game can be scored correctly.', function() {
-    it('should be able to score open frame', function() {
-      var rolls = [3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-      expect(new Bowling(rolls).score()).toEqual(7);
+    it('should be able to score a game with all gutterballs', function() {
+      var rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+      expect(new Bowling(rolls).score()).toEqual(0);
     });
 
-    xit('should be able to score multiple frames', function() {
-      var rolls = [3, 4, 2, 3, 5, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-      expect(new Bowling(rolls).score()).toEqual(19);
+    xit('should be able to score a game with all open frames', function() {
+      var rolls = [3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6];
+      expect(new Bowling(rolls).score()).toEqual(90);
     });
 
-    xit('should be able to score a game with all gutterballs', function() {
-      var rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-      expect(new Bowling(rolls).score()).toEqual(0);
+    xit('a spare followed by zeros is worth ten points', function() {
+      var rolls = [6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+      expect(new Bowling(rolls).score()).toEqual(10);
     });
 
-    xit('should be able to score a game with all single pin rolls', function() {
-      var rolls = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
-      expect(new Bowling(rolls).score()).toEqual(20);
+    xit('points scored in the roll after a spare are counted twice', function() {
+      var rolls = [6, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+      expect(new Bowling(rolls).score()).toEqual(16);
     });
 
-    xit('should be able to score a game with all open frames', function() {
-      var rolls = [3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6];
-      expect(new Bowling(rolls).score()).toEqual(90);
+    xit('consecutive spares each get a one roll bonus', function() {
+      var rolls = [5, 5, 3, 7, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+      expect(new Bowling(rolls).score()).toEqual(31);
     });
 
-    xit('should be able to score a strike not in the last frame', function() {
-      var rolls = [10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-      expect(new Bowling(rolls).score()).toEqual(26);
+    xit('should allow fill ball when the last frame is a spare', function() {
+      var rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 7];
+      expect(new Bowling(rolls).score()).toEqual(17);
     });
 
-    xit('should be able to score a spare not in the last frame', function() {
-      var rolls = [5, 5, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-      expect(new Bowling(rolls).score()).toEqual(20);
+    xit('a strike earns ten points in a frame with a single roll', function() {
+      var rolls = [10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+      expect(new Bowling(rolls).score()).toEqual(10);
+    });
+
+    xit('points scored in the two rolls after a strike are counted twice as a bonus', function() {
+      var rolls = [10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+      expect(new Bowling(rolls).score()).toEqual(26);
     });
 
     xit('should be able to score multiple strikes in a row', function() {
@@ -42,26 +47,26 @@ describe('Bowling', function() {
       expect(new Bowling(rolls).score()).toEqual(81);
     });
 
-    xit('should be able to score multiple spares in a row', function() {
-      var rolls = [5, 5, 3, 7, 4, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-      expect(new Bowling(rolls).score()).toEqual(32);
-    });
-
     xit('should allow fill balls when the last frame is a strike', function() {
       var rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 1];
       expect(new Bowling(rolls).score()).toEqual(18);
     });
 
-    xit('should allow fill ball when the last frame is a spare', function() {
-      var rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 1, 7];
-      expect(new Bowling(rolls).score()).toEqual(17);
+    xit('rolling a spare with the two roll bonus does not get a bonus roll', function() {
+      var rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 3];
+      expect(new Bowling(rolls).score()).toEqual(20);
     });
 
-    xit('should allow fill balls to be a strike', function() {
+    xit('strikes with the two roll bonus do not get bonus rolls', function() {
       var rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 10];
       expect(new Bowling(rolls).score()).toEqual(30);
     });
 
+    xit('a strike with the one roll bonus after a spare in the last frame does not get a bonus', function() {
+      var rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 10];
+      expect(new Bowling(rolls).score()).toEqual(20);
+    });
+
     xit('should be able to score a perfect game', function() {
       var rolls = [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10];
       expect(new Bowling(rolls).score()).toEqual(300);
@@ -69,60 +74,75 @@ describe('Bowling', function() {
   });
 
   describe('Check game rules.', function() {
-    xit('should not allow rolls with negative pins', function() {
-      var rolls = [-1];
+    xit('rolls can not score negative points', function() {
+      var rolls = [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
       expect(function() { new Bowling(rolls).score(); }).toThrow(
-        new Error('Pins must have a value from 0 to 10')
-      );
-    });
+        new Error('Pins must have a value from 0 to 10'));    
+	});
 
-    xit('should not allow rolls better than strike', function() {
-      var rolls = [11];
+    xit('a roll can not score more than 10 points', function() {
+      var rolls = [11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
       expect(function() { new Bowling(rolls).score(); }).toThrow(
-        new Error('Pins must have a value from 0 to 10')
-      );
-    });
+        new Error('Pins must have a value from 0 to 10'));
+	});
 
-    xit('should not allow two normal rolls better than strike', function() {
-      var rolls = [5, 6];
+    xit('two rolls in a frame can not score more than 10 points', function() {
+      var rolls = [5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
       expect(function() { new Bowling(rolls).score(); }).toThrow(
-        new Error('Pin count exceeds pins on the lane')
-      );
+        new Error('Pin count exceeds pins on the lane'));
+	});
+
+    xit('two bonus rolls after a strike in the last frame can not score more than 10 points', function() {
+      var rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 5, 6];
+      expect(function() { new Bowling(rolls).score(); }).toThrow(
+        new Error('Pin count exceeds pins on the lane'));    
+	});
+
+    xit('two bonus rolls after a strike in the last frame can score more than 10 points if one is a strike', function() {
+      var rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 6];
+      expect(new Bowling(rolls).score()).toEqual(26);
     });
 
-    xit('should not allow two normal rolls better than strike in last frame', function() {
-      var rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 6];
+    xit('the second bonus rolls after a strike in the last frame can not be a strike if the first one is not a strike', function() {
+      var rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 6, 10];
       expect(function() { new Bowling(rolls).score(); }).toThrow(
-        new Error('Pin count exceeds pins on the lane')
-      );
+        new Error('Pin count exceeds pins on the lane'));    
     });
 
-    xit('should not allow to take score at the beginning of the game', function() {
+    xit('an unstarted game can not be scored', function() {
       var rolls = [];
       expect(function() { new Bowling(rolls).score(); }).toThrow(
-        new Error('Score cannot be taken until the end of the game')
-      );
+        new Error('Score cannot be taken until the end of the game'));
     });
 
-    xit('should not allow to take score before the game has ended', function() {
-      var rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    xit('an incomplete game can not be scored', function() {
+      var rolls = [0, 0];
       expect(function() { new Bowling(rolls).score(); }).toThrow(
-        new Error('Score cannot be taken until the end of the game')
-      );
+        new Error('Score cannot be taken until the end of the game'));
     });
 
-    xit('should not allow rolls after the tenth frame', function() {
+    xit('a game with more than ten frames and no last frame spare or strike can not be scored', function() {
       var rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
       expect(function() { new Bowling(rolls).score(); }).toThrow(
-        new Error('Should not be able to roll after game is over')
-      );
+        new Error('Should not be able to roll after game is over'));
+    });
+
+    xit('bonus rolls for a strike in the last frame must be rolled before score can be calculated', function() {
+      var rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10];
+      expect(function() { new Bowling(rolls).score(); }).toThrow(
+        new Error('Score cannot be taken until the end of the game'));
+    });
+
+    xit('both bonus rolls for a strike in the last frame must be rolled before score can be calculated', function() {
+      var rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10];
+      expect(function() { new Bowling(rolls).score(); }).toThrow(
+        new Error('Score cannot be taken until the end of the game'));
     });
 
-    xit('should not calculate score before fill balls have been played', function() {
-      var rolls = [10, 10, 10, 10, 10, 10, 10, 10, 10, 10];
+    xit('bonus roll for a spare in the last frame must be rolled before score can be calculated', function() {
+      var rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3];
       expect(function() { new Bowling(rolls).score(); }).toThrow(
-        new Error('Score cannot be taken until the end of the game')
-      );
+        new Error('Score cannot be taken until the end of the game'));
     });
   });
-});
+});

data/tracks/ocaml/config.json

@@ -121,6 +121,11 @@
       "difficulty": 5,
       "topics": []
     },
+    {
+      "slug": "robot-name",
+      "difficulty": 6,
+      "topics": ["Randomness", "Mutable state"]
+    },
     {
       "slug": "list-ops",
       "difficulty": 6,

data/tracks/ocaml/exercises/leap/test.ml

@@ -5,19 +5,13 @@ open Leap
 let ae exp got _test_ctxt = assert_equal exp got
 
 let tests = [
-  "leap year in twentieth century" >::
-    ae true (leap_year 1996);
-  "odd standard year in twentieth century" >::
-    ae false (leap_year 1997);
-  "even standard year in twentieth century" >::
-    ae false (leap_year 1998);
-  "standard year in nineteenth century" >::
-    ae false (leap_year 1900);
-  "standard year in eighteenth century" >::
-    ae false (leap_year 1800);
-  "leap year twenty four hundred" >::
-    ae true (leap_year 2400);
-  "leap year two thousand" >::
+  "year not divisible by 4: common year" >::
+    ae false (leap_year 2015);
+  "year divisible by 4, not divisible by 100: leap year" >::
+    ae true (leap_year 2016);
+  "year divisible by 100, not divisible by 400: common year" >::
+    ae false (leap_year 2100);
+  "year divisible by 400: leap year" >::
     ae true (leap_year 2000);
 ]