dnd-character: implement exercise v1.0.0 (#1613)

* sum-of-multiples: update tests to v1.5.0

Fixes #1580
* Updated 3 test cases to conform to canonical data (reordered list to fit the ascending order convention)
* Updated example to check for ZeroDivisionError

* sum-of-multiples: pep8 formatting connotation

Small edits to conform to Pep8 standards

* sum-of-multiples: pep8 formatting connotation

Even smaller updates to conform to pep8

* sum-of_multiples: update import list

Change import to link to correct file

* sum-of-multiples: update tests to v1.5.0

* Updated test case names to reflect significance of each case.
* Updated example.py for brevity

* sum-of-multiples: update

* Delete blank line

* phone-number: update tests to v1.6.1

Fixes #1582
* Version increment.

* dnd-character: implement exercise v1.0.0

Closes #1593
* DND exercise implemented with corresponding tests and example
* Updated README.md

* dnd-character: implement exercise v1.0.0

Update #1613
* Del character{} from dnd_character.py
* Modified test cases to fit the exercise implementation in dnd_charact_test.py
* Modified example.py to exemplify spirit of exercise and deleted the character{}
* Implemented the README.md using the configlet tool

* dnd-character: implement exercise v1.0.0

Update config.json to reference this exercise.

* Update config.json

"unlocked_by" updated to reference "robot-name"

Co-Authored-By: GascaK <[email protected]>

* Update config.json

unlocked_by: null

Co-Authored-By: GascaK <[email protected]>

* dnd-character: update tests to v1.1.0

Closes #1593
* Update config.json
* Update _test.py to correctly reflect the canonical data.

* Update _test.py

Update to include max roll of 18.

Author: GascaK

config.json

@@ -1393,6 +1393,17 @@
         "strings"
       ]
     },
