trackler 2.0.8.27 → 2.0.8.28

data/tracks/python/exercises/sum-of-multiples/example.py

@@ -1,7 +1,4 @@
-def sum_of_multiples(limit, multiples=None):
-    if multiples[0] == 0:
-        # multiples of 0 don't change the sum
-        multiples = multiples[1:]
+def sum_of_multiples(limit, multiples):
     return sum(value for value in range(limit)
                if any(value % multiple == 0
                       for multiple in multiples))

data/tracks/python/exercises/sum-of-multiples/sum_of_multiples_test.py

@@ -1,10 +1,10 @@
 """
 You can make the following assumptions about the inputs to the
 'sum_of_multiples' function:
-    * All input numbers are non-negative 'int's, i.e. natural numbers including
-      zero.
-    * A list of factors must be given, and its elements are unique and sorted in
-      ascending order.
+    * All input numbers are non-negative 'int's, i.e. natural numbers
+      including zero.
+    * A list of factors must be given, and its elements are unique
+      and sorted in ascending order.
 """
 
 import unittest
@@ -12,39 +12,44 @@ import unittest
 from sum_of_multiples import sum_of_multiples
 
 
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+
 class SumOfMultiplesTest(unittest.TestCase):
-    def test_sum_to_1(self):
-        self.assertEqual(0, sum_of_multiples(1, [3, 5]))
+    def test_multiples_of_3_or_5_up_to_1(self):
+        self.assertEqual(sum_of_multiples(1, [3, 5]), 0)
+
+    def test_multiples_of_3_or_5_up_to_4(self):
+        self.assertEqual(sum_of_multiples(4, [3, 5]), 3)
 
-    def test_sum_to_3(self):
-        self.assertEqual(3, sum_of_multiples(4, [3, 5]))
+    def test_multiples_of_3_or_5_up_to_10(self):
+        self.assertEqual(sum_of_multiples(10, [3, 5]), 23)
 
-    def test_sum_to_10(self):
-        self.assertEqual(23, sum_of_multiples(10, [3, 5]))
+    def test_multiples_of_3_or_5_up_to_100(self):
+        self.assertEqual(sum_of_multiples(100, [3, 5]), 2318)
 
-    def test_sum_to_100(self):
-        self.assertEqual(2318, sum_of_multiples(100, [3, 5]))
+    def test_multiples_of_3_or_5_up_to_1000(self):
+        self.assertEqual(sum_of_multiples(1000, [3, 5]), 233168)
 
-    def test_sum_to_1000(self):
-        self.assertEqual(233168, sum_of_multiples(1000, [3, 5]))
+    def test_multiples_of_7_13_or_17_up_to_20(self):
+        self.assertEqual(sum_of_multiples(20, [7, 13, 17]), 51)
 
-    def test_configurable_7_13_17_to_20(self):
-        self.assertEqual(51, sum_of_multiples(20, [7, 13, 17]))
+    def test_multiples_of_4_or_6_up_to_15(self):
+        self.assertEqual(sum_of_multiples(15, [4, 6]), 30)
 
-    def test_configurable_4_6_to_15(self):
-        self.assertEqual(30, sum_of_multiples(15, [4, 6]))
+    def test_multiples_of_5_6_or_8_up_to_150(self):
+        self.assertEqual(sum_of_multiples(150, [5, 6, 8]), 4419)
 
-    def test_configurable_5_6_8_to_150(self):
-        self.assertEqual(4419, sum_of_multiples(150, [5, 6, 8]))
+    def test_multiples_of_5_or_25_up_to_51(self):
+        self.assertEqual(sum_of_multiples(51, [5, 25]), 275)
 
-    def test_configurable_43_47_to_10000(self):
-        self.assertEqual(2203160, sum_of_multiples(10000, [43, 47]))
+    def test_multiples_of_43_or_47_up_to_10000(self):
+        self.assertEqual(sum_of_multiples(10000, [43, 47]), 2203160)
 
-    def test_configurable_0_to_10(self):
-        self.assertEqual(0, sum_of_multiples(10, [0]))
+    def test_multiples_of_1_up_to_100(self):
+        self.assertEqual(sum_of_multiples(100, [1]), 4950)
 
