trackler 2.2.1.87 → 2.2.1.88

data/tracks/python/exercises/pangram/pangram_test.py

@@ -3,12 +3,16 @@ import unittest
 from pangram import is_pangram
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.3.0
 
 class PangramTests(unittest.TestCase):
+
     def test_sentence_empty(self):
         self.assertIs(is_pangram(''), False)
 
+    def test_recognizes_a_perfect_lower_case_pangram(self):
+        self.assertIs(is_pangram('abcdefghijklmnopqrstuvwxyz'), True)
+
     def test_pangram_with_only_lower_case(self):
         self.assertIs(
             is_pangram('the quick brown fox jumps over the lazy dog'),
@@ -20,10 +24,9 @@ class PangramTests(unittest.TestCase):
                        'jeopardize five gunboats'),
             False)
 
-    def test_another_missing_character_x(self):
-        self.assertIs(
-            is_pangram('the quick brown fish jumps over the lazy dog'),
-            False)
+    def test_another_missing_character(self):
+        self.assertIs(is_pangram('five boxing wizards jump quickly at it'),
+                      False)
 
     def test_pangram_with_underscores(self):
         self.assertIs(
@@ -47,7 +50,7 @@ class PangramTests(unittest.TestCase):
 
     def test_upper_and_lower_case_versions_of_the_same_character(self):
         self.assertIs(
-            is_pangram('the quick brown fox jumped over the lazy FOX'),
+            is_pangram('the quick brown fox jumped over the lazy FX'),
             False)
 
 

data/tracks/python/exercises/phone-number/phone_number_test.py

@@ -46,11 +46,11 @@ class PhoneTest(unittest.TestCase):
         with self.assertRaisesWithMessage(ValueError):
             Phone("123-@:!-7890")
 
-    def test_invalid_area_code(self):
+    def test_invalid_when_area_code_does_start_with_1(self):
         with self.assertRaisesWithMessage(ValueError):
             Phone("(123) 456-7890")
 
-    def test_invalid_exchange_code(self):
+    def test_invalid_when_exchange_code_does_start_with_1(self):
         with self.assertRaisesWithMessage(ValueError):
             Phone("(223) 056-7890")
 

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

@@ -1,50 +1,17 @@
 gestures = ['wink', 'double blink', 'close your eyes', 'jump']
 
 
-def handshake(s):
-    s = list(sanitize(s))
-    s.reverse()
-    seq = []
-    lim = len(s) if len(s) <= len(gestures) else len(gestures)
-    for i1 in range(lim):
-        if s[i1] == '1':
-            seq.append(gestures[i1])
-    if len(s) == 5:
-        seq.reverse()
-    return seq
-
-
-def code(seq):
-    if not seq or set(seq) - set(gestures):
-        return '0'
-    s = find_subseq(seq)
-    if not s:
-        s = ['1'] + find_subseq(reversed(seq))
-    return "".join(s)
-
-
-def sanitize(s):
-    if not(isinstance(s, int) or isinstance(s, str)):
-        raise TypeError('Unknown type')
-    if isinstance(s, int):
-        if s < 0:
-            return ""
-        s = bin(s)[2:]
-    elif set(s) - set(['0', '1']):
-        return ""
-    if len(s) > 5:
-        raise ValueError('Binary string too long')
-    return "0" * (len(gestures) - len(s)) + s
-
-
-def find_subseq(seq):
-    idx = 0
-    s = []
-    for g in seq:
-        if g not in gestures[idx:]:
-            return []
-        newidx = gestures.index(g, idx) + 1
-        s.extend(['0'] * (newidx - idx - 1) + ['1'])
-        idx = newidx
-    s.reverse()
-    return s
+def handshake(code):
+    actions = [gestures[i] for i in range(len(gestures))
+               if (code >> i) % 2 == 1]
+    return actions if code < 16 else list(reversed(actions))
+
+
+def secret_code(actions):
+    actions = [a for a in actions if a in gestures]
+    result = sum(1 << i for i, action in enumerate(gestures)
+                 if action in actions)
+    if len(actions) > 1 and (gestures.index(actions[0]) >
+                             gestures.index(actions[1])):
+        result += 16
+    return result

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

@@ -1,6 +1,6 @@
-def handshake(number):
+def handshake(code):
     pass
 
 
-def code(secret_code):
+def secret_code(actions):
     pass

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

@@ -1,49 +1,80 @@
 import unittest
 
-from secret_handshake import handshake, code
+from secret_handshake import handshake, secret_code
 
 
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
+
 class HandshakeTest(unittest.TestCase):
-    def test_shake_int(self):
-        self.assertEqual(handshake(9), ['wink', 'jump'])
+    def test_wink_for_1(self):
+        self.assertEqual(handshake(1), ['wink'])
+
+    def test_double_blink_for_10(self):
+        self.assertEqual(handshake(2), ['double blink'])
+
+    def test_close_your_eyes_for_100(self):
+        self.assertEqual(handshake(4), ['close your eyes'])
+
+    def test_jump_for_1000(self):
+        self.assertEqual(handshake(8), ['jump'])
+
+    def test_combine_two_actions(self):
+        self.assertEqual(handshake(3), ['wink', 'double blink'])
+
+    def test_reverse_two_actions(self):
+        self.assertEqual(handshake(19), ['double blink', 'wink'])
+
+    def test_reversing_one_action_gives_the_same_action(self):
+        self.assertEqual(handshake(24), ['jump'])
 
-    def test_shake_bin1(self):
-        self.assertEqual(
-            handshake('10110'), ['close your eyes', 'double blink'])
+    def test_reversing_no_actions_still_gives_no_actions(self):
+        self.assertEqual(handshake(16), [])
 
-    def test_shake_bin2(self):
-        self.assertEqual(handshake('101'), ['wink', 'close your eyes'])
+    def test_all_possible_actions(self):
+        self.assertEqual(handshake(15), ['wink',
+                                         'double blink',
+                                         'close your eyes',
+                                         'jump'])
 
-    def test_shake_negative_int(self):
-        self.assertEqual(handshake(-9), [])
+    def test_reverse_all_possible_actions(self):
+        self.assertEqual(handshake(31), ['jump',
+                                         'close your eyes',
+                                         'double blink',
+                                         'wink'])
 
-    def test_shake_bin_invalid(self):
-        self.assertEqual(handshake('121'), [])
+    def test_do_nothing_for_zero(self):
+        self.assertEqual(handshake(0), [])
 
-    def test_unknown_action(self):
-        self.assertEqual(code(['wink', 'sneeze']), '0')
+    # Track-specific tests
 
+    @unittest.skip('extra-credit')
     def test_code1(self):
-        self.assertEqual(code(['close your eyes', 'jump']), '1100')
+        self.assertEqual(secret_code(['close your eyes', 'jump']), 12)
 
+    @unittest.skip('extra-credit')
     def test_code2(self):
-        self.assertEqual(code(['wink', 'double blink']), '11')
+        self.assertEqual(secret_code(['wink', 'double blink']), 3)
 
+    @unittest.skip('extra-credit')
     def test_code3(self):
-        self.assertEqual(code(['jump', 'double blink']), '11010')
+        self.assertEqual(secret_code(['jump', 'double blink']), 26)
 
-    def test_composition1(self):
-        self.assertEqual(code(handshake(27)), '11011')
+    @unittest.skip('extra-credit')
+    def test_reversible1(self):
+        self.assertEqual(secret_code(handshake(27)), 27)
 
-    def test_composition2(self):
-        self.assertEqual(code(handshake(1)), '1')
+    @unittest.skip('extra-credit')
+    def test_reversible2(self):
+        self.assertEqual(secret_code(handshake(1)), 1)
 
-    def test_composition3(self):
-        self.assertEqual(code(handshake('111')), '111')
+    @unittest.skip('extra-credit')
+    def test_reversible3(self):
+        self.assertEqual(secret_code(handshake(7)), 7)
 
-    def test_composition4(self):
+    @unittest.skip('extra-credit')
+    def test_reversible4(self):
         inp = ['wink', 'double blink', 'jump']
-        self.assertEqual(handshake(code(inp)), inp)
+        self.assertEqual(handshake(secret_code(inp)), inp)
 
 
 if __name__ == '__main__':

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

@@ -1,6 +1,6 @@
 def transpose(input_lines):
-    lines = input_lines.split("\n")
-    zipped = map(list,
-                 [line.ljust(len(max(lines, key=len)))
-                  for line in lines])
-    return "\n".join("".join(line) for line in zip(*zipped)).strip()
+    lines = [line.replace(' ', '_') for line in input_lines.splitlines()]
+    lines = [line.ljust(len(max(lines, key=len))) for line in lines]
+    lines = [''.join(line) for line in zip(*lines)]
+    lines = [line.rstrip().replace('_', ' ') for line in lines]
+    return '\n'.join(lines)

data/tracks/python/exercises/transpose/transpose_test.py

@@ -2,7 +2,7 @@ import unittest
 from transpose import transpose
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
 
 class TransposeTests(unittest.TestCase):
     def test_empty_string(self):
@@ -14,15 +14,25 @@ class TransposeTests(unittest.TestCase):
         )
 
     def test_two_characters_in_a_row(self):
