merge in most recent to prep for test editing.

.gitignore

@@ -8,4 +8,5 @@ bin/configlet
 bin/configlet.exe
 .idea/
 .cache
+.pytest_cache
 __pycache__

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017 Exercism, Inc
+Copyright (c) 2019 Exercism
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

bin/check-test-version.py

@@ -323,5 +323,9 @@ def check_test_version(
         if opts.ignore and exercise in opts.ignore:
             continue
         if os.path.isdir(os.path.join('exercises', exercise)):
-            result = check_test_version(exercise, **kwargs) and result
+            try:
+                result = check_test_version(exercise, **kwargs) and result
+            except FileNotFoundError as e:
+                print(str(e))
+                result = False
     sys.exit(0 if result else 1)

config.json

@@ -798,7 +798,7 @@
       ]
     },
     {
-      "slug": "bracket-push",
+      "slug": "matching-brackets",
       "uuid": "45229a7c-6703-4240-8287-16645881a043",
       "core": false,
       "unlocked_by": "isogram",
@@ -1446,6 +1446,38 @@
         "math"
       ]
     },
+    {
+      "slug": "resistor-color",
+      "uuid": "d17bee9c-e803-4745-85ea-864f255fb04e",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+        "arrays"
+      ]
+    },
+    {
+      "slug": "resistor-color-duo",
+      "uuid": "089f06a6-0759-479c-8c00-d699525a1e22",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+        "arrays"
+      ]
+    },
+    {
+      "slug": "knapsack",
+      "uuid": "b0301d0b-d97a-4043-bd82-ba1edf8c1b16",
+      "core": false,
+      "unlocked_by": "clock",
+      "difficulty": 5,
+      "topics": [
+        "algorithms",
+        "lists",
+        "loops"
+      ]
+    },
     {
       "slug": "accumulate",
       "uuid": "e7351e8e-d3ff-4621-b818-cd55cf05bffd",
@@ -1544,26 +1576,6 @@
       "difficulty": 0,
       "topics": null,
       "deprecated": true
-    },
-    {
-      "slug": "resistor-color",
-      "uuid": "d17bee9c-e803-4745-85ea-864f255fb04e",
-      "core": false,
-      "unlocked_by": null,
-      "difficulty": 1,
-      "topics": [
-        "arrays"
-      ]
-    },
-    {
-      "slug": "resistor-colors",
-      "uuid": "089f06a6-0759-479c-8c00-d699525a1e22",
-      "core": false,
-      "unlocked_by": null,
-      "difficulty": 1,
-      "topics": [
-        "arrays"
-      ]
     }
   ]
 }

config/maintainers.json

@@ -21,16 +21,6 @@
       "avatar_url": null,
       "bio": "I can not only fetch JSON, but parse it too."
     },
