trackler 2.2.1.107 → 2.2.1.108

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

@@ -41,7 +41,7 @@ class Tree(object):
             tree.children.append(child.remove(node))
         return tree
 
-    def fromPov(self, from_node):
+    def from_pov(self, from_node):
         stack = [self]
         visited = set()
         while stack:
@@ -55,8 +55,8 @@ class Tree(object):
                 stack.append(child.add(tree.remove(child.label)))
         raise ValueError("Tree could not be reoriented")
 
-    def pathTo(self, from_node, to_node):
-        reordered = self.fromPov(from_node)
+    def path_to(self, from_node, to_node):
+        reordered = self.from_pov(from_node)
         stack = reordered.children
         path = [from_node]
         while path[-1] != to_node:

data/tracks/python/exercises/pov/pov.py

@@ -18,8 +18,8 @@ class Tree(object):
     def __eq__(self, other):
         return self.__dict__() == other.__dict__()
 
-    def fromPov(self, from_node):
+    def from_pov(self, from_node):
         pass
 
-    def pathTo(self, from_node, to_node):
+    def path_to(self, from_node, to_node):
         pass

data/tracks/python/exercises/pov/pov_test.py

@@ -3,16 +3,13 @@ import unittest
 from pov import Tree
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.1
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.2.0
 
 class PovTest(unittest.TestCase):
-    def assertTreeEquals(self, result, expected):
-        self.assertEqual(result, expected,
-                         '{} != {}'.format(result, expected))
 
     def test_singleton_returns_same_tree(self):
         tree = Tree('x')
-        self.assertTreeEquals(tree.fromPov('x'), tree)
+        self.assertTreeEquals(tree.from_pov('x'), tree)
 
     def test_can_reroot_tree_with_parent_and_one_sibling(self):
         tree = Tree('parent', [
@@ -24,7 +21,7 @@ class PovTest(unittest.TestCase):
                 Tree('sibling')
             ])
         ])
-        self.assertTreeEquals(tree.fromPov('x'), expected)
+        self.assertTreeEquals(tree.from_pov('x'), expected)
 
     def test_can_reroot_tree_with_parent_and_many_siblings(self):
         tree = Tree('parent', [
@@ -40,7 +37,7 @@ class PovTest(unittest.TestCase):
                 Tree('c')
             ])
         ])
-        self.assertTreeEquals(tree.fromPov('x'), expected)
+        self.assertTreeEquals(tree.from_pov('x'), expected)
 
     def test_can_reroot_a_tree_with_new_root_deeply_nested(self):
         tree = Tree('level-0', [
@@ -61,7 +58,7 @@ class PovTest(unittest.TestCase):
                 ])
             ])
         ])
-        self.assertTreeEquals(tree.fromPov('x'), expected)
+        self.assertTreeEquals(tree.from_pov('x'), expected)
 
     def test_moves_children_of_new_root_to_same_level_as_former_parent(self):
         tree = Tree('parent', [
@@ -75,7 +72,7 @@ class PovTest(unittest.TestCase):
             Tree('kid-0'),
             Tree('kid-1')
         ])
-        self.assertTreeEquals(tree.fromPov('x'), expected)
+        self.assertTreeEquals(tree.from_pov('x'), expected)
 
     def test_can_reroot_complex_tree_with_cousins(self):
         tree = Tree('grandparent', [
@@ -106,12 +103,12 @@ class PovTest(unittest.TestCase):
                 ])
             ])
         ])
-        self.assertTreeEquals(tree.fromPov('x'), expected)
+        self.assertTreeEquals(tree.from_pov('x'), expected)
 
     def test_errors_if_target_does_not_exist_in_singleton_tree(self):
         tree = Tree('x')
         with self.assertRaisesWithMessage(ValueError):
