trackler 2.2.1.48 → 2.2.1.49

data/tracks/purescript/config.json

@@ -261,6 +261,18 @@
         "arithmetics",
         "maybe"
       ]
+    },
+    {
+      "uuid": "ee76a602-0eae-2680-b0d6-b804a419ed267ef04c2",
+      "slug": "sum-of-multiples",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+        "arithmetics",
+        "arrays",
+        "modulo"
+      ]
     }
   ],
   "foregone": [

data/tracks/purescript/exercises/sum-of-multiples/README.md

@@ -0,0 +1,15 @@
+# Sum Of Multiples
+
+Given a number, find the sum of all the multiples of particular numbers up to
+but not including that number.
+
+If we list all the natural numbers up to but not including 20 that are
+multiples of either 3 or 5, we get 3, 5, 6 and 9, 10, 12, 15, and 18.
+
+The sum of these multiples is 78.
+## Source
+
+A variation on Problem 1 at Project Euler [http://projecteuler.net/problem=1](http://projecteuler.net/problem=1)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/purescript/exercises/sum-of-multiples/bower.json

@@ -0,0 +1,26 @@
+{
+  "name": "sum-of-multiples",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "output"
+  ],
+  "dependencies": {
+    "purescript-console": "^3.0.0",
+    "purescript-datetime": "^3.4.0",
+    "purescript-either": "^3.1.0",
+    "purescript-enums": "^3.2.1",
+    "purescript-integers": "^3.1.0",
+    "purescript-lists": "^4.10.0",
+    "purescript-maps": "^3.5.2",
+    "purescript-prelude": "^3.1.0",
+    "purescript-sets": "^3.0.0",
+    "purescript-strings": "^3.3.1",
+    "purescript-unicode": "^3.0.1"
+  },
+  "devDependencies": {
+    "purescript-psci-support": "^3.0.0",
+    "purescript-test-unit": "^13.0.0"
+  }
+}

data/tracks/purescript/exercises/sum-of-multiples/examples/src/SumOfMultiples.purs

@@ -0,0 +1,16 @@
+module SumOfMultiples
+  ( sumOfMultiples
+  ) where
+
+import Prelude
+import Data.Array ((..), filter)
+import Data.Foldable (any, sum)
+
+sumOfMultiples :: Array Int -> Int -> Int
+sumOfMultiples factors limit = sum $ filter (any isMultiple factors) rangeToCheck
+  where
+    rangeToCheck :: Array Int
+    rangeToCheck = 1..(limit - 1)
+
+    isMultiple :: Int -> Int -> Boolean
+    isMultiple factor x = x `mod` factor == 0

data/tracks/purescript/exercises/sum-of-multiples/src/SumOfMultiples.purs

@@ -0,0 +1,3 @@
+module SumOfMultiples
+  ( sumOfMultiples
+  ) where

data/tracks/purescript/exercises/sum-of-multiples/test/Main.purs

@@ -0,0 +1,63 @@
+module Test.Main where
+
+import Prelude
+
+import Control.Monad.Aff.AVar (AVAR)
+import Control.Monad.Eff (Eff)
+import Control.Monad.Eff.Console (CONSOLE)
+import SumOfMultiples (sumOfMultiples)
+import Test.Unit (TestSuite, suite, test)
+import Test.Unit.Assert as Assert
+import Test.Unit.Console (TESTOUTPUT)
+import Test.Unit.Main (runTest)
+
+main :: forall eff
+  . Eff ( avar :: AVAR
+        , console :: CONSOLE
+        , testOutput :: TESTOUTPUT
+        | eff
+        )
+        Unit
+main = runTest suites
+
+suites :: forall e. TestSuite e
+suites = do
+  suite "SumOfMultiples.sumOfMultiples" do
+    test "multiples of 3 or 5 up to 1" do
+      Assert.equal 0 (sumOfMultiples [3, 5] 1)
+
+    test "multiples of 3 or 5 up to 4" do
+      Assert.equal 3 (sumOfMultiples [3, 5] 4)
+
+    test "multiples of 3 up to 7" do
+      Assert.equal 9 (sumOfMultiples [3] 7)
+
+    test "multiples of 3 or 5 up to 10" do
+      Assert.equal 23 (sumOfMultiples [3, 5] 10)
+
+    test "multiples of 3 or 5 up to 100" do
+      Assert.equal 2318 (sumOfMultiples [3, 5] 100)
+
+    test "multiples of 3 or 5 up to 1000" do
+      Assert.equal 233168 (sumOfMultiples [3, 5] 1000)
+
+    test "multiples of 7, 13 or 17 up to 20" do
+      Assert.equal 51 (sumOfMultiples [7, 13, 17] 20)
+
+    test "multiples of 4 or 6 up to 15" do
+      Assert.equal 30 (sumOfMultiples [4, 6] 15)
+
+    test "multiples of 5, 6 or 8 up to 150" do
+      Assert.equal 4419 (sumOfMultiples [5, 6, 8] 150)
+
+    test "multiples of 5 or 25 up to 51" do
+      Assert.equal 275 (sumOfMultiples [5, 25] 51)
+
+    test "multiples of 43 or 47 up to 10000" do
+      Assert.equal 2203160 (sumOfMultiples [43, 47] 10000)
+
+    test "multiples of 1 up to 100" do
+      Assert.equal 4950 (sumOfMultiples [1] 100)
+
+    test "multiples of an empty list up to 10000" do
+      Assert.equal 0 (sumOfMultiples [] 10000)

data/tracks/python/README.md

@@ -22,6 +22,7 @@ A list of missing exercise can be found here: http://exercism.io/languages/pytho
 - We use minimalistic stub files for all exercises (#272).
 - We use `unittest` (Python Standard Library) and no 3rd-party-framework.
 - We use the parameter order `self.assertEqual(actual, expected)` (#440).
+- We use context managers (`with self.assertRaises(\<exception type\>):`) for testing for exceptions (#477).
 
 
 ### Testing
@@ -50,7 +51,7 @@ This repo uses [flake8](http://flake8.readthedocs.org/en/latest/) with default s
 
 This repo uses `travis-ci` in the following configuration: [travis.yml](https://github.com/exercism/python/blob/master/.travis.yml)
 
-It will check automatically the code style, the problem configuration and runns the unittests with all supported Python versions.
+It will automatically check the code style, the problem configuration, and run the unittests with all supported Python versions.
 
 
 ## Pull Requests
@@ -71,3 +72,6 @@ If you're new to Git take a look at [this short guide](https://github.com/exerci
 
 ## Python icon
 The Python logo is an unregistered trademark. We are using a derived logo with the permission of the Python Software Foundation.
+
+## License
+This repository uses the [MIT License](/LICENSE).

data/tracks/python/config.json

@@ -118,7 +118,9 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
-
+        "strings",
+        "equality",
+        "conditionals"
       ]
     },
     {
@@ -140,7 +142,11 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
-
+        "strings",
+        "conditionals",
+        "dates",
+        "parsing",
+        "pattern_recognition"
       ]
     },
     {
@@ -503,7 +509,11 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
-
+        "algorithms",
+        "conditionals",
+        "classes",
+        "exception_handling",
+        "queues"
       ]
     },
     {
@@ -537,7 +547,10 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
-
+            "algorithms",
+            "cryptography",
+            "text_formatting",
+            "lists"
       ]
     },
     {
@@ -560,7 +573,13 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
-
+        "algorithms",
+        "conditionals",
+        "lists",
+        "loops",
+        "mathematics",
+        "matrices",
+        "sets"
       ]
     },
     {
@@ -582,7 +601,10 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
-
+      	"algorithms",
+        "loops",
+        "mathematics",
+        "logic"
       ]
     },
     {
@@ -632,7 +654,10 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
-
+        "recursion",
+        "strings",
+        "stacks",
+        "parsing"
       ]
     },
     {
@@ -642,7 +667,11 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
-
+        "lists",
+        "parsing",
+        "transformation",
+        "loops",
+        "games"
       ]
     },
     {
@@ -696,7 +725,9 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
-
+        "lists",
+        "parsing",
+        "pattern_recognition"
       ]
     },
     {
@@ -1043,6 +1074,18 @@
         "conditionals"
       ]
     },