-    {
-      "github_username": "N-Parsons",
-      "alumnus": false,
-      "show_on_website": true,
-      "name": "Nathan Parsons",
-      "link_text": null,
-      "link_url": null,
-      "avatar_url": null,
-      "bio": "Python fits with how I think and allows me to quickly write powerful, maintainable, and extensible code."
-    },
     {
       "github_username": "m-a-ge",
       "alumnus": false,

exercises/allergies/allergies.py

@@ -3,7 +3,7 @@ class Allergies(object):
     def __init__(self, score):
         pass
 
-    def is_allergic_to(self, item):
+    def allergic_to(self, item):
         pass
 
     @property

exercises/allergies/allergies_test.py

@@ -7,62 +7,161 @@
     unittest.TestCase.assertCountEqual = unittest.TestCase.assertItemsEqual
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.2.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v2.0.0
 
 class AllergiesTest(unittest.TestCase):
-    def test_no_allergies_means_not_allergic(self):
-        allergies = Allergies(0)
-        self.assertIs(allergies.is_allergic_to('peanuts'), False)
-        self.assertIs(allergies.is_allergic_to('cats'), False)
-        self.assertIs(allergies.is_allergic_to('strawberries'), False)
-
-    def test_is_allergic_to_eggs(self):
-        self.assertIs(Allergies(1).is_allergic_to('eggs'), True)
-
-    def test_allergic_to_eggs_in_addition_to_other_stuff(self):
-        allergies = Allergies(5)
-        self.assertIs(allergies.is_allergic_to('eggs'), True)
-        self.assertIs(allergies.is_allergic_to('shellfish'), True)
-        self.assertIs(allergies.is_allergic_to('strawberries'), False)
-
-    def test_allergic_to_strawberries_but_not_peanuts(self):
-        allergies = Allergies(9)
-        self.assertIs(allergies.is_allergic_to('eggs'), True)
-        self.assertIs(allergies.is_allergic_to('peanuts'), False)
-        self.assertIs(allergies.is_allergic_to('shellfish'), False)
-        self.assertIs(allergies.is_allergic_to('strawberries'), True)
-
-    def test_no_allergies_at_all(self):
+
+    def test_eggs_not_allergic_to_anything(self):
+        self.assertIs(Allergies(0).allergic_to("eggs"), False)
+
+    def test_allergic_only_to_eggs(self):
+        self.assertIs(Allergies(1).allergic_to("eggs"), True)
+
+    def test_allergic_to_eggs_and_something_else(self):
+        self.assertIs(Allergies(3).allergic_to("eggs"), True)
+
+    def test_allergic_to_something_but_not_eggs(self):
+        self.assertIs(Allergies(2).allergic_to("eggs"), False)
+
+    def test_eggs_allergic_to_everything(self):
+        self.assertIs(Allergies(255).allergic_to("eggs"), True)
+
+    def test_peanuts_not_allergic_to_anything(self):
+        self.assertIs(Allergies(0).allergic_to("peanuts"), False)
+
+    def test_allergic_only_to_peanuts(self):
+        self.assertIs(Allergies(2).allergic_to("peanuts"), True)
+
+    def test_allergic_to_peanuts_and_something_else(self):
+        self.assertIs(Allergies(7).allergic_to("peanuts"), True)
+
+    def test_allergic_to_something_but_not_peanuts(self):
+        self.assertIs(Allergies(5).allergic_to("peanuts"), False)
+
+    def test_peanuts_allergic_to_everything(self):
+        self.assertIs(Allergies(255).allergic_to("peanuts"), True)
+
+    def test_shellfish_not_allergic_to_anything(self):
+        self.assertIs(Allergies(0).allergic_to("shellfish"), False)
+
+    def test_allergic_only_to_shellfish(self):
+        self.assertIs(Allergies(4).allergic_to("shellfish"), True)
+
+    def test_allergic_to_shellfish_and_something_else(self):
+        self.assertIs(Allergies(14).allergic_to("shellfish"), True)
+
+    def test_allergic_to_something_but_not_shellfish(self):
+        self.assertIs(Allergies(10).allergic_to("shellfish"), False)
+
+    def test_shellfish_allergic_to_everything(self):
+        self.assertIs(Allergies(255).allergic_to("shellfish"), True)
+
+    def test_strawberries_not_allergic_to_anything(self):
+        self.assertIs(Allergies(0).allergic_to("strawberries"), False)
+
+    def test_allergic_only_to_strawberries(self):
+        self.assertIs(Allergies(8).allergic_to("strawberries"), True)
+
+    def test_allergic_to_strawberries_and_something_else(self):
+        self.assertIs(Allergies(28).allergic_to("strawberries"), True)
+
+    def test_allergic_to_something_but_not_strawberries(self):
+        self.assertIs(Allergies(20).allergic_to("strawberries"), False)
+
+    def test_strawberries_allergic_to_everything(self):
+        self.assertIs(Allergies(255).allergic_to("strawberries"), True)
+
+    def test_tomatoes_not_allergic_to_anything(self):
+        self.assertIs(Allergies(0).allergic_to("tomatoes"), False)
+
+    def test_allergic_only_to_tomatoes(self):
+        self.assertIs(Allergies(16).allergic_to("tomatoes"), True)
+
+    def test_allergic_to_tomatoes_and_something_else(self):
+        self.assertIs(Allergies(56).allergic_to("tomatoes"), True)
+
+    def test_allergic_to_something_but_not_tomatoes(self):
+        self.assertIs(Allergies(40).allergic_to("tomatoes"), False)
+
+    def test_tomatoes_allergic_to_everything(self):
+        self.assertIs(Allergies(255).allergic_to("tomatoes"), True)
+
+    def test_chocolate_not_allergic_to_anything(self):
+        self.assertIs(Allergies(0).allergic_to("chocolate"), False)
+
+    def test_allergic_only_to_chocolate(self):
+        self.assertIs(Allergies(32).allergic_to("chocolate"), True)
+
+    def test_allergic_to_chocolate_and_something_else(self):
+        self.assertIs(Allergies(112).allergic_to("chocolate"), True)
+
+    def test_allergic_to_something_but_not_chocolate(self):
+        self.assertIs(Allergies(80).allergic_to("chocolate"), False)
+
+    def test_chocolate_alergic_to_everything(self):
+        self.assertIs(Allergies(255).allergic_to("chocolate"), True)
+
+    def test_pollen_not_alergic_to_anything(self):
+        self.assertIs(Allergies(0).allergic_to("pollen"), False)
+
+    def test_allergic_only_to_pollen(self):
+        self.assertIs(Allergies(64).allergic_to("pollen"), True)
+
+    def test_allergic_to_pollen_and_something_else(self):
+        self.assertIs(Allergies(224).allergic_to("pollen"), True)
+
+    def test_allergic_to_something_but_not_pollen(self):
+        self.assertIs(Allergies(160).allergic_to("pollen"), False)
+
+    def test_pollen_allergic_to_everything(self):
+        self.assertIs(Allergies(255).allergic_to("pollen"), True)
+
+    def test_cats_not_allergic_to_anything(self):
+        self.assertIs(Allergies(0).allergic_to("cats"), False)
+
+    def test_allergic_only_to_cats(self):
+        self.assertIs(Allergies(128).allergic_to("cats"), True)
+
+    def test_allergic_to_cats_and_something_else(self):
+        self.assertIs(Allergies(192).allergic_to("cats"), True)
+
+    def test_allergic_to_something_but_not_cats(self):
+        self.assertIs(Allergies(64).allergic_to("cats"), False)
+
+    def test_cats_allergic_to_everything(self):
+        self.assertIs(Allergies(255).allergic_to('cats'), True)
+
+    def test_no_allergies(self):
         self.assertEqual(Allergies(0).lst, [])
 
-    def test_allergic_to_just_eggs(self):
+    def test_just_eggs(self):
         self.assertEqual(Allergies(1).lst, ['eggs'])
 
-    def test_allergic_to_just_peanuts(self):
+    def test_just_peanuts(self):
         self.assertEqual(Allergies(2).lst, ['peanuts'])
 
-    def test_allergic_to_just_strawberries(self):
+    def test_just_strawberries(self):
         self.assertEqual(Allergies(8).lst, ['strawberries'])
 
-    def test_allergic_to_eggs_and_peanuts(self):
+    def test_eggs_and_peanuts(self):
         self.assertCountEqual(Allergies(3).lst, ['eggs', 'peanuts'])
 
-    def test_allergic_to_more_than_eggs_but_not_peanuts(self):
+    def test_more_than_eggs_but_not_peanuts(self):
         self.assertCountEqual(Allergies(5).lst, ['eggs', 'shellfish'])
 
-    def test_allergic_to_lots_of_stuff(self):
+    def test_lots_of_stuff(self):
         self.assertCountEqual(
             Allergies(248).lst,
             ['strawberries', 'tomatoes', 'chocolate', 'pollen', 'cats'])
 
-    def test_allergic_to_everything(self):
+    def test_everything(self):
         self.assertCountEqual(
             Allergies(255).lst, [
                 'eggs', 'peanuts', 'shellfish', 'strawberries', 'tomatoes',
                 'chocolate', 'pollen', 'cats'
             ])
 
-    def test_ignore_non_allergen_score_parts(self):
+    def test_no_allergen_score_parts(self):
         self.assertCountEqual(
             Allergies(509).lst, [
                 'eggs', 'shellfish', 'strawberries', 'tomatoes', 'chocolate',

exercises/allergies/example.py

@@ -14,10 +14,10 @@ class Allergies(object):
     def __init__(self, score):
         self.score = score
 
-    def is_allergic_to(self, allergy):
+    def allergic_to(self, allergy):
         return bool(self.score & 1 << self._allergies.index(allergy))
 
     @property
     def lst(self):
         return [allergy for allergy in self._allergies
-                if self.is_allergic_to(allergy)]
+                if self.allergic_to(allergy)]

exercises/alphametics/alphametics_test.py

@@ -10,10 +10,10 @@ def test_puzzle_with_three_letters(self):
         self.assertEqual(solve("I + BB == ILL"), {"I": 1, "B": 9, "L": 0})
 
     def test_solution_must_have_unique_value_for_each_letter(self):
-        self.assertEqual(solve("A == B"), {})
+        self.assertEqual(solve("A == B"), None)
 
     def test_leading_zero_solution_is_invalid(self):
-        self.assertEqual(solve("ACA + DD == BD"), {})
+        self.assertEqual(solve("ACA + DD == BD"), None)
 
     def test_puzzle_with_two_digits_final_carry(self):
         self.assertEqual(

exercises/alphametics/example.py

@@ -108,11 +108,11 @@ def check_rec(eqparams, tracecombo=(dict(), 0, set(range(10))), p=0):
             # if the recursive call returned a non-empty dictionary
             # this means the recursion has found a solution
             # otherwise, proceed to the new permutation
-            if len(rectest) > 0:
+            if rectest and len(rectest) > 0:
                 return rectest
     # if no permutations are avaialble or no
-    # permutation gave the result return the empty dictionary
-    return dict()
+    # permutation gave the result return None
+    return None
 
 
 def solve(an):

exercises/armstrong-numbers/armstrong_numbers.py

@@ -1,2 +1,2 @@
-def is_armstrong(number):
+def is_armstrong_number(number):
     pass