+    {
+        "slug": "dnd-character",
+        "uuid": "58625685-b5cf-4e8a-b3aa-bff54da0689d",
+        "core": false,
+        "unlocked_by": null,
+        "difficulty": 1,
+        "topics": [
+            "randomness",
+            "integers"
+        ]
+    },
     {
       "slug": "accumulate",
       "uuid": "e7351e8e-d3ff-4621-b818-cd55cf05bffd",

exercises/dnd-character/README.md

@@ -0,0 +1,82 @@
+# Dnd Character
+
+For a game of [Dungeons & Dragons][DND], each player starts by generating a
+character they can play with. This character has, among other things, six
+abilities; strength, dexterity, constitution, intelligence, wisdom and
+charisma. These six abilities have scores that are determined randomly. You
+do this by rolling four 6-sided dice and record the sum of the largest three
+dice. You do this six times, once for each ability.
+
+Your character's initial hitpoints are 10 + your character's constitution
+modifier. You find your character's constitution modifier by subtracting 10
+from your character's constitution, divide by 2 and round down.
+
+Write a random character generator that follows the rules above.
+
+For example, the six throws of four dice may look like:
+
+* 5, 3, 1, 6: You discard the 1 and sum 5 + 3 + 6 = 14, which you assign to strength.
+* 3, 2, 5, 3: You discard the 2 and sum 3 + 5 + 3 = 11, which you assign to dexterity.
+* 1, 1, 1, 1: You discard the 1 and sum 1 + 1 + 1 = 3, which you assign to constitution.
+* 2, 1, 6, 6: You discard the 1 and sum 2 + 6 + 6 = 14, which you assign to intelligence.
+* 3, 5, 3, 4: You discard the 3 and sum 5 + 3 + 4 = 12, which you assign to wisdom.
+* 6, 6, 6, 6: You discard the 6 and sum 6 + 6 + 6 = 18, which you assign to charisma.
+
+Because constitution is 3, the constitution modifier is -4 and the hitpoints are 6.
+
+## Notes
+
+Most programming languages feature (pseudo-)random generators, but few
+programming languages are designed to roll dice. One such language is [Troll].
+
+[DND]: https://en.wikipedia.org/wiki/Dungeons_%26_Dragons
+[Troll]: http://hjemmesider.diku.dk/~torbenm/Troll/
+
+## 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 dnd_character_test.py`
+- Python 3.4+: `pytest dnd_character_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 dnd_character_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/dnd-character` 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 [Running the Tests](http://exercism.io/tracks/python/tests).
+
+## Source
+
+Simon Shine, Erik Schierboom [https://github.com/exercism/problem-specifications/issues/616#issuecomment-437358945](https://github.com/exercism/problem-specifications/issues/616#issuecomment-437358945)
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

exercises/dnd-character/dnd_character.py

@@ -0,0 +1,3 @@
+class Character:
+    def __init__(self):
+        pass

exercises/dnd-character/dnd_character_test.py

@@ -0,0 +1,78 @@
+import unittest
+
+from dnd_character import Character, modifier
+
+
+# Tests adapted from 'problem-specifications//canonical-data.json' @ v1.1.0
+
+class DnDCharacterTest(unittest.TestCase):
+    def test_modifier_for_score_3_is_n4(self):
+        self.assertEqual(modifier(3), -4)
+
+    def test_modifier_for_score_4_is_n3(self):
+        self.assertEqual(modifier(4), -3)
+
+    def test_modifier_for_score_5_is_n3(self):
+        self.assertEqual(modifier(5), -3)
+
+    def test_modifier_for_score_6_is_n2(self):
+        self.assertEqual(modifier(6), -2)
+
+    def test_modifier_for_score_7_is_n2(self):
+        self.assertEqual(modifier(7), -2)
+
+    def test_modifier_for_score_8_is_n1(self):
+        self.assertEqual(modifier(8), -1)
+
+    def test_modifier_for_score_9_is_n1(self):
+        self.assertEqual(modifier(9), -1)
+
+    def test_modifier_for_score_10_is_0(self):
+        self.assertEqual(modifier(10), 0)
+
+    def test_modifier_for_score_11_is_0(self):
+        self.assertEqual(modifier(11), 0)
+
+    def test_modifier_for_score_12_is_1(self):
+        self.assertEqual(modifier(12), 1)
+
+    def test_modifier_for_score_13_is_1(self):
+        self.assertEqual(modifier(13), 1)
+
+    def test_modifier_for_score_14_is_2(self):
+        self.assertEqual(modifier(14), 2)
+
+    def test_modifier_for_score_15_is_2(self):
+        self.assertEqual(modifier(15), 2)
+
+    def test_modifier_for_score_16_is_3(self):
+        self.assertEqual(modifier(16), 3)
+
+    def test_modifier_for_score_17_is_3(self):
+        self.assertEqual(modifier(17), 3)
+
+    def test_modifier_for_score_18_is_4(self):
+        self.assertEqual(modifier(18), 4)
+
+    def test_random_ability_is_within_range(self):
+        self.assertIn(Character().ability(), range(3, 19))
+
+    def test_random_character_is_valid(self):
+        Char = Character()
+        self.assertIn(Char.strength, range(3, 19))
+        self.assertIn(Char.dexterity, range(3, 19))
+        self.assertIn(Char.constitution, range(3, 19))
+        self.assertIn(Char.intelligence, range(3, 19))
+        self.assertIn(Char.wisdom, range(3, 19))
+        self.assertIn(Char.charisma, range(3, 19))
+        self.assertEqual(
+            Char.hitpoints,
+            10 + modifier(Char.constitution))
+
+    def test_each_ability_is_only_calculated_once(self):
+        Char = Character()
+        self.assertEqual(Char.strength, Char.strength)
+
+
+if __name__ == '__main__':
+    unittest.main()

exercises/dnd-character/example.py

@@ -0,0 +1,23 @@
+import random
+import math
+
+
+class Character:
+    def __init__(self):
+        self.strength = self.ability()
+        self.dexterity = self.ability()
+        self.constitution = self.ability()
+        self.intelligence = self.ability()
+        self.wisdom = self.ability()
+        self.charisma = self.ability()
+        self.hitpoints = 10 + modifier(self.constitution)
+
+    def ability(self):
+        dice_rolls = sorted(
+            [random.randint(1, 6)
+                for _ in range(4)])
+        return sum(dice_rolls[1:])
+
+
+def modifier(value):
+    return math.floor((value-10)/2)