trackler 2.2.1.107 → 2.2.1.108

data/tracks/python/exercises/rectangles/rectangles_test.py

@@ -3,7 +3,7 @@ import unittest
 from rectangles import count
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
 
 class WordTest(unittest.TestCase):
     def test_no_rows(self):

data/tracks/python/exercises/roman-numerals/roman_numerals_test.py

@@ -3,7 +3,7 @@ import unittest
 import roman_numerals
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.2.0
 
 class RomanTest(unittest.TestCase):
     numerals = {
@@ -16,6 +16,7 @@ class RomanTest(unittest.TestCase):
         9: 'IX',
         27: 'XXVII',
         48: 'XLVIII',
+        49: 'XLIX',
         59: 'LIX',
         93: 'XCIII',
         141: 'CXLI',

data/tracks/python/exercises/run-length-encoding/run_length_encoding_test.py

@@ -3,9 +3,9 @@ import unittest
 from run_length_encoding import encode, decode
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
 
-class WordCountTests(unittest.TestCase):
+class RunLengthEncodingTests(unittest.TestCase):
     def test_encode_empty_string(self):
         self.assertMultiLineEqual(encode(''), '')
 

data/tracks/python/exercises/saddle-points/saddle_points_test.py

@@ -10,36 +10,36 @@ import unittest
 from saddle_points import saddle_points
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
 
 class SaddlePointTest(unittest.TestCase):
-    def test_one_saddle(self):
-        inp = [[9, 8, 7], [5, 3, 2], [6, 6, 7]]
-        self.assertEqual(saddle_points(inp), set([(1, 0)]))
+    def test_identify_single_saddle_point(self):
+        matrix = [[9, 8, 7], [5, 3, 2], [6, 6, 7]]
+        self.assertEqual(saddle_points(matrix), set([(1, 0)]))
 
-    def test_empty_matrix(self):
+    def test_empty_matrix_has_no_saddle_points(self):
         self.assertEqual(saddle_points([]), set())
 
-    def test_no_saddle(self):
-        inp = [[1, 2, 3], [3, 1, 2], [2, 3, 1]]
-        self.assertEqual(saddle_points(inp), set())
+    def test_identify_lack_of_saddle_points_when_there_are_none(self):
+        matrix = [[1, 2, 3], [3, 1, 2], [2, 3, 1]]
+        self.assertEqual(saddle_points(matrix), set())
 
-    def test_mult_saddle(self):
-        inp = [[4, 5, 4], [3, 5, 5], [1, 5, 4]]
-        ans = set([(0, 1), (1, 1), (2, 1)])
-        self.assertEqual(saddle_points(inp), ans)
+    def test_identify_multiple_saddle_points(self):
+        matrix = [[4, 5, 4], [3, 5, 5], [1, 5, 4]]
+        expected = set([(0, 1), (1, 1), (2, 1)])
+        self.assertEqual(saddle_points(matrix), expected)
 
-    def test_indentify_saddle_bottom_right_corner(self):
-        inp = [[8, 7, 9], [6, 7, 6], [3, 2, 5]]
-        ans = set([(2, 2)])
-        self.assertEqual(saddle_points(inp), ans)
+    def test_identify_saddle_point_in_bottom_right_corner(self):
+        matrix = [[8, 7, 9], [6, 7, 6], [3, 2, 5]]
+        expected = set([(2, 2)])
+        self.assertEqual(saddle_points(matrix), expected)
 
     # Additional tests for this track
 
     def test_irregular_matrix(self):
-        inp = [[3, 2, 1], [0, 1], [2, 1, 0]]
+        matrix = [[3, 2, 1], [0, 1], [2, 1, 0]]
         with self.assertRaisesWithMessage(ValueError):
-            saddle_points(inp)
+            saddle_points(matrix)
 
     # Utility functions
     def setUp(self):

data/tracks/python/exercises/scale-generator/example.py

@@ -8,22 +8,21 @@ class Scale(object):
     FLAT_KEYS = ['F', 'Bb', 'Eb', 'Ab', 'Db', 'Gb', 'd', 'g', 'c', 'f', 'bb',
                  'eb']
 
-    def __init__(self, tonic, scale_name, pattern=None):
+    def __init__(self, tonic, intervals=None):
         self.tonic = tonic.capitalize()
-        self.name = self.tonic + ' ' + scale_name
-        self.pattern = pattern
+        self.intervals = intervals
         self.chromatic_scale = (self.FLAT_CHROMATIC_SCALE
                                 if tonic in self.FLAT_KEYS
                                 else self.CHROMATIC_SCALE)
         self.pitches = self._assign_pitches()
 
     def _assign_pitches(self):
-        if self.pattern is None:
+        if self.intervals is None:
             return self._reorder_chromatic_scale()
         last_index = 0
         pitches = []
         scale = self._reorder_chromatic_scale()
-        for i, interval in enumerate(self.pattern):
+        for i, interval in enumerate(self.intervals):
             pitches.append(scale[last_index])
             last_index += self.ASCENDING_INTERVALS.index(interval) + 1
         if pitches[0] != scale[last_index % len(scale)]:

data/tracks/python/exercises/scale-generator/scale_generator.py

@@ -1,3 +1,3 @@
 class Scale(object):
-    def __init__(self, tonic, scale_name, pattern=None):
-        pass
+    def __init__(self, tonic, intervals=None):
+        self.pitches = None

data/tracks/python/exercises/scale-generator/scale_generator_test.py

@@ -3,121 +3,86 @@ import unittest
 from scale_generator import Scale
 
 
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+
 class ScaleGeneratorTest(unittest.TestCase):
 
-    def test_naming_scale(self):
-        chromatic = Scale('c', 'chromatic')
-        expected = 'C chromatic'
-        actual = chromatic.name
-        self.assertEqual(expected, actual)
-
-    def test_chromatic_scale(self):
-        chromatic = Scale('C', 'chromatic')
-        expected = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#',
-                    'B']
-        actual = chromatic.pitches
-        self.assertEqual(expected, actual)
-
-    def test_another_chromatic_scale(self):
-        chromatic = Scale('F', 'chromatic')
-        expected = ['F', 'Gb', 'G', 'Ab', 'A', 'Bb', 'B', 'C', 'Db', 'D', 'Eb',
-                    'E']
-        actual = chromatic.pitches
-        self.assertEqual(expected, actual)
-
-    def test_naming_major_scale(self):
-        major = Scale('G', 'major', 'MMmMMMm')
-        expected = 'G major'
-        actual = major.name
-        self.assertEqual(expected, actual)
-
-    def test_major_scale(self):
-        major = Scale('C', 'major', 'MMmMMMm')
+    # Test chromatic scales
+    def test_chromatic_scale_with_sharps(self):
+        expected = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#',
+                    'G', 'G#', 'A', 'A#', 'B']
+        self.assertEqual(Scale('C').pitches, expected)
+
+    def test_chromatic_scale_with_flats(self):
+        expected = ['F', 'Gb', 'G', 'Ab', 'A', 'Bb', 'B',
+                    'C', 'Db', 'D', 'Eb', 'E']
+        self.assertEqual(Scale('F').pitches, expected)
+
+    # Test scales with specified intervals
+    def test_simple_major_scale(self):
         expected = ['C', 'D', 'E', 'F', 'G', 'A', 'B']