-            tree.fromPov('nonexistent')
+            tree.from_pov('nonexistent')
 
     def test_errors_if_target_does_not_exist_in_large_tree(self):
         tree = Tree('parent', [
@@ -123,7 +120,7 @@ class PovTest(unittest.TestCase):
             Tree('sibling-1')
         ])
         with self.assertRaisesWithMessage(ValueError):
-            tree.fromPov('nonexistent')
+            tree.from_pov('nonexistent')
 
     def test_find_path_between_two_nodes(self):
         tree = Tree('parent', [
@@ -131,7 +128,7 @@ class PovTest(unittest.TestCase):
             Tree('sibling')
         ])
         expected = ['x', 'parent']
-        self.assertEqual(tree.pathTo('x', 'parent'), expected)
+        self.assertEqual(tree.path_to('x', 'parent'), expected)
 
     def test_can_find_path_to_sibling(self):
         tree = Tree('parent', [
@@ -141,7 +138,7 @@ class PovTest(unittest.TestCase):
             Tree('c')
         ])
         expected = ['x', 'parent', 'b']
-        self.assertEqual(tree.pathTo('x', 'b'), expected)
+        self.assertEqual(tree.path_to('x', 'b'), expected)
 
     def test_can_find_path_to_cousin(self):
         tree = Tree('grandparent', [
@@ -159,7 +156,7 @@ class PovTest(unittest.TestCase):
             ])
         ])
         expected = ['x', 'parent', 'grandparent', 'uncle', 'cousin-1']
-        self.assertEqual(tree.pathTo('x', 'cousin-1'), expected)
+        self.assertEqual(tree.path_to('x', 'cousin-1'), expected)
 
     def test_can_find_path_from_nodes_other_than_x(self):
         tree = Tree('parent', [
@@ -169,7 +166,7 @@ class PovTest(unittest.TestCase):
             Tree('c')
         ])
         expected = ['a', 'parent', 'c']
-        self.assertEqual(tree.pathTo('a', 'c'), expected)
+        self.assertEqual(tree.path_to('a', 'c'), expected)
 
     def test_errors_if_destination_does_not_exist(self):
         tree = Tree('parent', [
@@ -181,7 +178,7 @@ class PovTest(unittest.TestCase):
             Tree('sibling-1')
         ])
         with self.assertRaisesWithMessage(ValueError):
-            tree.pathTo('x', 'nonexistent')
+            tree.path_to('x', 'nonexistent')
 
     def test_errors_if_source_does_not_exist(self):
         tree = Tree('parent', [
@@ -193,7 +190,7 @@ class PovTest(unittest.TestCase):
             Tree('sibling-1')
         ])
         with self.assertRaisesWithMessage(ValueError):
-            tree.pathTo('nonexistent', 'x')
+            tree.path_to('nonexistent', 'x')
 
     # Utility functions
     def setUp(self):
@@ -205,6 +202,10 @@ class PovTest(unittest.TestCase):
     def assertRaisesWithMessage(self, exception):
         return self.assertRaisesRegex(exception, r".+")
 
+    def assertTreeEquals(self, result, expected):
+        self.assertEqual(result, expected,
+                         '{} != {}'.format(result, expected))
+
 
 if __name__ == '__main__':
     unittest.main()

data/tracks/python/exercises/protein-translation/protein_translation_test.py

@@ -3,77 +3,67 @@ import unittest
 from protein_translation import proteins
 
 
-# Tests adapted from problem-specifications/canonical-data.json @ v1.0.0
+# Tests adapted from problem-specifications/canonical-data.json @ v1.1.0
 
 class ProteinTranslationTests(unittest.TestCase):
 
     def test_AUG_translates_to_methionine(self):
-        self.assertEqual(['Methionine'], proteins('AUG'))
+        self.assertEqual(proteins('AUG'), ['Methionine'])
 
     def test_identifies_Phenylalanine_codons(self):
         for codon in ['UUU', 'UUC']:
-            self.assertEqual(['Phenylalanine'], proteins(codon))
+            self.assertEqual(proteins(codon), ['Phenylalanine'])
 
     def test_identifies_Leucine_codons(self):
         for codon in ['UUA', 'UUG']:
-            self.assertEqual(['Leucine'], proteins(codon))
+            self.assertEqual(proteins(codon), ['Leucine'])
 
     def test_identifies_Serine_codons(self):
         for codon in ['UCU', 'UCC', 'UCA', 'UCG']:
-            self.assertEqual(['Serine'], proteins(codon))
+            self.assertEqual(proteins(codon), ['Serine'])
 
     def test_identifies_Tyrosine_codons(self):
         for codon in ['UAU', 'UAC']:
-            self.assertEqual(['Tyrosine'], proteins(codon))
+            self.assertEqual(proteins(codon), ['Tyrosine'])
 
     def test_identifies_Cysteine_codons(self):
         for codon in ['UGU', 'UGC']:
-            self.assertEqual(['Cysteine'], proteins(codon))
+            self.assertEqual(proteins(codon), ['Cysteine'])
 
     def test_identifies_Tryptophan_codons(self):
-        self.assertEqual(['Tryptophan'], proteins('UGG'))
+        self.assertEqual(proteins('UGG'), ['Tryptophan'])
 
     def test_identifies_stop_codons(self):
         for codon in ['UAA', 'UAG', 'UGA']:
-            self.assertEqual([], proteins(codon))
+            self.assertEqual(proteins(codon), [])
 
     def test_translates_rna_strand_into_correct_protein_list(self):
         strand = 'AUGUUUUGG'
         expected = ['Methionine', 'Phenylalanine', 'Tryptophan']
-        self.assertEqual(expected, proteins(strand))
+        self.assertEqual(proteins(strand), expected)
 
     def test_stops_translation_if_stop_codon_at_beginning_of_sequence(self):
         strand = 'UAGUGG'
         expected = []
-        self.assertEqual(expected, proteins(strand))
+        self.assertEqual(proteins(strand), expected)
 
     def test_stops_translation_if_stop_codon_at_end_of_two_codon_sequence(
             self):
         strand = 'UGGUAG'
         expected = ['Tryptophan']
-        self.assertEqual(expected, proteins(strand))
+        self.assertEqual(proteins(strand), expected)
 
     def test_stops_translation_if_stop_codon_at_end_of_three_codon_sequence(
             self):
         strand = 'AUGUUUUAA'
         expected = ['Methionine', 'Phenylalanine']
-        self.assertEqual(expected, proteins(strand))
+        self.assertEqual(proteins(strand), expected)
 
     def test_stops_translation_if_stop_codon_in_middle_of_six_codon_sequence(
             self):
         strand = 'UGGUGUUAUUAAUGGUUU'
         expected = ['Tryptophan', 'Cysteine', 'Tyrosine']
-        self.assertEqual(expected, proteins(strand))
-
-    # Utility functions
-    def setUp(self):
-        try:
-            self.assertRaisesRegex
-        except AttributeError:
-            self.assertRaisesRegex = self.assertRaisesRegexp
-
-    def assertRaisesWithMessage(self, exception):
-        return self.assertRaisesRegex(exception, r".+")
+        self.assertEqual(proteins(strand), expected)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/rail-fence-cipher/rail_fence_cipher_test.py

@@ -3,7 +3,7 @@ import unittest
 from rail_fence_cipher import encode, decode
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.1
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
 
 class RailFenceTests(unittest.TestCase):
     def test_encode_with_two_rails(self):

data/tracks/python/exercises/rational-numbers/README.md

