trackler 2.2.1.87 → 2.2.1.88

data/tracks/java/exercises/rna-transcription/src/test/java/RnaTranscriptionTest.java

@@ -1,16 +1,11 @@
 import org.junit.Before;
 import org.junit.Ignore;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 import static org.junit.Assert.assertEquals;
 
 public class RnaTranscriptionTest {
 
-    @Rule
-    public ExpectedException expectedException = ExpectedException.none();
-
     private RnaTranscription rnaTranscription;
 
     @Before
@@ -47,28 +42,4 @@ public class RnaTranscriptionTest {
         assertEquals("UGCACCAGAAUU", rnaTranscription.transcribe("ACGTGGTCTTAA"));
     }
 
-    @Ignore("Remove to run test")
-    @Test
-    public void testRnaTranscriptionOfRnaThrowsAnError() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Invalid input");
-        rnaTranscription.transcribe("U");
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void testRnaTranscriptionOfInvalidInputThrowsAnError() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Invalid input");
-        rnaTranscription.transcribe("XXX");
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void testRnaTranscriptionOfPartiallyInvalidInput() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Invalid input");
-        rnaTranscription.transcribe("ACGTXXXCTTAA");
-    }
-
 }

data/tracks/python/.travis.yml

@@ -19,8 +19,8 @@ install:
 
 before_script:
   - flake8
-
-script:
   - ./bin/fetch-configlet
   - ./bin/configlet lint .
+
+script:
   - ./test/check-exercises.py

data/tracks/python/exercises/complex-numbers/.meta/hints.md