-    def test_configurable_0_1_to_10(self):
-        self.assertEqual(45, sum_of_multiples(10, [0, 1]))
+    def test_multiples_of_an_empty_list_up_to_10000(self):
+        self.assertEqual(sum_of_multiples(10000, []), 0)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/triangle/triangle_test.py

@@ -5,63 +5,48 @@ from triangle import Triangle, TriangleError
 
 class TriangleTests(unittest.TestCase):
     def test_equilateral_triangles_have_equal_sides(self):
-        self.assertEqual("equilateral", Triangle(2, 2, 2).kind())
+        self.assertEqual(Triangle(2, 2, 2).kind(), "equilateral")
 
     def test_larger_equilateral_triangles_also_have_equal_sides(self):
-        self.assertEqual("equilateral", Triangle(10, 10, 10).kind())
+        self.assertEqual(Triangle(10, 10, 10).kind(), "equilateral")
 
     def test_isosceles_triangles_have_last_two_sides_equal(self):
-        self.assertEqual("isosceles", Triangle(3, 4, 4).kind())
+        self.assertEqual(Triangle(3, 4, 4).kind(), "isosceles")
 
     def test_isosceles_triangles_have_first_and_last_sides_equal(self):
-        self.assertEqual("isosceles", Triangle(4, 3, 4).kind())
+        self.assertEqual(Triangle(4, 3, 4).kind(), "isosceles")
 
     def test_isosceles_triangles_have_two_first_sides_equal(self):
-        self.assertEqual("isosceles", Triangle(4, 4, 3).kind())
+        self.assertEqual(Triangle(4, 4, 3).kind(), "isosceles")
 
     def test_isosceles_triangles_have_in_fact_exactly_two_sides_equal(self):
-        self.assertEqual("isosceles", Triangle(10, 10, 2).kind())
+        self.assertEqual(Triangle(10, 10, 2).kind(), "isosceles")
 
     def test_scalene_triangles_have_no_equal_sides(self):
-        self.assertEqual("scalene", Triangle(3, 4, 5).kind())
+        self.assertEqual(Triangle(3, 4, 5).kind(), "scalene")
 
     def test_scalene_triangles_have_no_equal_sides_at_a_larger_scale_too(self):
-        self.assertEqual("scalene", Triangle(10, 11, 12).kind())
+        self.assertEqual(Triangle(10, 11, 12).kind(), "scalene")
 
-        self.assertEqual("scalene", Triangle(5, 4, 2).kind())
+        self.assertEqual(Triangle(5, 4, 2).kind(), "scalene")
 
     def test_very_small_triangles_are_legal(self):
-        self.assertEqual("scalene", Triangle(0.4, 0.6, 0.3).kind())
+        self.assertEqual(Triangle(0.4, 0.6, 0.3).kind(), "scalene")
 
     def test_triangles_with_no_size_are_illegal(self):
-        self.assertRaises(
-            TriangleError,
-            Triangle, 0, 0, 0
-        )
+        self.assertRaises(TriangleError, Triangle, 0, 0, 0)
 
     def test_triangles_with_negative_sides_are_illegal(self):
-        self.assertRaises(
-            TriangleError,
-            Triangle, 3, 4, -5
-        )
+        self.assertRaises(TriangleError, Triangle, 3, 4, -5)
 
     def test_triangles_violating_triangle_inequality_are_illegal(self):
-        self.assertRaises(
-            TriangleError,
-            Triangle, 1, 1, 3
-        )
+        self.assertRaises(TriangleError, Triangle, 1, 1, 3)
 
     def test_triangles_violating_triangle_inequality_are_illegal_2(self):
-        self.assertRaises(
-            TriangleError,
-            Triangle, 2, 4, 2
-        )
+        self.assertRaises(TriangleError, Triangle, 2, 4, 2)
 
     def test_triangles_violating_triangle_inequality_are_illegal_3(self):
-        self.assertRaises(
-            TriangleError,
-            Triangle, 7, 3, 2
-        )
+        self.assertRaises(TriangleError, Triangle, 7, 3, 2)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/trinary/trinary_test.py

@@ -5,25 +5,25 @@ from trinary import trinary
 
 class TrinaryTest(unittest.TestCase):
     def test_valid_trinary1(self):
-        self.assertEqual(0, trinary('0'))
+        self.assertEqual(trinary('0'), 0)
 
     def test_valid_trinary2(self):