-        actual = major.pitches
-        self.assertEqual(expected, actual)
+        self.assertEqual(Scale('C', 'MMmMMMm').pitches, expected)
 
-    def test_another_major_scale(self):
-        major = Scale('G', 'major', 'MMmMMMm')
+    def test_major_scale_with_sharps(self):
         expected = ['G', 'A', 'B', 'C', 'D', 'E', 'F#']
-        actual = major.pitches
-        self.assertEqual(expected, actual)
+        self.assertEqual(Scale('G', 'MMmMMMm').pitches, expected)
+
+    def test_major_scale_with_flats(self):
+        expected = ['F', 'G', 'A', 'Bb', 'C', 'D', 'E']
+        self.assertEqual(Scale('F', 'MMmMMMm').pitches, expected)
 
-    def test_minor_scale(self):
-        minor = Scale('f#', 'minor', 'MmMMmMM')
+    def test_minor_scale_with_sharps(self):
         expected = ['F#', 'G#', 'A', 'B', 'C#', 'D', 'E']
-        actual = minor.pitches
-        self.assertEqual(expected, actual)
+        self.assertEqual(Scale('f#', 'MmMMmMM').pitches, expected)
 
-    def test_another_minor_scale(self):
-        minor = Scale('bb', 'minor', 'MmMMmMM')
+    def test_minor_scale_with_flats(self):
         expected = ['Bb', 'C', 'Db', 'Eb', 'F', 'Gb', 'Ab']