@@ -0,0 +1,3 @@
+## Hints
+
+See [Emulating numeric types](https://docs.python.org/2/reference/datamodel.html#emulating-numeric-types) for help on operator overloading.

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

@@ -31,6 +31,10 @@ Implement the following operations:
 
 Assume the programming language you are using does not have an implementation of complex numbers.
 
+## Hints
+
+See [Emulating numeric types](https://docs.python.org/2/reference/datamodel.html#emulating-numeric-types) for help on operator overloading.
+
 ## Exception messages
 
 Sometimes it is necessary to raise an exception. When you do this, you should include a meaningful error message to

data/tracks/python/exercises/complex-numbers/complex_numbers.py

@@ -2,19 +2,19 @@ class ComplexNumber(object):
     def __init__(self, real, imaginary):
         pass
 
-    def add(self, other):
+    def __add__(self, other):
         pass
 
-    def mul(self, other):
+    def __mul__(self, other):
         pass
 
-    def sub(self, other):
+    def __sub__(self, other):
         pass
 
-    def div(self, other):
+    def __truediv__(self, other):
         pass
 
-    def abs(self):
+    def __abs__(self):
         pass
 
     def conjugate(self):

data/tracks/python/exercises/complex-numbers/complex_numbers_test.py

@@ -1,3 +1,5 @@
+from __future__ import division
+
 import unittest
 
 import math
@@ -13,95 +15,89 @@ class ComplexNumbersTest(unittest.TestCase):
     def test_add_purely_real_numbers(self):
         first_input = ComplexNumber(1, 0)
         second_input = ComplexNumber(2, 0)
-        self.assertEqual(first_input.add(second_input).real, 3)
-        self.assertEqual(first_input.add(second_input).imaginary, 0)
+        expected = ComplexNumber(3, 0)
+        self.assertEqual(first_input + second_input, expected)
 
     def test_add_purely_imaginary_numbers(self):
         first_input = ComplexNumber(0, 1)
         second_input = ComplexNumber(0, 2)
-        self.assertEqual(first_input.add(second_input).real, 0)
-        self.assertEqual(first_input.add(second_input).imaginary, 3)
+        expected = ComplexNumber(0, 3)
+        self.assertEqual(first_input + second_input, expected)
 
     def test_add_numbers_with_real_and_imaginary_part(self):
         first_input = ComplexNumber(1, 2)
         second_input = ComplexNumber(3, 4)
-        self.assertEqual(first_input.add(second_input).real, 4)
-        self.assertEqual(first_input.add(second_input).imaginary, 6)
+        expected = ComplexNumber(4, 6)
+        self.assertEqual(first_input + second_input, expected)
 
     def test_subtract_purely_real_numbers(self):
         first_input = ComplexNumber(1, 0)
         second_input = ComplexNumber(2, 0)
-        self.assertEqual(first_input.sub(second_input).real, -1)
-        self.assertEqual(first_input.sub(second_input).imaginary, 0)
+        expected = ComplexNumber(-1, 0)
+        self.assertEqual(first_input - second_input, expected)
 
     def test_subtract_purely_imaginary_numbers(self):
         first_input = ComplexNumber(0, 1)
         second_input = ComplexNumber(0, 2)
-        self.assertEqual(first_input.sub(second_input).real, 0)
-        self.assertEqual(first_input.sub(second_input).imaginary, -1)
+        expected = ComplexNumber(0, -1)
+        self.assertEqual(first_input - second_input, expected)
 
     def test_subtract_numbers_with_real_and_imaginary_part(self):
         first_input = ComplexNumber(1, 2)
         second_input = ComplexNumber(3, 4)
-        self.assertEqual(first_input.sub(second_input).real, -2)
-        self.assertEqual(first_input.sub(second_input).imaginary, -2)
+        expected = ComplexNumber(-2, -2)
+        self.assertEqual(first_input - second_input, expected)
 
     def test_multiply_purely_real_numbers(self):
         first_input = ComplexNumber(1, 0)
         second_input = ComplexNumber(2, 0)
-        self.assertEqual(first_input.mul(second_input).real, 2)
-        self.assertEqual(first_input.mul(second_input).imaginary, 0)
+        expected = ComplexNumber(2, 0)
+        self.assertEqual(first_input * second_input, expected)
 
     def test_multiply_purely_imaginary_numbers(self):
         first_input = ComplexNumber(0, 1)
         second_input = ComplexNumber(0, 2)
-        self.assertEqual(first_input.mul(second_input).real, -2)
-        self.assertEqual(first_input.mul(second_input).imaginary, 0)
+        expected = ComplexNumber(-2, 0)
+        self.assertEqual(first_input * second_input, expected)
 
     def test_multiply_numbers_with_real_and_imaginary_part(self):
         first_input = ComplexNumber(1, 2)
         second_input = ComplexNumber(3, 4)
-        self.assertEqual(first_input.mul(second_input).real, -5)
-        self.assertEqual(first_input.mul(second_input).imaginary, 10)
+        expected = ComplexNumber(-5, 10)
+        self.assertEqual(first_input * second_input, expected)
 
     def test_divide_purely_real_numbers(self):
         input_number = ComplexNumber(1.0, 0.0)
         expected = ComplexNumber(0.5, 0.0)
         divider = ComplexNumber(2.0, 0.0)
-        self.assertEqual(input_number.div(divider).real, expected.real)
-        self.assertEqual(input_number.div(divider).imaginary,
-                         expected.imaginary)
+        self.assertEqual(input_number / divider, expected)
 
     def test_divide_purely_imaginary_numbers(self):
         input_number = ComplexNumber(0, 1)
         expected = ComplexNumber(0.5, 0)
         divider = ComplexNumber(0, 2)
-        self.assertEqual(input_number.div(divider).real, expected.real)
-        self.assertEqual(input_number.div(divider).imaginary,
-                         expected.imaginary)
+        self.assertEqual(input_number / divider, expected)
 
     def test_divide_numbers_with_real_and_imaginary_part(self):
         input_number = ComplexNumber(1, 2)
         expected = ComplexNumber(0.44, 0.08)
         divider = ComplexNumber(3, 4)
-        self.assertEqual(input_number.div(divider).real, expected.real)
-        self.assertEqual(input_number.div(divider).imaginary,
-                         expected.imaginary)
+        self.assertEqual(input_number / divider, expected)
 
     def test_absolute_value_of_a_positive_purely_real_number(self):
-        self.assertEqual(ComplexNumber(5, 0).abs(), 5)
+        self.assertEqual(abs(ComplexNumber(5, 0)), 5)
 
     def test_absolute_value_of_a_negative_purely_real_number(self):
-        self.assertEqual(ComplexNumber(-5, 0).abs(), 5)
+        self.assertEqual(abs(ComplexNumber(-5, 0)), 5)
 
     def test_absolute_value_of_imaginary_number_positive_imaginary_part(self):
-        self.assertEqual(ComplexNumber(0, 5).abs(), 5)
+        self.assertEqual(abs(ComplexNumber(0, 5)), 5)
 
     def test_absolute_value_of_imaginary_number_negative_imaginary_part(self):
-        self.assertEqual(ComplexNumber(0, -5).abs(), 5)
+        self.assertEqual(abs(ComplexNumber(0, -5)), 5)
 
     def test_absolute_value_of_a_number_with_real_and_imaginary_part(self):
-        self.assertEqual(ComplexNumber(3, 4).abs(), 5)
+        self.assertEqual(abs(ComplexNumber(3, 4)), 5)
 
     def test_conjugate_a_purely_real_number(self):
         input_number = ComplexNumber(5, 0)

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

@@ -6,22 +6,25 @@ class ComplexNumber(object):
         self.real = real
         self.imaginary = imaginary
 
-    def add(self, other):
+    def __eq__(self, other):
+        return self.real == other.real and self.imaginary == other.imaginary
+
+    def __add__(self, other):
         r = self.real + other.real
         i = self.imaginary + other.imaginary
         return ComplexNumber(r, i)
 
-    def mul(self, other):
+    def __mul__(self, other):
         r = self.real * other.real - self.imaginary * other.imaginary
         i = self.real * other.imaginary + self.imaginary * other.real
         return ComplexNumber(r, i)
 
-    def sub(self, other):
+    def __sub__(self, other):
         r = self.real - other.real
         i = self.imaginary - other.imaginary
         return ComplexNumber(r, i)
 
-    def div(self, other):
+    def __truediv__(self, other):
         d = other.real * other.real + other.imaginary * other.imaginary
         r = (self.real * other.real + self.imaginary *
              other.imaginary) / float(d)
@@ -29,7 +32,7 @@ class ComplexNumber(object):
              self.real * other.imaginary) / float(d)
         return ComplexNumber(r, i)
 
-    def abs(self):
+    def __abs__(self):
         square_sum = self.real * self.real + self.imaginary * self.imaginary
         return math.sqrt(square_sum)
 

data/tracks/python/exercises/difference-of-squares/difference_of_squares.py

@@ -1,10 +1,10 @@
-def square_of_sum():
+def square_of_sum(count):
     pass
 
 
-def sum_of_squares():
+def sum_of_squares(count):
     pass
 
 
-def difference():
+def difference(count):
     pass

data/tracks/python/exercises/difference-of-squares/example.py

@@ -1,11 +1,11 @@
-def square_of_sum(n):
-    sum_ = n * (n + 1) / 2
+def square_of_sum(count):
+    sum_ = count * (count + 1) / 2
     return sum_ * sum_
 
 
-def sum_of_squares(n):
-    return sum(m * m for m in range(n + 1))
+def sum_of_squares(count):
+    return sum(m * m for m in range(count + 1))
 
 
-def difference(n):
-    return square_of_sum(n) - sum_of_squares(n)
+def difference(count):
+    return square_of_sum(count) - sum_of_squares(count)

data/tracks/python/exercises/palindrome-products/example.py

@@ -1,18 +1,119 @@
-def largest_palindrome(max_factor, min_factor=0):
-    return max(palindromes(max_factor, min_factor), key=lambda tup: tup[0])
+from __future__ import division
+from itertools import chain
+from math import log10, floor, ceil
+
+
+def largest_palindrome(max_factor, min_factor):
+    return get_extreme_palindrome_with_factors(max_factor, min_factor,
+                                               "largest")
 
 
 def smallest_palindrome(max_factor, min_factor):
-    return min(palindromes(max_factor, min_factor), key=lambda tup: tup[0])
+    return get_extreme_palindrome_with_factors(max_factor, min_factor,
+                                               "smallest")
+
+
+def get_extreme_palindrome_with_factors(max_factor, min_factor, extreme):
+    palindromes_found = palindromes(max_factor, min_factor,
+                                    reverse=(extreme == "largest"))
+    factor_pairs = None
+    for palin in palindromes_found:
+        factor_pairs = ((fact, palin // fact)
+                        for fact in range(min_factor, max_factor + 1)
+                        if palin % fact == 0)
+        factor_pairs = list(pair for pair in factor_pairs
+                            if min_factor <= pair[1] <= max_factor)
+        if len(factor_pairs) > 0:
+            break
+
+    if factor_pairs is None or len(factor_pairs) == 0:
+        raise ValueError("no palindrome with factors in the "
+                         "range {min_factor} to {max_factor}"
+                         .format(min_factor=min_factor,
+                                 max_factor=max_factor))
+
+    return (palin, factor_pairs)
+
+
+def reverse_num(n):
+    rev = 0
+    while n > 0:
+        rev *= 10
+        rev += (n % 10)
+        n //= 10
+    return rev
+
+
+def num_digits(n):
+    return int(floor(log10(n) + 1))
+
+
+def palindromes(max_factor, min_factor, reverse=False):
+    """Generates all palindromes between `min_factor`**2 and max_factor`**2
+
+    If `reverse` is True, will produce the palindromes in decreasing order,
+    from `max_factor`**2 down to `min_factor`**2. This is needed for
+    `largest_palindrome`, since it won't have to iterate through a
+    most of the palindromes just to find the one it needs.
+    """
+    if max_factor < min_factor:
+        raise ValueError("invalid input: min is {min_factor} "
+                         "and max is {max_factor}"
+                         .format(min_factor=min_factor,
+                                 max_factor=max_factor))
+
+    minimum = min_factor ** 2
+    maximum = max_factor ** 2
+
+    def gen_palins_of_length(nd, reverse=reverse):
+        """Generates all palindromes with `nd` number of digits that are
+        within the desired range.
+
+        Again, if `reverse` is True, the palindromes are generated in
+        reverse order.
+        """
+        even_nd = (nd % 2 == 0)
+
+        min_left_half = max(10 ** (int(ceil(nd / 2)) - 1),
+                            minimum // (10 ** (nd // 2)))
+        max_left_half = min((10 ** int(ceil(nd / 2))) - 1,
+                            maximum // (10 ** (nd // 2)))
+
+        current_left_half = min_left_half if not reverse else max_left_half
+
+        def make_palindrome(left_half, even_nd=False):
+            right_half = (reverse_num(left_half)
+                          if even_nd
+                          else reverse_num(left_half // 10))
+            return (left_half * (10 ** (nd // 2))) + right_half
 
+        if not reverse:
+            while current_left_half <= max_left_half:
+                palin = make_palindrome(current_left_half, even_nd)
+                if minimum <= palin <= maximum:
+                    yield palin
+                elif palin > maximum:
+                    # since palindromes are generated in increasing order,
+                    #   we break out of the loop once we've exceeded the
+                    #   maximum value
+                    break
+                current_left_half += 1
+        else:
+            while current_left_half >= min_left_half:
+                palin = make_palindrome(current_left_half, even_nd)
+                if minimum <= palin <= maximum:
+                    yield palin
+                elif palin < minimum:
+                    # since palindromes are generated in decreasing order,
+                    #   we break out of the loop once we've gone below the
+                    #   minimum value
+                    break
+                current_left_half -= 1
 
-def palindromes(max_factor, min_factor):
-    return ((a * b, (a, b))
-            for a in range(min_factor, max_factor + 1)
-            for b in range(min_factor, a + 1)
-            if is_palindrome(a * b))
+    min_nd, max_nd = num_digits(minimum), num_digits(maximum)
 
+    lengths = (range(min_nd, max_nd + 1)
+               if not reverse
+               else range(max_nd, min_nd - 1, -1))
 
-def is_palindrome(n):
-    s = str(n)
-    return s == s[::-1]
+    return chain(*map(gen_palins_of_length, lengths))

data/tracks/python/exercises/palindrome-products/palindrome_products_test.py

@@ -16,31 +16,72 @@ import unittest
 from palindrome_products import smallest_palindrome, largest_palindrome
 
 
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+
 class PalindromesTests(unittest.TestCase):
+    def test_smallest_palindrome_from_single_digit_factors(self):
+        value, factors = smallest_palindrome(min_factor=1, max_factor=9)
+        self.assertEqual(value, 1)
+        self.assertFactorsEqual(factors, {(1, 1)})
+
     def test_largest_palindrome_from_single_digit_factors(self):
-        value, factors = largest_palindrome(max_factor=9)
+        value, factors = largest_palindrome(min_factor=1, max_factor=9)
         self.assertEqual(value, 9)
-        self.assertIn(set(factors), [{1, 9}, {3, 3}])
+        self.assertFactorsEqual(factors, {(1, 9), (3, 3)})
+
+    def test_smallest_palindrome_from_double_digit_factors(self):
+        value, factors = smallest_palindrome(min_factor=10, max_factor=99)
+        self.assertEqual(value, 121)
+        self.assertFactorsEqual(factors, {(11, 11)})
 
     def test_largest_palindrome_from_double_digit_factors(self):
-        value, factors = largest_palindrome(max_factor=99, min_factor=10)
+        value, factors = largest_palindrome(min_factor=10, max_factor=99)
         self.assertEqual(value, 9009)
-        self.assertEqual(set(factors), {91, 99})
+        self.assertFactorsEqual(factors, {(91, 99)})
 
-    def test_smallest_palindrome_from_double_digit_factors(self):
-        value, factors = smallest_palindrome(max_factor=99, min_factor=10)
-        self.assertEqual(value, 121)
-        self.assertEqual(set(factors), {11})
+    def test_smallest_palindrome_from_triple_digit_factors(self):
+        value, factors = smallest_palindrome(min_factor=100, max_factor=999)
+        self.assertEqual(value, 10201)
+        self.assertFactorsEqual(factors, {(101, 101)})
 
     def test_largest_palindrome_from_triple_digit_factors(self):
-        value, factors = largest_palindrome(max_factor=999, min_factor=100)
+        value, factors = largest_palindrome(min_factor=100, max_factor=999)
         self.assertEqual(value, 906609)
-        self.assertEqual(set(factors), {913, 993})
+        self.assertFactorsEqual(factors, {(913, 993)})
 
-    def test_smallest_palindrome_from_triple_digit_factors(self):
-        value, factors = smallest_palindrome(max_factor=999, min_factor=100)
-        self.assertEqual(value, 10201)
-        self.assertEqual(set(factors), {101, 101})
+    def test_smallest_palindrome_from_four_digit_factors(self):
+        value, factors = smallest_palindrome(min_factor=1000, max_factor=9999)
+        self.assertEqual(value, 1002001)
+        self.assertFactorsEqual(factors, {(1001, 1001)})
+
+    def test_largest_palindrome_from_four_digit_factors(self):
+        value, factors = largest_palindrome(min_factor=1000, max_factor=9999)
+        self.assertEqual(value, 99000099)
+        self.assertFactorsEqual(factors, {(9901, 9999)})
+
+    def test_empty_for_smallest_palindrome_if_none_in_range(self):
+        with self.assertRaises(ValueError):
+            value, factors = smallest_palindrome(min_factor=1002,
+                                                 max_factor=1003)
+
+    def test_empty_for_largest_palindrome_if_none_in_range(self):
+        with self.assertRaises(ValueError):
+            value, factors = largest_palindrome(min_factor=15, max_factor=15)
+
+    def test_error_for_smallest_if_min_is_more_than_max(self):
+        with self.assertRaises(ValueError):
+            value, factors = smallest_palindrome(min_factor=10000,
+                                                 max_factor=1)
+
+    def test_error_for_largest_if_min_is_more_than_max(self):
+        with self.assertRaises(ValueError):
+            value, factors = largest_palindrome(min_factor=2, max_factor=1)
+
+    # Utility methods
+
+    def assertFactorsEqual(self, actual, expected):
+        self.assertEqual(set(map(frozenset, actual)),
+                         set(map(frozenset, expected)))
 
 
 if __name__ == '__main__':