-        self.assertEqual(1, trinary('1'))
+        self.assertEqual(trinary('1'), 1)
 
     def test_valid_trinary3(self):
-        self.assertEqual(3, trinary('10'))
+        self.assertEqual(trinary('10'), 3)
 
     def test_valid_trinary4(self):
-        self.assertEqual(307, trinary('102101'))
+        self.assertEqual(trinary('102101'), 307)
 
     def test_valid_trinary5(self):
-        self.assertEqual(242, trinary('22222'))
+        self.assertEqual(trinary('22222'), 242)
 
     def test_valid_trinary6(self):
-        self.assertEqual(81, trinary('10000'))
+        self.assertEqual(trinary('10000'), 81)
 
     def test_invalid_trinary(self):
-        self.assertEqual(0, trinary('13201'))
+        self.assertEqual(trinary('13201'), 0)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/twelve-days/twelve_days_test.py

@@ -4,24 +4,23 @@ from twelve_days import sing, verse, verses
 
 
 class TwelveDaysTests(unittest.TestCase):
-
     def test_verse1(self):
         expected = ("On the first day of Christmas my true love gave to me, "
                     "a Partridge in a Pear Tree.\n")
-        self.assertEqual(expected, verse(1))
+        self.assertEqual(verse(1), expected)
 
     def test_verse2(self):
         expected = ("On the second day of Christmas my true love gave to me, "
                     "two Turtle Doves, "
                     "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(expected, verse(2))
+        self.assertEqual(verse(2), expected)
 
     def test_verse3(self):
         expected = ("On the third day of Christmas my true love gave to me, "
                     "three French Hens, "
                     "two Turtle Doves, "
                     "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(expected, verse(3))
+        self.assertEqual(verse(3), expected)
 
     def test_verse4(self):
         expected = ("On the fourth day of Christmas my true love gave to me, "
@@ -29,7 +28,7 @@ class TwelveDaysTests(unittest.TestCase):
                     "three French Hens, "
                     "two Turtle Doves, "
                     "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(expected, verse(4))
+        self.assertEqual(verse(4), expected)
 
     def test_verse5(self):
         expected = ("On the fifth day of Christmas my true love gave to me, "
@@ -38,7 +37,7 @@ class TwelveDaysTests(unittest.TestCase):
                     "three French Hens, "
                     "two Turtle Doves, "
                     "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(expected, verse(5))
+        self.assertEqual(verse(5), expected)
 
     def test_verse6(self):
         expected = ("On the sixth day of Christmas my true love gave to me, "
@@ -48,7 +47,7 @@ class TwelveDaysTests(unittest.TestCase):
                     "three French Hens, "
                     "two Turtle Doves, "
                     "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(expected, verse(6))
+        self.assertEqual(verse(6), expected)
 
     def test_verse7(self):
         expected = ("On the seventh day of Christmas my true love gave to me, "
@@ -59,7 +58,7 @@ class TwelveDaysTests(unittest.TestCase):
                     "three French Hens, "
                     "two Turtle Doves, "
                     "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(expected, verse(7))
+        self.assertEqual(verse(7), expected)
 
     def test_verse8(self):
         expected = ("On the eighth day of Christmas my true love gave to me, "
@@ -71,7 +70,7 @@ class TwelveDaysTests(unittest.TestCase):
                     "three French Hens, "
                     "two Turtle Doves, "
                     "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(expected, verse(8))
+        self.assertEqual(verse(8), expected)
 
     def test_verse9(self):
         expected = ("On the ninth day of Christmas my true love gave to me, "
@@ -84,7 +83,7 @@ class TwelveDaysTests(unittest.TestCase):
                     "three French Hens, "
                     "two Turtle Doves, "
                     "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(expected, verse(9))
+        self.assertEqual(verse(9), expected)
 
     def test_verse10(self):
         expected = ("On the tenth day of Christmas my true love gave to me, "
@@ -98,7 +97,7 @@ class TwelveDaysTests(unittest.TestCase):
                     "three French Hens, "
                     "two Turtle Doves, "
                     "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(expected, verse(10))
+        self.assertEqual(verse(10), expected)
 
     def test_verse11(self):
         expected = ("On the eleventh day of Christmas "
@@ -114,7 +113,7 @@ class TwelveDaysTests(unittest.TestCase):
                     "three French Hens, "
                     "two Turtle Doves, "
                     "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(expected, verse(11))
+        self.assertEqual(verse(11), expected)
 
     def test_verse12(self):
         expected = ("On the twelfth day of Christmas my true love gave to me, "
@@ -130,7 +129,7 @@ class TwelveDaysTests(unittest.TestCase):
                     "three French Hens, "
                     "two Turtle Doves, "
                     "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(expected, verse(12))
+        self.assertEqual(verse(12), expected)
 
     def test_multiple_verses(self):
         expected = ("On the first day of Christmas my true love gave to me, "
@@ -142,7 +141,7 @@ class TwelveDaysTests(unittest.TestCase):
                     "three French Hens, "
                     "two Turtle Doves, "
                     "and a Partridge in a Pear Tree.\n\n")
-        self.assertEqual(expected, verses(1, 3))
+        self.assertEqual(verses(1, 3), expected)
 
     def test_the_whole_song(self):
         self.assertEqual(verses(1, 12), sing())

data/tracks/python/exercises/word-count/example.py

@@ -1,16 +1,8 @@
 from collections import Counter
 
 
-# to be backwards compatible with the old Python 2.X
-def decode_if_needed(string):
-    try:
-        return string.decode('utf-8')
-    except AttributeError:
-        return string
-
-
 def word_count(text):
     def replace_nonalpha(char):
         return char.lower() if char.isalnum() else ' '
-    text = ''.join(replace_nonalpha(c) for c in decode_if_needed(text))
+    text = ''.join(replace_nonalpha(c) for c in text)
     return Counter(text.split())

data/tracks/python/exercises/word-count/word_count_test.py

@@ -1,17 +1,8 @@
-# -*- coding: utf-8 -*-
 import unittest
 
 from word_count import word_count
 
 
-# to be backwards compatible with the old Python 2.X
-def decode_if_needed(string):
-    try:
-        return string.decode('utf-8')
-    except AttributeError:
-        return string
-
-
 class WordCountTests(unittest.TestCase):
 
     def test_count_one_word(self):
@@ -78,12 +69,6 @@ class WordCountTests(unittest.TestCase):
             word_count('hey,my_spacebar_is_broken.')
         )
 
-    def test_unicode(self):
-        self.assertEqual(
-            {decode_if_needed('до'): 1, decode_if_needed('свидания'): 1},
-            word_count('до🖖свидания!')
-        )
-
 
 if __name__ == '__main__':
     unittest.main()

data/tracks/python/exercises/wordy/wordy_test.py

@@ -4,50 +4,49 @@ from wordy import calculate
 
 
 class WordyTest(unittest.TestCase):
-
     def test_simple_add_1(self):
-        self.assertEqual(18, calculate("What is 5 plus 13?"))
+        self.assertEqual(calculate("What is 5 plus 13?"), 18)
 
     def test_simple_add_2(self):
-        self.assertEqual(-8, calculate("What is 5 plus -13?"))
+        self.assertEqual(calculate("What is 5 plus -13?"), -8)
 
     def test_simple_sub_1(self):
-        self.assertEqual(6, calculate("What is 103 minus 97?"))
+        self.assertEqual(calculate("What is 103 minus 97?"), 6)
 
     def test_simple_sub_2(self):
-        self.assertEqual(-6, calculate("What is 97 minus 103?"))
+        self.assertEqual(calculate("What is 97 minus 103?"), -6)
 
     def test_simple_mult(self):
-        self.assertEqual(21, calculate("What is 7 multiplied by 3?"))
+        self.assertEqual(calculate("What is 7 multiplied by 3?"), 21)
 
     def test_simple_div(self):
-        self.assertEqual(9, calculate("What is 45 divided by 5?"))
+        self.assertEqual(calculate("What is 45 divided by 5?"), 9)
 
     def test_add_negative_numbers(self):
-        self.assertEqual(-11, calculate("What is -1 plus -10?"))
+        self.assertEqual(calculate("What is -1 plus -10?"), -11)
 
     def test_add_more_digits(self):
-        self.assertEqual(45801, calculate("What is 123 plus 45678?"))
+        self.assertEqual(calculate("What is 123 plus 45678?"), 45801)
 
     def test_add_twice(self):
-        self.assertEqual(4, calculate("What is 1 plus 2 plus 1?"))
+        self.assertEqual(calculate("What is 1 plus 2 plus 1?"), 4)
 
     def test_add_then_subtract(self):
-        self.assertEqual(14, calculate("What is 1 plus 5 minus -8?"))
+        self.assertEqual(calculate("What is 1 plus 5 minus -8?"), 14)
 
     def test_subtract_twice(self):
-        self.assertEqual(-7, calculate("What is 20 minus 14 minus 13?"))
+        self.assertEqual(calculate("What is 20 minus 14 minus 13?"), -7)
 
     def test_multiply_twice(self):
-        self.assertEqual(-12, calculate("What is 2 multiplied by -2 "
-                                        "multiplied by 3?"))
+        self.assertEqual(
+            calculate("What is 2 multiplied by -2 multiplied by 3?"), -12)
 
     def test_add_then_multiply(self):
-        self.assertEqual(-8, calculate("What is -3 plus 7 multiplied by -2?"))
+        self.assertEqual(calculate("What is -3 plus 7 multiplied by -2?"), -8)
 
     def test_divide_twice(self):
         self.assertEqual(
-            16, calculate("What is -12000 divided by 25 divided by -30?"))
+            calculate("What is -12000 divided by 25 divided by -30?"), 16)
 
     def test_invalid_operation(self):
         self.assertRaises(ValueError, calculate, "What is 4 xor 7?")
@@ -56,8 +55,8 @@ class WordyTest(unittest.TestCase):
         self.assertRaises(ValueError, calculate, "What is 2 2 minus 3?")
 
     def test_missing_number(self):
-        self.assertRaises(ValueError, calculate, "What is 7 plus "
-                                                 "multiplied by -2?")
+        self.assertRaises(ValueError, calculate,
+                          "What is 7 plus multiplied by -2?")
 
     def test_irrelevant_question(self):
         self.assertRaises(ValueError, calculate, "Which is greater, 3 or 2?")

data/tracks/python/exercises/zebra-puzzle/example.py

@@ -17,28 +17,25 @@ def next_to(x, y):
 def solution():
     houses = first, _, middle, _, _ = range(5)
     orderings = list(permutations(houses))
-    result = next([{Englishman: "Englishman", Spaniard: "Spaniard",
-                    Ukranian: "Ukranian", Japanese: "Japanese",
-                    Norwegian: "Norwegian"}[x]
-                   for x in (water, zebra)]
-                  for (red, green, ivory, yellow, blue) in orderings
-                  if just_right_of(green, ivory)
-                  for (Englishman, Spaniard, Ukranian, Japanese, Norwegian) in orderings
-                  if Englishman is red
-                  if Norwegian is first
-                  if next_to(Norwegian, blue)
-                  for (coffee, tea, milk, oj, water) in orderings
-                  if coffee is green
-                  if Ukranian is tea
-                  if milk is middle
-                  for (OldGold, Kools, Chesterfields, LuckyStrike, Parliaments) in orderings
-                  if Kools is yellow
-                  if LuckyStrike is oj
-                  if Japanese is Parliaments
-                  for (dog, snails, fox, horse, zebra) in orderings
-                  if Spaniard is dog
-                  if OldGold is snails
-                  if next_to(Chesterfields, fox)
-                  if next_to(Kools, horse))
+    result = next(
+        [{
+            Englishman: "Englishman",
+            Spaniard: "Spaniard",
+            Ukranian: "Ukranian",
+            Japanese: "Japanese",
+            Norwegian: "Norwegian"
+        }[x] for x in (water, zebra)]
+        for (red, green, ivory, yellow, blue) in orderings
+        if just_right_of(green, ivory)
+        for (Englishman, Spaniard, Ukranian, Japanese, Norwegian) in orderings
+        if Englishman is red if Norwegian is first if next_to(Norwegian, blue)
+        for (coffee, tea, milk, oj, water) in orderings if coffee is green
+        if Ukranian is tea if milk is middle
+        for (OldGold, Kools, Chesterfields, LuckyStrike, Parliaments
+             ) in orderings if Kools is yellow if LuckyStrike is oj
+        if Japanese is Parliaments
+        for (dog, snails, fox, horse, zebra) in orderings if Spaniard is dog
+        if OldGold is snails if next_to(Chesterfields, fox)
+        if next_to(Kools, horse))
     return ("It is the {} who drinks the water.\n"
             "The {} keeps the zebra.").format(*result)