-        actual = minor.pitches
-        self.assertEqual(expected, actual)
+        self.assertEqual(Scale('bb', 'MmMMmMM').pitches, expected)
 
     def test_dorian_mode(self):
-        dorian = Scale('d', 'dorian', 'MmMMMmM')
         expected = ['D', 'E', 'F', 'G', 'A', 'B', 'C']
-        actual = dorian.pitches
-        self.assertEqual(expected, actual)
+        self.assertEqual(Scale('d', 'MmMMMmM').pitches, expected)
 
     def test_mixolydian_mode(self):
-        mixolydian = Scale('Eb', 'mixolydian', 'MMmMMmM')
         expected = ['Eb', 'F', 'G', 'Ab', 'Bb', 'C', 'Db']
-        actual = mixolydian.pitches
-        self.assertEqual(expected, actual)
+        self.assertEqual(Scale('Eb', 'MMmMMmM').pitches, expected)
 
     def test_lydian_mode(self):
-        lydian = Scale('a', 'lydian', 'MMMmMMm')
         expected = ['A', 'B', 'C#', 'D#', 'E', 'F#', 'G#']
-        actual = lydian.pitches
-        self.assertEqual(expected, actual)
+        self.assertEqual(Scale('a', 'MMMmMMm').pitches, expected)
 
     def test_phrygian_mode(self):
-        phrygian = Scale('e', 'phrygian', 'mMMMmMM')
         expected = ['E', 'F', 'G', 'A', 'B', 'C', 'D']
-        actual = phrygian.pitches
-        self.assertEqual(expected, actual)
+        self.assertEqual(Scale('e', 'mMMMmMM').pitches, expected)
 
     def test_locrian_mode(self):
-        locrian = Scale('g', 'locrian', 'mMMmMMM')
         expected = ['G', 'Ab', 'Bb', 'C', 'Db', 'Eb', 'F']
-        actual = locrian.pitches
-        self.assertEqual(expected, actual)
+        self.assertEqual(Scale('g', 'mMMmMMM').pitches, expected)
 
     def test_harmonic_minor(self):
-        harmonic_minor = Scale('d', 'harmonic_minor', 'MmMMmAm')
         expected = ['D', 'E', 'F', 'G', 'A', 'Bb', 'Db']
-        actual = harmonic_minor.pitches
-        self.assertEqual(expected, actual)
+        self.assertEqual(Scale('d', 'MmMMmAm').pitches, expected)
 
     def test_octatonic(self):
-        octatonic = Scale('C', 'octatonic', 'MmMmMmMm')
         expected = ['C', 'D', 'D#', 'F', 'F#', 'G#', 'A', 'B']
-        actual = octatonic.pitches
-        self.assertEqual(expected, actual)
+        self.assertEqual(Scale('C', 'MmMmMmMm').pitches, expected)
 
     def test_hexatonic(self):
-        hexatonic = Scale('Db', 'hexatonic', 'MMMMMM')
         expected = ['Db', 'Eb', 'F', 'G', 'A', 'B']
-        actual = hexatonic.pitches
-        self.assertEqual(expected, actual)
+        self.assertEqual(Scale('Db', 'MMMMMM').pitches, expected)
 
     def test_pentatonic(self):
-        pentatonic = Scale('A', 'pentatonic', 'MMAMA')
         expected = ['A', 'B', 'C#', 'E', 'F#']
-        actual = pentatonic.pitches
-        self.assertEqual(expected, actual)
+        self.assertEqual(Scale('A', 'MMAMA').pitches, expected)
 
     def test_enigmatic(self):
-        enigmatic = Scale('G', 'enigmatic', 'mAMMMmm')
         expected = ['G', 'G#', 'B', 'C#', 'D#', 'F', 'F#']
-        actual = enigmatic.pitches
-        self.assertEqual(expected, actual)
+        self.assertEqual(Scale('G', 'mAMMMmm').pitches, expected)
 
+    # Track-specific tests
     def test_brokeninterval(self):
         with self.assertRaisesWithMessage(ValueError):