@@ -0,0 +1,59 @@
+# Rational Numbers
+
+A rational number is defined as the quotient of two integers `a` and `b`, called the numerator and denominator, respectively, where `b != 0`.
+
+The absolute value `|r|` of the rational number `r = a/b` is equal to `|a|/|b|`.
+
+The sum of two rational numbers `r1 = a1/b1` and `r2 = a2/b2` is `r1 + r2 = a1/b1 + a2/b2 = (a1 * b2 + a2 * b1) / (b1 * b2)`.
+
+The difference of two rational numbers `r1 = a1/b1` and `r2 = a2/b2` is `r1 - r2 = a1/b1 - a2/b2 = (a1 * b2 - a2 * b1) / (b1 * b2)`.
+
+The product (multiplication) of two rational numbers `r1 = a1/b1` and `r2 = a2/b2` is `r1 * r2 = (a1 * a2) / (b1 * b2)`.
+
+Dividing a rational number `r1 = a1/b1` by another `r2 = a2/b2` is `r1 / r2 = (a1 * b2) / (a2 * b1)` if `a2 * b1` is not zero.
+
+Exponentiation of a rational number `r = a/b` to a non-negative integer power `n` is `r^n = (a^n)/(b^n)`.
+
+Exponentiation of a rational number `r = a/b` to a negative integer power `n` is `r^n = (b^m)/(a^m)`, where `m = |n|`.
+
+Exponentiation of a rational number `r = a/b` to a real (floating-point) number `x` is the quotient `(a^x)/(b^x)`, which is a real number.
+
+Exponentiation of a real number `x` to a rational number `r = a/b` is `x^(a/b) = root(x^a, b)`, where `root(p, q)` is the `q`th root of `p`.
+
+Implement the following operations:
+ - addition, subtraction, multiplication and division of two rational numbers,
+ - absolute value, exponentiation of a given rational number to an integer power, exponentiation of a given rational number to a real (floating-point) power, exponentiation of a real number to a rational number.
+
+Your implementation of rational numbers should always be reduced to lowest terms. For example, `4/4` should reduce to `1/1`, `30/60` should reduce to `1/2`, `12/8` should reduce to `3/2`, etc. To reduce a rational number `r = a/b`, divide `a` and `b` by the greatest common divisor (gcd) of `a` and `b`. So, for example, `gcd(12, 8) = 4`, so `r = 12/8` can be reduced to `(12/4)/(8/4) = 3/2`.
+
+Assume that the programming language you are using does not have an implementation of rational numbers.
+
+## Exception messages
+
+Sometimes it is necessary to raise an exception. When you do this, you should include a meaningful error message to
+indicate what the source of the error is. This makes your code more readable and helps significantly with debugging. Not
+every exercise will require you to raise an exception, but for those that do, the tests will only pass if you include
+a message.
+
+To raise a message with an exception, just write it as an argument to the exception type. For example, instead of
+`raise Exception`, you shold write:
+
+```python
+raise Exception("Meaningful message indicating the source of the error")
+```
+
+## Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the solution is in the `$EXERCISM_WORKSPACE/python/rational-numbers` directory.
+
+You can find your Exercism workspace by running `exercism debug` and looking for the line that starts with `Workspace`.
+
+For more detailed information about running tests, code style and linting,
+please see the [help page](http://exercism.io/languages/python).
+
+## Source
+
+Wikipedia [https://en.wikipedia.org/wiki/Rational_number](https://en.wikipedia.org/wiki/Rational_number)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/python/exercises/rational-numbers/example.py

@@ -0,0 +1,58 @@
+from __future__ import division
+
+from fractions import gcd
+
+
+class Rational(object):
+    """
+    Toyish implementation of rational numbers. For production purpose,
+    please use `fractions.Fraction` in standard library instead.
+    """
+    def __init__(self, numer, denom):
+        self.numer, self.denom = self._reduce(numer, denom)
+
+    def _reduce(self, numer, denom):
+        if numer == 0:
+            n, d = 0, 1
+        else:
+            g = gcd(numer, denom)
+            n, d = int(numer/g), int(denom/g)
+            if n > 0 and d < 0:
+                n, d = -n, -d
+        return n, d
+
+    def __eq__(self, other):
+        return self.numer == other.numer and self.denom == other.denom
+
+    def __repr__(self):
+        return '{}/{}'.format(self.numer, self.denom)
+
+    def __add__(self, other):
+        return Rational(
+            self.numer*other.denom + self.denom*other.numer,
+            self.denom*other.denom
+        )
+
+    def __sub__(self, other):
+        return Rational(
+            self.numer*other.denom - self.denom*other.numer,
+            self.denom*other.denom
+        )
+
+    def __mul__(self, other):
+        return Rational(self.numer * other.numer, self.denom * other.denom)
+
+    def __truediv__(self, other):
+        return Rational(self.numer * other.denom, self.denom * other.numer)
+
+    def __abs__(self):
+        if self.numer >= 0:
+            return self
+        else:
+            return Rational(-self.numer, self.denom)
+
+    def __pow__(self, power):
+        return Rational(self.numer ** power, self.denom ** power)
+
+    def __rpow__(self, base):
+        return base ** (self.numer / self.denom)

data/tracks/python/exercises/rational-numbers/rational_numbers.py

@@ -0,0 +1,34 @@
+from __future__ import division
+
+
+class Rational(object):
+    def __init__(self, numer, denom):
+        self.numer = None
+        self.denom = None
+
+    def __eq__(self, other):
+        return self.numer == other.numer and self.denom == other.denom
+
+    def __repr__(self):
+        return '{}/{}'.format(self.numer, self.denom)
+
+    def __add__(self, other):
+        pass
+
+    def __sub__(self, other):
+        pass
+
+    def __mul__(self, other):
+        pass
+
+    def __truediv__(self, other):
+        pass
+
+    def __abs__(self):
+        pass
+
+    def __pow__(self, power):
+        pass
+
+    def __rpow__(self, base):
+        pass

data/tracks/python/exercises/rational-numbers/rational_numbers_test.py

@@ -0,0 +1,132 @@
+from __future__ import division
+
+import unittest
+
+from rational_numbers import Rational
+
+
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+
+class RationalTests(unittest.TestCase):
+
+    # Test addition
+    def test_add_two_positive(self):
+        self.assertEqual(Rational(1, 2) + Rational(2, 3), Rational(7, 6))
+
+    def test_add_positive_and_negative(self):
+        self.assertEqual(Rational(1, 2) + Rational(-2, 3), Rational(-1, 6))
+
+    def test_add_two_negative(self):
+        self.assertEqual(Rational(-1, 2) + Rational(-2, 3), Rational(-7, 6))
+
+    def test_add_opposite(self):
+        self.assertEqual(Rational(1, 2) + Rational(-1, 2), Rational(0, 1))
+
+    # Test subtraction
+    def test_subtract_two_positive(self):
+        self.assertEqual(Rational(1, 2) - Rational(2, 3), Rational(-1, 6))
+
+    def test_subtract_positive_and_negative(self):
+        self.assertEqual(Rational(1, 2) - Rational(-2, 3), Rational(7, 6))
+
+    def test_subtract_two_negative(self):
+        self.assertEqual(Rational(-1, 2) - Rational(-2, 3), Rational(1, 6))
+
+    def test_subtract_from_self(self):
+        self.assertEqual(Rational(1, 2) - Rational(1, 2), Rational(0, 1))
+
+    # Test multiplication
+    def test_multiply_two_positive(self):
+        self.assertEqual(Rational(1, 2) * Rational(2, 3), Rational(1, 3))
+
+    def test_multiply_negative_by_positive(self):
+        self.assertEqual(Rational(-1, 2) * Rational(2, 3), Rational(-1, 3))
+
+    def test_multiply_two_negative(self):
+        self.assertEqual(Rational(-1, 2) * Rational(-2, 3), Rational(1, 3))
+
+    def test_multiply_reciprocal(self):
+        self.assertEqual(Rational(1, 2) * Rational(2, 1), Rational(1, 1))
+
+    def test_multiply_by_one(self):
+        self.assertEqual(Rational(1, 2) * Rational(1, 1), Rational(1, 2))
+
+    def test_multiply_by_zero(self):
+        self.assertEqual(Rational(1, 2) * Rational(0, 1), Rational(0, 1))
+
+    # Test division
+    def test_divide_two_positive(self):
+        self.assertEqual(Rational(1, 2) / Rational(2, 3), Rational(3, 4))
+
+    def test_divide_positive_by_negative(self):
+        self.assertEqual(Rational(1, 2) / Rational(-2, 3), Rational(-3, 4))
+
+    def test_divide_two_negative(self):
+        self.assertEqual(Rational(-1, 2) / Rational(-2, 3), Rational(3, 4))
+
+    def test_divide_by_one(self):
+        self.assertEqual(Rational(1, 2) / Rational(1, 1), Rational(1, 2))
+
+    # Test absolute value
+    def test_absolute_value_of_positive(self):
+        self.assertEqual(abs(Rational(1, 2)), Rational(1, 2))
+
+    def test_absolute_value_of_negative(self):
+        self.assertEqual(abs(Rational(-1, 2)), Rational(1, 2))
+
+    def test_absolute_value_of_zero(self):
+        self.assertEqual(abs(Rational(0, 1)), Rational(0, 1))
+
+    # Test exponentiation of a rational number
+    def test_raise_a_positive_rational_to_a_positive_integer_power(self):
+        self.assertEqual(Rational(1, 2) ** 3, Rational(1, 8))
+
+    def test_raise_a_negative_rational_to_a_positive_integer_power(self):
+        self.assertEqual(Rational(-1, 2) ** 3, Rational(-1, 8))
+
+    def test_raise_zero_to_an_integer_power(self):
+        self.assertEqual(Rational(0, 1) ** 5, Rational(0, 1))
+
+    def test_raise_one_to_an_integer_power(self):
+        self.assertEqual(Rational(1, 1) ** 4, Rational(1, 1))
+
+    def test_raise_a_positive_rational_to_the_power_of_zero(self):
+        self.assertEqual(Rational(1, 2) ** 0, Rational(1, 1))
+
+    def test_raise_a_negative_rational_to_the_power_of_zero(self):
+        self.assertEqual(Rational(-1, 2) ** 0, Rational(1, 1))
+
+    # Test exponentiation of a real number to a rational number
+    def test_raise_a_real_number_to_a_positive_rational(self):
+        self.assertAlmostEqual(8 ** Rational(4, 3), 16.0, places=8)
+
+    def test_raise_a_real_number_to_a_negative_rational(self):
+        self.assertAlmostEqual(
+            9 ** Rational(-1, 2), 0.3333333333333333, places=8
+        )
+
+    def test_raise_a_real_number_to_a_zero_rational(self):
+        self.assertAlmostEqual(2 ** Rational(0, 1), 1.0, places=8)
+
+    # Test reduction to lowest terms
+    def test_reduce_positive(self):
+        self.assertEqual(Rational(2, 4), Rational(1, 2))
+
+    def test_reduce_negative(self):
+        self.assertEqual(Rational(-4, 6), Rational(-2, 3))
+
+    def test_reduce_rational_with_negative_denominator(self):
+        self.assertEqual(Rational(3, -9), Rational(-1, 3))
+
+    def test_reduce_zero(self):
+        self.assertEqual(Rational(0, 6), Rational(0, 1))
+
+    def test_reduce_integer(self):
+        self.assertEqual(Rational(-14, 7), Rational(-2, 1))
+
+    def test_reduce_one(self):
+        self.assertEqual(Rational(13, 13), Rational(1, 1))
+
+
+if __name__ == '__main__':
+    unittest.main()