yacht: implement exercise

config.json

@@ -148,6 +148,21 @@
         "conditionals"
       ]
     },
+    {
+      "uuid": "22f937e5-52a7-4956-9dde-61c985251a6b",
+      "slug": "yacht",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+        "conditionals",
+        "equality",
+        "games",
+        "integers",
+        "pattern_matching",
+        "sequences"
+      ]
+    },
     {
       "uuid": "505e7bdb-e18d-45fd-9849-0bf33492efd9",
       "slug": "run-length-encoding",

exercises/yacht/README.md

@@ -0,0 +1,85 @@
+# Yacht
+
+# Score a single throw of dice in *Yacht*
+
+The dice game [Yacht](https://en.wikipedia.org/wiki/Yacht_(dice_game)) is from
+the same family as Poker Dice, Generala and particularly Yahtzee, of which it
+is a precursor. In the game, five dice are rolled and the result can be entered
+in any of twelve categories. The score of a throw of the dice depends on
+category chosen.
+
+## Scores in Yacht
+
+    Category    Score                   Example
+    Ones            1 × number of ones      1 1 1 4 5 scores 3
+    Twos            2 × number of twos      2 2 3 4 5 scores 4
+    Threes          3 × number of threes    3 3 3 3 3 scores 15
+    Fours           4 × number of fours     1 2 3 3 5 scores 0
+    Fives           5 × number of fives     5 1 5 2 5 scores 15
+    Sixes           6 × number of sixes     2 3 4 5 6 scores 6
+    Full House      Total of the dice       3 3 3 5 5 scores 19
+    Four of a Kind  Total of the four dice  4 4 4 4 6 scores 16
+    Little Straight 30 points               1 2 3 4 5 scores 30 
+    Big Straight    30 points               2 3 4 5 6 scores 30
+    Choice          Sum of the dice         2 3 3 4 6 scores 18
+    Yacht           50 points               4 4 4 4 4 scores 50
+
+If the dice do not satisfy the requirements of a category, the score is zero.
+If, for example, *Four Of A Kind* is entered in the *Yacht* category, zero
+points are scored. A *Yacht* scores zero if entered in the *Full House* category.
+
+## Task 
+Given a list of values for five dice and a category, your solution should return
+the score of the dice for that category. If the dice do not satisfy the requirements
+of the category your solution should return 0. You can assume that five values
+will always be presented, and the value of each will be between one and six
+inclusively. You should not assume that the dice are ordered.
+
+## Exception messages
+
+Sometimes it is necessary to raise an exception. When you do this, you should include a meaningful error message to
+indicate what the source of the error is. This makes your code more readable and helps significantly with debugging. Not
+every exercise will require you to raise an exception, but for those that do, the tests will only pass if you include
+a message.
+
+To raise a message with an exception, just write it as an argument to the exception type. For example, instead of
+`raise Exception`, you should write:
+
+```python
+raise Exception("Meaningful message indicating the source of the error")
+```
+
+## Running the tests
+
+To run the tests, run the appropriate command below ([why they are different](https://github.com/pytest-dev/pytest/issues/1629#issue-161422224)):
+
+- Python 2.7: `py.test yacht_test.py`
+- Python 3.3+: `pytest yacht_test.py`
+
+Alternatively, you can tell Python to run the pytest module (allowing the same command to be used regardless of Python version):
+`python -m pytest yacht_test.py`
+
+### Common `pytest` options
+
+- `-v` : enable verbose output
+- `-x` : stop running tests on first failure
+- `--ff` : run failures from previous test before running other test cases
+
+For other options, see `python -m pytest -h`
+
+## Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the solution is in the `$EXERCISM_WORKSPACE/python/yacht` directory.
+
+You can find your Exercism workspace by running `exercism debug` and looking for the line that starts with `Workspace`.
+
+For more detailed information about running tests, code style and linting,
+please see the [help page](http://exercism.io/languages/python).
+
+## Source
+
+James Kilfiger, using wikipedia [https://en.wikipedia.org/wiki/Yacht_(dice_game)](https://en.wikipedia.org/wiki/Yacht_(dice_game))
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

exercises/yacht/example.py

@@ -0,0 +1,65 @@
+from collections import Counter
+from functools import partial
+
+YACHT = 0
+ONES = 1
+TWOS = 2
+THREES = 3
+FOURS = 4
+FIVES = 5
+SIXES = 6
+FULL_HOUSE = 7
+FOUR_OF_A_KIND = 8
+LITTLE_STRAIGHT = 9
+BIG_STRAIGHT = 10
+CHOICE = 11
+
+
+def ns(number, dice):
+    return sum(n for n in dice if n == number)
+
+
+def full_house(dice):
+    counter = Counter(dice)
+    return sum(dice) if set(counter.values()) == {3, 2} else 0
+
+
+def four_of_a_kind(dice):
+    counter = Counter(dice)
+    number, count = counter.most_common()[0]
+    return 4 * number if count >= 4 else 0
+
+
+def little_straight(dice):
+    return 30 if set(dice) == {1, 2, 3, 4, 5} else 0
+
+
+def big_straight(dice):
+    return 30 if set(dice) == {2, 3, 4, 5, 6} else 0
+
+
+def yacht(dice):
+    return 50 if len(set(dice)) == 1 else 0
+
+
+functions = [
+    yacht,
+    partial(ns, 1),
+    partial(ns, 2),
+    partial(ns, 3),
+    partial(ns, 4),
+    partial(ns, 5),
+    partial(ns, 6),
+    full_house,
+    four_of_a_kind,
+    little_straight,
+    big_straight,
+    sum,
+]
+
+
+def score(dice, category):
+    try:
+        return functions[category](dice)
+    except IndexError:
+        raise ValueError("no such category")

exercises/yacht/yacht.py

@@ -0,0 +1,18 @@
+# Score categories
+# Change the values as you see fit
+YACHT = None
+ONES = None
+TWOS = None
+THREES = None
+FOURS = None
+FIVES = None
+SIXES = None
+FULL_HOUSE = None
+FOUR_OF_A_KIND = None
+LITTLE_STRAIGHT = None
+BIG_STRAIGHT = None
+CHOICE = None
+
+
+def score(dice, category):
+    pass

exercises/yacht/yacht_test.py

@@ -0,0 +1,90 @@
+import unittest
+
+import yacht
+from yacht import score
+
+
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+
+class YachtTests(unittest.TestCase):
+    def test_yacht(self):
+        self.assertEqual(score([5, 5, 5, 5, 5], yacht.YACHT), 50)
+
+    def test_not_yacht(self):
+        self.assertEqual(score([1, 3, 3, 2, 5], yacht.YACHT), 0)
+
+    def test_ones(self):
+        self.assertEqual(score([1, 1, 1, 3, 5], yacht.ONES), 3)
+
+    def test_ones_out_of_order(self):
+        self.assertEqual(score([3, 1, 1, 5, 1], yacht.ONES), 3)
+
+    def test_no_ones(self):
+        self.assertEqual(score([4, 3, 6, 5, 5], yacht.ONES), 0)
+
+    def test_twos(self):
+        self.assertEqual(score([2, 3, 4, 5, 6], yacht.TWOS), 2)
+
+    def test_fours(self):
+        self.assertEqual(score([1, 4, 1, 4, 1], yacht.FOURS), 8)
+
+    def test_yacht_counted_as_threes(self):
+        self.assertEqual(score([3, 3, 3, 3, 3], yacht.THREES), 15)
+
+    def test_yacht_of_threes_counted_as_fives(self):
+        self.assertEqual(score([3, 3, 3, 3, 3], yacht.FIVES), 0)
+
+    def test_sixes(self):
+        self.assertEqual(score([2, 3, 4, 5, 6], yacht.SIXES), 6)
+
+    def test_full_house_two_small_three_big(self):
+        self.assertEqual(score([2, 2, 4, 4, 4], yacht.FULL_HOUSE), 16)
+
+    def test_full_house_three_small_two_big(self):
+        self.assertEqual(score([5, 3, 3, 5, 3], yacht.FULL_HOUSE), 19)
+
+    def test_two_pair_is_not_a_full_house(self):
+        self.assertEqual(score([2, 2, 4, 4, 5], yacht.FULL_HOUSE), 0)
+
+    def test_yacht_is_not_a_full_house(self):
+        self.assertEqual(score([2, 2, 2, 2, 2], yacht.FULL_HOUSE), 0)
+
+    def test_four_of_a_kind(self):
+        self.assertEqual(score([6, 6, 4, 6, 6], yacht.FOUR_OF_A_KIND), 24)
+
+    def test_yacht_can_be_scored_as_four_of_a_kind(self):
+        self.assertEqual(score([3, 3, 3, 3, 3], yacht.FOUR_OF_A_KIND), 12)
+
+    def test_full_house_is_not_four_of_a_kind(self):
+        self.assertEqual(score([3, 5, 4, 1, 2], yacht.FOUR_OF_A_KIND), 0)
+
+    def test_little_straight(self):
+        self.assertEqual(score([3, 5, 4, 1, 2], yacht.LITTLE_STRAIGHT), 30)
+
+    def test_little_straight_as_big_straight(self):
+        self.assertEqual(score([1, 2, 3, 4, 5], yacht.BIG_STRAIGHT), 0)
+
+    def test_four_in_order_but_not_a_little_straight(self):
+        self.assertEqual(score([1, 1, 2, 3, 4], yacht.LITTLE_STRAIGHT), 0)
+
+    def test_no_pairs_but_not_a_little_straight(self):
+        self.assertEqual(score([1, 2, 3, 4, 6], yacht.LITTLE_STRAIGHT), 0)
+
+    def test_min_1_max_5_but_not_a_little_straight(self):
+        self.assertEqual(score([1, 1, 3, 4, 5], yacht.LITTLE_STRAIGHT), 0)
+
+    def test_big_straight(self):
+        self.assertEqual(score([4, 6, 2, 5, 3], yacht.BIG_STRAIGHT), 30)
+
+    def test_big_straight_as_little_straight(self):
+        self.assertEqual(score([6, 5, 4, 3, 2], yacht.LITTLE_STRAIGHT), 0)
+
+    def test_choice(self):
+        self.assertEqual(score([3, 3, 5, 6, 6], yacht.CHOICE), 23)
+
+    def test_yacht_as_choice(self):
+        self.assertEqual(score([2, 2, 2, 2, 2], yacht.CHOICE), 10)
+
+
+if __name__ == '__main__':
+    unittest.main()