-            Scale('G', 'enigmatic', 'mAMMMmM')
+            Scale('G', 'mAMMMmM')
 
     # Utility functions
     def setUp(self):

data/tracks/python/exercises/secret-handshake/secret_handshake_test.py

@@ -3,7 +3,7 @@ import unittest
 from secret_handshake import handshake, secret_code
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.2.0
 
 class HandshakeTest(unittest.TestCase):
     def test_wink_for_1(self):

data/tracks/python/exercises/tournament/tournament_test.py

@@ -3,7 +3,7 @@ import unittest
 from tournament import tally
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.3.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.4.0
 
 class TestTournament(unittest.TestCase):
     def test_just_the_header_if_no_input(self):

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

@@ -20,14 +20,9 @@ def verse(day_number):
     if len(gifts) > 1:
         gifts[:-1] = [', '.join(gifts[:-1])]
     gifts = ', and '.join(gifts)
-    return 'On the {} day of Christmas my true love gave to me, {}.\n'.format(
+    return 'On the {} day of Christmas my true love gave to me, {}.'.format(
         ORDINAL[day_number], gifts)
 
 
-def verses(start, end):
-    return ''.join([verse(n) + '\n'
-                    for n in range(start, end + 1)])
-
-
-def sing():
-    return verses(1, 12)
+def recite(start, end):
+    return [verse(n) for n in range(start, end + 1)]

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

@@ -1,10 +1,2 @@
-def verse(day_number):
-    pass
-
-
-def verses(start, end):
-    pass
-
-
-def sing():
+def recite(start_verse, end_verse):
     pass

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

@@ -1,67 +1,69 @@
 import unittest
 
-from twelve_days import sing, verse, verses
+from twelve_days import recite
 
 
-class TwelveDaysTests(unittest.TestCase):
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
+
+class VerseTests(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(verse(1), expected)
+        expected = ["On the first day of Christmas my true love gave to me, "
+                    "a Partridge in a Pear Tree."]
+        self.assertEqual(recite(1, 1), expected)
 
     def test_verse2(self):
-        expected = ("On the second day of Christmas my true love gave to me, "
+        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(verse(2), expected)
+                    "and a Partridge in a Pear Tree."]
+        self.assertEqual(recite(2, 2), expected)
 
     def test_verse3(self):
-        expected = ("On the third day of Christmas my true love gave to me, "
+        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(verse(3), expected)
+                    "and a Partridge in a Pear Tree."]
+        self.assertEqual(recite(3, 3), expected)
 
     def test_verse4(self):
-        expected = ("On the fourth day of Christmas my true love gave to me, "
+        expected = ["On the fourth day of Christmas my true love gave to me, "
                     "four Calling Birds, "
                     "three French Hens, "
                     "two Turtle Doves, "
-                    "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(verse(4), expected)
+                    "and a Partridge in a Pear Tree."]
+        self.assertEqual(recite(4, 4), expected)
 
     def test_verse5(self):
-        expected = ("On the fifth day of Christmas my true love gave to me, "
+        expected = ["On the fifth day of Christmas my true love gave to me, "
                     "five Gold Rings, "
                     "four Calling Birds, "
                     "three French Hens, "
                     "two Turtle Doves, "
-                    "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(verse(5), expected)
+                    "and a Partridge in a Pear Tree."]
+        self.assertEqual(recite(5, 5), expected)
 
     def test_verse6(self):
-        expected = ("On the sixth day of Christmas my true love gave to me, "
+        expected = ["On the sixth day of Christmas my true love gave to me, "
                     "six Geese-a-Laying, "
                     "five Gold Rings, "
                     "four Calling Birds, "
                     "three French Hens, "
                     "two Turtle Doves, "
-                    "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(verse(6), expected)
+                    "and a Partridge in a Pear Tree."]
+        self.assertEqual(recite(6, 6), expected)
 
     def test_verse7(self):
-        expected = ("On the seventh day of Christmas my true love gave to me, "
+        expected = ["On the seventh day of Christmas my true love gave to me, "
                     "seven Swans-a-Swimming, "
                     "six Geese-a-Laying, "
                     "five Gold Rings, "
                     "four Calling Birds, "
                     "three French Hens, "
                     "two Turtle Doves, "
-                    "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(verse(7), expected)
+                    "and a Partridge in a Pear Tree."]
+        self.assertEqual(recite(7, 7), expected)
 
     def test_verse8(self):
-        expected = ("On the eighth day of Christmas my true love gave to me, "
+        expected = ["On the eighth day of Christmas my true love gave to me, "
                     "eight Maids-a-Milking, "
                     "seven Swans-a-Swimming, "
                     "six Geese-a-Laying, "
@@ -69,11 +71,11 @@ class TwelveDaysTests(unittest.TestCase):
                     "four Calling Birds, "
                     "three French Hens, "
                     "two Turtle Doves, "
-                    "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(verse(8), expected)
+                    "and a Partridge in a Pear Tree."]
+        self.assertEqual(recite(8, 8), expected)
 
     def test_verse9(self):
-        expected = ("On the ninth day of Christmas my true love gave to me, "
+        expected = ["On the ninth day of Christmas my true love gave to me, "
                     "nine Ladies Dancing, "
                     "eight Maids-a-Milking, "
                     "seven Swans-a-Swimming, "
@@ -82,11 +84,11 @@ class TwelveDaysTests(unittest.TestCase):
                     "four Calling Birds, "
                     "three French Hens, "
                     "two Turtle Doves, "
-                    "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(verse(9), expected)
+                    "and a Partridge in a Pear Tree."]
+        self.assertEqual(recite(9, 9), expected)
 
     def test_verse10(self):
-        expected = ("On the tenth day of Christmas my true love gave to me, "
+        expected = ["On the tenth day of Christmas my true love gave to me, "
                     "ten Lords-a-Leaping, "
                     "nine Ladies Dancing, "
                     "eight Maids-a-Milking, "
@@ -96,11 +98,11 @@ class TwelveDaysTests(unittest.TestCase):
                     "four Calling Birds, "
                     "three French Hens, "
                     "two Turtle Doves, "
-                    "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(verse(10), expected)
+                    "and a Partridge in a Pear Tree."]
+        self.assertEqual(recite(10, 10), expected)
 
     def test_verse11(self):
-        expected = ("On the eleventh day of Christmas "
+        expected = ["On the eleventh day of Christmas "
                     "my true love gave to me, "
                     "eleven Pipers Piping, "
                     "ten Lords-a-Leaping, "
@@ -112,11 +114,11 @@ class TwelveDaysTests(unittest.TestCase):
                     "four Calling Birds, "
                     "three French Hens, "
                     "two Turtle Doves, "
-                    "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(verse(11), expected)
+                    "and a Partridge in a Pear Tree."]
+        self.assertEqual(recite(11, 11), expected)
 
     def test_verse12(self):
-        expected = ("On the twelfth day of Christmas my true love gave to me, "
+        expected = ["On the twelfth day of Christmas my true love gave to me, "
                     "twelve Drummers Drumming, "
                     "eleven Pipers Piping, "
                     "ten Lords-a-Leaping, "
@@ -128,23 +130,22 @@ class TwelveDaysTests(unittest.TestCase):
                     "four Calling Birds, "
                     "three French Hens, "
                     "two Turtle Doves, "
-                    "and a Partridge in a Pear Tree.\n")
-        self.assertEqual(verse(12), expected)
+                    "and a Partridge in a Pear Tree."]
+        self.assertEqual(recite(12, 12), expected)
 
-    def test_multiple_verses(self):
-        expected = ("On the first day of Christmas my true love gave to me, "
-                    "a Partridge in a Pear Tree.\n\n"
-                    "On the second day of Christmas my true love gave to me, "
-                    "two Turtle Doves, "
-                    "and a Partridge in a Pear Tree.\n\n"
-                    "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\n")
-        self.assertEqual(verses(1, 3), expected)
+
+class LyricsTests(unittest.TestCase):
+    def test_first_three_verses_of_the_song(self):
+        expected = [recite(n, n)[0] for n in range(1, 4)]
+        self.assertEqual(recite(1, 3), expected)
+
+    def test_three_verses_from_the_middle_of_the_song(self):
+        expected = [recite(n, n)[0] for n in range(4, 7)]
+        self.assertEqual(recite(4, 6), expected)
 
     def test_the_whole_song(self):
-        self.assertEqual(verses(1, 12), sing())
+        expected = [recite(n, n)[0] for n in range(1, 13)]
+        self.assertEqual(recite(1, 12), expected)
 
 
 if __name__ == '__main__':