+    {
+        "uuid": "4f5f890d-0db4-5480-f79a-21057c37871b15133dc",
+        "slug": "zipper",
+        "core": false,
+        "unlocked_by": null,
+        "difficulty": 8,
+        "topics": [
+            "recursion",
+            "searching",
+            "trees"
+        ]
+    },
     {
       "uuid": "e7351e8e-d3ff-4621-b818-cd55cf05bffd",
       "slug": "accumulate",

data/tracks/python/exercises/allergies/allergies_test.py

@@ -12,18 +12,18 @@ if not hasattr(unittest.TestCase, 'assertCountEqual'):
 class AllergiesTests(unittest.TestCase):
     def test_no_allergies_means_not_allergic(self):
         allergies = Allergies(0)
-        self.assertFalse(allergies.is_allergic_to('peanuts'))
-        self.assertFalse(allergies.is_allergic_to('cats'))
-        self.assertFalse(allergies.is_allergic_to('strawberries'))
+        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.assertTrue(Allergies(1).is_allergic_to('eggs'))
+        self.assertIs(Allergies(1).is_allergic_to('eggs'), True)
 
     def test_allergic_to_eggs_in_addition_to_other_stuff(self):
         allergies = Allergies(5)
-        self.assertTrue(allergies.is_allergic_to('eggs'))
-        self.assertTrue(allergies.is_allergic_to('shellfish'))
-        self.assertFalse(allergies.is_allergic_to('strawberries'))
+        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_no_allergies_at_all(self):
         self.assertEqual(Allergies(0).lst, [])

data/tracks/python/exercises/allergies/example.py

@@ -15,7 +15,7 @@ class Allergies(object):
         self.score = score
 
     def is_allergic_to(self, allergy):
-        return self.score & 1 << self._allergies.index(allergy)
+        return bool(self.score & 1 << self._allergies.index(allergy))
 
     @property
     def lst(self):

data/tracks/python/exercises/binary-search/binary_search_test.py

@@ -27,17 +27,20 @@ class BinarySearchTests(unittest.TestCase):
             5)
 
     def test_identifies_value_missing(self):