+        input_line = "A1"
+        expected = [
+            "A",
+            "1"
+        ]
         self.assertEqual(
-            transpose("A1"),
-            "\n".join(["A", "1"])
+            transpose(input_line),
+            "\n".join(expected)
         )
 
     def test_two_characters_in_a_column(self):
+        input_line = [
+            "A",
+            "1"
+        ]
+        expected = "A1"
         self.assertEqual(
-            transpose("\n".join(["A", "1"])),
-            "A1"
+            transpose("\n".join(input_line)),
+            expected
         )
 
     def test_simple(self):
@@ -35,7 +45,6 @@ class TransposeTests(unittest.TestCase):
             "B2",
             "C3"
         ]
-
         self.assertEqual(
             transpose("\n".join(input_line)),
             "\n".join(expected)
@@ -182,77 +191,31 @@ class TransposeTests(unittest.TestCase):
             "\n".join(expected)
         )
 
-    def test_many_lines(self):
+    def test_mixed_line_length(self):
         input_line = [
-            "Chor. Two households, both alike in dignity,",
-            "In fair Verona, where we lay our scene,",
-            "From ancient grudge break to new mutiny,",
-            "Where civil blood makes civil hands unclean.",
-            "From forth the fatal loins of these two foes",
-            "A pair of star-cross'd lovers take their life;",
-            "Whose misadventur'd piteous overthrows",
-            "Doth with their death bury their parents' strife.",
-            "The fearful passage of their death-mark'd love,",
-            "And the continuance of their parents' rage,",
-            "Which, but their children's end, naught could remove,",
-            "Is now the two hours' traffic of our stage;",
-            "The which if you with patient ears attend,",
-            "What here shall miss, our toil shall strive to mend."
+            "The longest line.",
+            "A long line.",
+            "A longer line.",
+            "A line."
         ]
         expected = [
-            "CIFWFAWDTAWITW",
-            "hnrhr hohnhshh",
-            "o oeopotedi ea",
-            "rfmrmash  cn t",
-            ".a e ie fthow ",
-            " ia fr weh,whh",
-            "Trnco miae  ie",
-            "w ciroitr btcr",
-            "oVivtfshfcuhhe",
-            " eeih a uote  ",
-            "hrnl sdtln  is",
-            "oot ttvh tttfh",
-            "un bhaeepihw a",
-            "saglernianeoyl",
-            "e,ro -trsui ol",
-            "h uofcu sarhu ",
-            "owddarrdan o m",
-            "lhg to'egccuwi",
-            "deemasdaeehris",
-            "sr als t  ists",
-            ",ebk 'phool'h,",
-            "  reldi ffd   ",
-            "bweso tb  rtpo",
-            "oea ileutterau",
-            "t kcnoorhhnatr",
-            "hl isvuyee'fi ",
-            " atv es iisfet",
-            "ayoior trr ino",
-            "l  lfsoh  ecti",
-            "ion   vedpn  l",
-            "kuehtteieadoe ",
-            "erwaharrar,fas",
-            "   nekt te  rh",
-            "ismdsehphnnosa",
-            "ncuse ra-tau l",
-            " et  tormsural",
-            "dniuthwea'g t ",
-            "iennwesnr hsts",
-            "g,ycoi tkrttet",
-            "n ,l r s'a anr",
-            "i  ef  'dgcgdi",
-            "t  aol   eoe,v",
-            "y  nei sl,u; e",
-            ",  .sf to l   ",
-            "     e rv d  t",
-            "     ; ie    o",
-            "       f, r   ",
-            "       e  e  m",
-            "       .  m  e",
-            "          o  n",
-            "          v  d",
-            "          e  .",
-            "          ,"
+            "TAAA",
+            "h   ",
+            "elll",
+            " ooi",
+            "lnnn",
+            "ogge",
+            "n e.",
+            "glr",
+            "ei ",
+            "snl",
+            "tei",
+            " .n",
+            "l e",
+            "i .",
+            "n",
+            "e",
+            "."
         ]
         self.assertEqual(
             transpose("\n".join(input_line)),

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

@@ -28,7 +28,7 @@ DIRECTIONS = (Point(1, 0), Point(1, -1), Point(1, 1), Point(-1, -1),
 
 class WordSearch(object):
     def __init__(self, puzzle):
-        self.rows = puzzle.split()
+        self.rows = puzzle
         self.width = len(self.rows[0])
         self.height = len(self.rows)
 

data/tracks/python/exercises/word-search/word_search_test.py

@@ -8,119 +8,119 @@ from word_search import WordSearch, Point
 class WordSearchTests(unittest.TestCase):
 
     def test_initial_game_grid(self):
-        puzzle = 'jefblpepre'
+        puzzle = ['jefblpepre']
         searchAnswer = WordSearch(puzzle).search('clojure')
         self.assertIsNone(searchAnswer)
 
     def test_left_to_right_word(self):
-        puzzle = 'clojurermt'
+        puzzle = ['clojurermt']
         searchAnswer = WordSearch(puzzle).search('clojure')
         self.assertEqual(searchAnswer, (Point(0, 0), Point(6, 0)))
 
     def test_left_to_right_word_different_position(self):
-        puzzle = 'mtclojurer'
+        puzzle = ['mtclojurer']
         searchAnswer = WordSearch(puzzle).search('clojure')
         self.assertEqual(searchAnswer, (Point(2, 0), Point(8, 0)))
 
     def test_different_left_to_right_word(self):
-        puzzle = 'coffeelplx'
+        puzzle = ['coffeelplx']
         searchAnswer = WordSearch(puzzle).search('coffee')
         self.assertEqual(searchAnswer, (Point(0, 0), Point(5, 0)))
 
     def test_different_left_to_right_word_different_position(self):
-        puzzle = 'xcoffeezlp'
+        puzzle = ['xcoffeezlp']
         searchAnswer = WordSearch(puzzle).search('coffee')
         self.assertEqual(searchAnswer, (Point(1, 0), Point(6, 0)))
 
     def test_left_to_right_word_two_lines(self):
-        puzzle = ('jefblpepre\n'
-                  'tclojurerm\n')
+        puzzle = ['jefblpepre',
+                  'tclojurerm']
         searchAnswer = WordSearch(puzzle).search('clojure')
         self.assertEqual(searchAnswer, (Point(1, 1), Point(7, 1)))
 
     def test_left_to_right_word_three_lines(self):
-        puzzle = ('camdcimgtc\n'
-                  'jefblpepre\n'
-                  'clojurermt\n')
+        puzzle = ['camdcimgtc',
+                  'jefblpepre',
+                  'clojurermt']
         searchAnswer = WordSearch(puzzle).search('clojure')
         self.assertEqual(searchAnswer, (Point(0, 2), Point(6, 2)))
 
     def test_left_to_right_word_ten_lines(self):
-        puzzle = ('jefblpepre\n'
-                  'camdcimgtc\n'
-                  'oivokprjsm\n'
-                  'pbwasqroua\n'
-                  'rixilelhrs\n'
-                  'wolcqlirpc\n'
-                  'screeaumgr\n'
-                  'alxhpburyi\n'
-                  'jalaycalmp\n'
-                  'clojurermt\n')
+        puzzle = ['jefblpepre',
+                  'camdcimgtc',
+                  'oivokprjsm',
+                  'pbwasqroua',
+                  'rixilelhrs',
+                  'wolcqlirpc',
+                  'screeaumgr',
+                  'alxhpburyi',
+                  'jalaycalmp',
+                  'clojurermt']
         searchAnswer = WordSearch(puzzle).search('clojure')
         self.assertEqual(searchAnswer, (Point(0, 9), Point(6, 9)))
 
     def test_left_to_right_word_ten_lines_different_position(self):
-        puzzle = ('jefblpepre\n'
-                  'camdcimgtc\n'
-                  'oivokprjsm\n'
-                  'pbwasqroua\n'
-                  'rixilelhrs\n'
-                  'wolcqlirpc\n'
-                  'screeaumgr\n'
-                  'alxhpburyi\n'
-                  'clojurermt\n'
-                  'jalaycalmp\n')
+        puzzle = ['jefblpepre',
+                  'camdcimgtc',
+                  'oivokprjsm',
+                  'pbwasqroua',
+                  'rixilelhrs',
+                  'wolcqlirpc',
+                  'screeaumgr',
+                  'alxhpburyi',
+                  'clojurermt',
+                  'jalaycalmp']
         searchAnswer = WordSearch(puzzle).search('clojure')
         self.assertEqual(searchAnswer, (Point(0, 8), Point(6, 8)))
 
     def test_different_left_to_right_word_ten_lines(self):
-        puzzle = ('jefblpepre\n'
-                  'camdcimgtc\n'
-                  'oivokprjsm\n'
-                  'pbwasqroua\n'
-                  'rixilelhrs\n'
-                  'wolcqlirpc\n'
-                  'fortranftw\n'
-                  'alxhpburyi\n'
-                  'clojurermt\n'
-                  'jalaycalmp\n')
+        puzzle = ['jefblpepre',
+                  'camdcimgtc',
+                  'oivokprjsm',
+                  'pbwasqroua',
+                  'rixilelhrs',
+                  'wolcqlirpc',
+                  'fortranftw',
+                  'alxhpburyi',
+                  'clojurermt',
+                  'jalaycalmp']
         searchAnswer = WordSearch(puzzle).search('fortran')
         self.assertEqual(searchAnswer, (Point(0, 6), Point(6, 6)))
 
     def test_multiple_words(self):
-        puzzle = ('jefblpepre\n'
-                  'camdcimgtc\n'
-                  'oivokprjsm\n'
-                  'pbwasqroua\n'
-                  'rixilelhrs\n'
-                  'wolcqlirpc\n'
-                  'fortranftw\n'
-                  'alxhpburyi\n'
-                  'jalaycalmp\n'
-                  'clojurermt\n')
+        puzzle = ['jefblpepre',
+                  'camdcimgtc',
+                  'oivokprjsm',
+                  'pbwasqroua',
+                  'rixilelhrs',
+                  'wolcqlirpc',
+                  'fortranftw',
+                  'alxhpburyi',
+                  'jalaycalmp',
+                  'clojurermt']
         searchAnswer = WordSearch(puzzle).search('fortran')
         self.assertEqual(searchAnswer, (Point(0, 6), Point(6, 6)))
         searchAnswer = WordSearch(puzzle).search('clojure')
         self.assertEqual(searchAnswer, (Point(0, 9), Point(6, 9)))
 
     def test_single_word_right_to_left(self):
-        puzzle = 'rixilelhrs'
+        puzzle = ['rixilelhrs']
         searchAnswer = WordSearch(puzzle).search('elixir')
         self.assertEqual(searchAnswer, (Point(5, 0), Point(0, 0)))
 
     @classmethod
-    def setUpClass(self):
-        puzzle = ('jefblpepre\n'
-                  'camdcimgtc\n'
-                  'oivokprjsm\n'
-                  'pbwasqroua\n'
-                  'rixilelhrs\n'
-                  'wolcqlirpc\n'
-                  'screeaumgr\n'
-                  'alxhpburyi\n'
-                  'jalaycalmp\n'
-                  'clojurermt')
-        self.example = WordSearch(puzzle)
+    def setUpClass(cls):
+        puzzle = ['jefblpepre',
+                  'camdcimgtc',
+                  'oivokprjsm',
+                  'pbwasqroua',
+                  'rixilelhrs',
+                  'wolcqlirpc',
+                  'screeaumgr',
+                  'alxhpburyi',
+                  'jalaycalmp',
+                  'clojurermt']
+        cls.example = WordSearch(puzzle)
 
     def test_horizontal_words_different_directions(self):
         self.assertEqual(