-        self.assertRaises(ValueError, binary_search, [1, 3, 4, 6, 8, 9, 11], 7)
+        with self.assertRaises(ValueError):
+            binary_search([1, 3, 4, 6, 8, 9, 11], 7)
 
     def test_value_smaller_than_arrays_minimum(self):
-        self.assertRaises(ValueError, binary_search, [1, 3, 4, 6, 8, 9, 11], 0)
+        with self.assertRaises(ValueError):
+            binary_search([1, 3, 4, 6, 8, 9, 11], 0)
 
     def test_value_larger_than_arrays_maximum(self):
-        self.assertRaises(ValueError, binary_search, [1, 3, 4, 6, 8, 9, 11],
-                          13)
+        with self.assertRaises(ValueError):
+            binary_search([1, 3, 4, 6, 8, 9, 11], 13)
 
     def test_empty_array(self):
-        self.assertRaises(ValueError, binary_search, [], 1)
+        with self.assertRaises(ValueError):
+            binary_search([], 1)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/binary/binary_test.py

@@ -32,16 +32,20 @@ class BinaryTests(unittest.TestCase):
         self.assertEqual(parse_binary("10001101000"), 1128)
 
     def test_invalid_binary_text_only(self):
-        self.assertRaises(ValueError, parse_binary, "carrot")
+        with self.assertRaises(ValueError):
+            parse_binary("carrot")
 
     def test_invalid_binary_number_not_base2(self):
-        self.assertRaises(ValueError, parse_binary, "102011")
+        with self.assertRaises(ValueError):
+            parse_binary("102011")
 
     def test_invalid_binary_numbers_with_text(self):
-        self.assertRaises(ValueError, parse_binary, "10nope")
+        with self.assertRaises(ValueError):
+            parse_binary("10nope")
 
     def test_invalid_binary_text_with_numbers(self):
-        self.assertRaises(ValueError, parse_binary, "nope10")
+        with self.assertRaises(ValueError):
+            parse_binary("nope10")
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/book-store/example.py

@@ -5,7 +5,7 @@ def _group_price(size):
     discounts = [0, .05, .1, .2, .25]
     if not (0 < size <= 5):
         raise ValueError('size must be in 1..' + len(discounts))
-    return 8 * size * (1 - discounts[size - 1])
+    return BOOK_PRICE * size * (1 - discounts[size - 1])
 
 
 def calculate_total(books, price_so_far=0.):

data/tracks/python/exercises/clock/clock.py

@@ -1,3 +1,6 @@
 class Clock(object):
     def __init__(self, hour, minute):
         pass
+
+    def __add__(self, other):
+        pass

data/tracks/python/exercises/clock/clock_test.py

@@ -64,52 +64,52 @@ class ClockTest(unittest.TestCase):
 
     # Test adding and subtracting minutes.
     def test_add_minutes(self):
-        self.assertEqual(str(Clock(10, 0).add(3)), '10:03')
+        self.assertEqual(str(Clock(10, 0) + 3), '10:03')
 
     def test_add_no_minutes(self):
-        self.assertEqual(str(Clock(6, 41).add(0)), '06:41')
+        self.assertEqual(str(Clock(6, 41) + 0), '06:41')
 
     def test_add_to_next_hour(self):
-        self.assertEqual(str(Clock(0, 45).add(40)), '01:25')
+        self.assertEqual(str(Clock(0, 45) + 40), '01:25')
 
     def test_add_more_than_one_hour(self):
-        self.assertEqual(str(Clock(10, 0).add(61)), '11:01')
+        self.assertEqual(str(Clock(10, 0) + 61), '11:01')
 
     def test_add_more_than_two_hours_with_carry(self):
-        self.assertEqual(str(Clock(0, 45).add(160)), '03:25')
+        self.assertEqual(str(Clock(0, 45) + 160), '03:25')
 
     def test_add_across_midnight(self):
-        self.assertEqual(str(Clock(23, 59).add(2)), '00:01')
+        self.assertEqual(str(Clock(23, 59) + 2), '00:01')
 
     def test_add_more_than_one_day(self):
-        self.assertEqual(str(Clock(5, 32).add(1500)), '06:32')
+        self.assertEqual(str(Clock(5, 32) + 1500), '06:32')
 
     def test_add_more_than_two_days(self):
-        self.assertEqual(str(Clock(1, 1).add(3500)), '11:21')
+        self.assertEqual(str(Clock(1, 1) + 3500), '11:21')
 
     def test_subtract_minutes(self):
-        self.assertEqual(str(Clock(10, 3).add(-3)), '10:00')
+        self.assertEqual(str(Clock(10, 3) + -3), '10:00')
 
     def test_subtract_to_previous_hour(self):
-        self.assertEqual(str(Clock(10, 3).add(-3)), '10:00')
+        self.assertEqual(str(Clock(10, 3) + -3), '10:00')
 
     def test_subtract_more_than_an_hour(self):
-        self.assertEqual(str(Clock(10, 3).add(-30)), '09:33')
+        self.assertEqual(str(Clock(10, 3) + -30), '09:33')
 
     def test_subtract_across_midnight(self):
-        self.assertEqual(str(Clock(10, 3).add(-70)), '08:53')
+        self.assertEqual(str(Clock(10, 3) + -70), '08:53')
 
     def test_subtract_more_than_two_hours(self):
-        self.assertEqual(str(Clock(0, 0).add(-160)), '21:20')
+        self.assertEqual(str(Clock(0, 0) + -160), '21:20')
 
     def test_subtract_more_than_two_hours_with_borrow(self):
-        self.assertEqual(str(Clock(6, 15).add(-160)), '03:35')
+        self.assertEqual(str(Clock(6, 15) + -160), '03:35')
 
     def test_subtract_more_than_one_day(self):
-        self.assertEqual(str(Clock(5, 32).add(-1500)), '04:32')
+        self.assertEqual(str(Clock(5, 32) + -1500), '04:32')
 
     def test_subtract_more_than_two_days(self):
-        self.assertEqual(str(Clock(2, 20).add(-3000)), '00:20')
+        self.assertEqual(str(Clock(2, 20) + -3000), '00:20')
 
     # Construct two separate clocks, set times, test if they are equal.
     def test_clocks_with_same_time(self):