Up to two fer

Author: cglacet

.DS_Store

@@ -80,7 +80,7 @@ Exercises from the main track are:
  - ![#E8C14E](https://placehold.it/10/E8C14E/000000?text=+) [saddle-points](saddle-points) ([_.py solution_](saddle-points/saddle_points.py))
 
 Extra exercises that I think are interesting:
- - ![#E8C14E](https://placehold.it/10/E8C14E/000000?text=+) [bank-account](bank-account) ([_.py solution_](bank-account/bank_account.py)): decorators and errors:
+ - ![#E8C14E](https://placehold.it/10/E8C14E/000000?text=+) [bank-account](bank-account) ([_.py solution_](bank-account/bank_account.py)): concurrency, decorators and errors
  - ![#FF7C63](https://placehold.it/10/FF7C63/000000?text=+) [flatten-array](flatten-array) ([_.py solution_](flatten-array/flatten_array.py)): Python stack discussion (iterative array flattening)
  - ![#E8C14E](https://placehold.it/10/E8C14E/000000?text=+) [binary search tree](binary-search-tree) ([_.py solution_](binary-search-tree/binary_search_tree.py)): basically a simpler version of the array flattening problem (same techniques involved)
  - ![#FF7C63](https://placehold.it/10/FF7C63/000000?text=+) [rectangles](rectangles) ([_.py solution_](rectangles/rectangles.py)): interesting algorithmic problem (if you have a simpler solution I'm interested)

README.md

@@ -0,0 +1 @@
+{}

armstrong-numbers/.pytest_cache/v/cache/lastfailed

@@ -0,0 +1,10 @@
+[
+  "armstrong_numbers_test.py::ArmstrongNumbersTest::test_four_digit_number_that_is_an_armstrong_number",
+  "armstrong_numbers_test.py::ArmstrongNumbersTest::test_four_digit_number_that_is_not_an_armstrong_number",
+  "armstrong_numbers_test.py::ArmstrongNumbersTest::test_seven_digit_number_that_is_an_armstrong_number",
+  "armstrong_numbers_test.py::ArmstrongNumbersTest::test_seven_digit_number_that_is_not_an_armstrong_number",
+  "armstrong_numbers_test.py::ArmstrongNumbersTest::test_single_digit_numbers_are_armstrong_numbers",
+  "armstrong_numbers_test.py::ArmstrongNumbersTest::test_there_are_no_two_digit_armstrong_numbers",
+  "armstrong_numbers_test.py::ArmstrongNumbersTest::test_three_digit_number_that_is_an_armstrong_number",
+  "armstrong_numbers_test.py::ArmstrongNumbersTest::test_three_digit_number_that_is_not_an_armstrong_number"
+]

armstrong-numbers/.pytest_cache/v/cache/nodeids

@@ -0,0 +1 @@
+{"track":"python","exercise":"armstrong-numbers","id":"369d7861d45c48c29b291a4747a89292","url":"https://exercism.io/my/solutions/369d7861d45c48c29b291a4747a89292","handle":"cglacet","is_requester":true,"auto_approve":false}

armstrong-numbers/.solution.json

@@ -0,0 +1,61 @@
+# Armstrong Numbers
+
+An [Armstrong number](https://en.wikipedia.org/wiki/Narcissistic_number) is a number that is the sum of its own digits each raised to the power of the number of digits.
+
+For example:
+
+- 9 is an Armstrong number, because `9 = 9^1 = 9`
+- 10 is *not* an Armstrong number, because `10 != 1^2 + 0^2 = 1`
+- 153 is an Armstrong number, because: `153 = 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153`
+- 154 is *not* an Armstrong number, because: `154 != 1^3 + 5^3 + 4^3 = 1 + 125 + 64 = 190`
+
+Write some code to determine whether a number is an Armstrong number.
+
+## 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 should write:
+
+```python
+raise Exception("Meaningful message indicating the source of the error")
+```
+
+## Running the tests
+
+To run the tests, run the appropriate command below ([why they are different](https://github.com/pytest-dev/pytest/issues/1629#issue-161422224)):
+
+- Python 2.7: `py.test armstrong_numbers_test.py`
+- Python 3.4+: `pytest armstrong_numbers_test.py`
+
+Alternatively, you can tell Python to run the pytest module (allowing the same command to be used regardless of Python version):
+`python -m pytest armstrong_numbers_test.py`
+
+### Common `pytest` options
+
+- `-v` : enable verbose output
+- `-x` : stop running tests on first failure
+- `--ff` : run failures from previous test before running other test cases
+
+For other options, see `python -m pytest -h`
+
+## Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the solution is in the `$EXERCISM_WORKSPACE/python/armstrong-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 [Running the Tests](http://exercism.io/tracks/python/tests).
+
+## Source
+
+Wikipedia [https://en.wikipedia.org/wiki/Narcissistic_number](https://en.wikipedia.org/wiki/Narcissistic_number)
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

armstrong-numbers/README.md

@@ -0,0 +1,2 @@
+def is_armstrong(number):
+    return sum(int(x)**len(str(number)) for x in str(number)) == number

armstrong-numbers/__pycache__/armstrong_numbers.cpython-36.pyc

@@ -0,0 +1,36 @@
+import unittest
+
+from armstrong_numbers import is_armstrong
+
+
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+
+class ArmstrongNumbersTest(unittest.TestCase):
+
+    def test_single_digit_numbers_are_armstrong_numbers(self):
+        self.assertIs(is_armstrong(5), True)
+
+    def test_there_are_no_two_digit_armstrong_numbers(self):
+        self.assertIs(is_armstrong(10), False)
+
+    def test_three_digit_number_that_is_an_armstrong_number(self):
+        self.assertIs(is_armstrong(153), True)
+
+    def test_three_digit_number_that_is_not_an_armstrong_number(self):
+        self.assertIs(is_armstrong(100), False)
+
+    def test_four_digit_number_that_is_an_armstrong_number(self):
+        self.assertIs(is_armstrong(9474), True)
+
+    def test_four_digit_number_that_is_not_an_armstrong_number(self):
+        self.assertIs(is_armstrong(9475), False)
+
+    def test_seven_digit_number_that_is_an_armstrong_number(self):
+        self.assertIs(is_armstrong(9926315), True)
+
+    def test_seven_digit_number_that_is_not_an_armstrong_number(self):
+        self.assertIs(is_armstrong(9926314), False)
+
+
+if __name__ == '__main__':
+    unittest.main()

armstrong-numbers/__pycache__/armstrong_numbers_test.cpython-36-PYTEST.pyc

@@ -0,0 +1 @@
+{}

armstrong-numbers/armstrong_numbers.py

@@ -0,0 +1,12 @@
+[
+  "binary_search_tree_test.py::BinarySearchTreeTest::test_can_create_complex_tree",
+  "binary_search_tree_test.py::BinarySearchTreeTest::test_can_sort_complex_tree",
+  "binary_search_tree_test.py::BinarySearchTreeTest::test_can_sort_if_second_number_is_greater_than_first",
+  "binary_search_tree_test.py::BinarySearchTreeTest::test_can_sort_if_second_number_is_same_as_first",
+  "binary_search_tree_test.py::BinarySearchTreeTest::test_can_sort_if_second_number_is_smaller_than_first",
+  "binary_search_tree_test.py::BinarySearchTreeTest::test_can_sort_single_number",
+  "binary_search_tree_test.py::BinarySearchTreeTest::test_data_is_retained",
+  "binary_search_tree_test.py::BinarySearchTreeTest::test_greater_number_at_right_node",
+  "binary_search_tree_test.py::BinarySearchTreeTest::test_same_number_at_left_node",
+  "binary_search_tree_test.py::BinarySearchTreeTest::test_smaller_data_at_left_node"
+]

armstrong-numbers/armstrong_numbers_test.py

@@ -0,0 +1 @@
+{"track":"python","exercise":"binary-search-tree","id":"ef4c867df95a45c5b7cadfc0a1eb256e","url":"https://exercism.io/my/solutions/ef4c867df95a45c5b7cadfc0a1eb256e","handle":"cglacet","is_requester":true,"auto_approve":false}

binary-search-tree/.pytest_cache/v/cache/lastfailed

@@ -0,0 +1 @@
+{}

binary-search-tree/.pytest_cache/v/cache/nodeids

@@ -0,0 +1,12 @@
+[
+  "binary_search_test.py::BinarySearchTest::test_empty_array",
+  "binary_search_test.py::BinarySearchTest::test_finds_value_at_beginning_of_array",
+  "binary_search_test.py::BinarySearchTest::test_finds_value_at_end_of_array",
+  "binary_search_test.py::BinarySearchTest::test_finds_value_in_array_of_even_length",
+  "binary_search_test.py::BinarySearchTest::test_finds_value_in_array_of_odd_length",
+  "binary_search_test.py::BinarySearchTest::test_finds_value_in_array_with_one_element",
+  "binary_search_test.py::BinarySearchTest::test_finds_value_in_middle_of_array",
+  "binary_search_test.py::BinarySearchTest::test_identifies_value_missing",
+  "binary_search_test.py::BinarySearchTest::test_value_larger_than_arrays_maximum",
+  "binary_search_test.py::BinarySearchTest::test_value_smaller_than_arrays_minimum"
+]

binary-search-tree/.solution.json

@@ -0,0 +1 @@
+{"track":"python","exercise":"binary-search","id":"4436f1ba33d14769a9767c0cb3c42a84","url":"https://exercism.io/my/solutions/4436f1ba33d14769a9767c0cb3c42a84","handle":"cglacet","is_requester":true,"auto_approve":false}

binary-search-tree/__pycache__/binary_search_tree.cpython-36.pyc

@@ -0,0 +1,84 @@
+# Binary Search
+
+Implement a binary search algorithm.
+
+Searching a sorted collection is a common task. A dictionary is a sorted
+list of word definitions. Given a word, one can find its definition. A
+telephone book is a sorted list of people's names, addresses, and
+telephone numbers. Knowing someone's name allows one to quickly find
+their telephone number and address.
+
+If the list to be searched contains more than a few items (a dozen, say)
+a binary search will require far fewer comparisons than a linear search,
+but it imposes the requirement that the list be sorted.
+
+In computer science, a binary search or half-interval search algorithm
+finds the position of a specified input value (the search "key") within
+an array sorted by key value.
+
+In each step, the algorithm compares the search key value with the key
+value of the middle element of the array.
+
+If the keys match, then a matching element has been found and its index,
+or position, is returned.
+
+Otherwise, if the search key is less than the middle element's key, then
+the algorithm repeats its action on the sub-array to the left of the
+middle element or, if the search key is greater, on the sub-array to the
+right.
+
+If the remaining array to be searched is empty, then the key cannot be
+found in the array and a special "not found" indication is returned.
+
+A binary search halves the number of items to check with each iteration,
+so locating an item (or determining its absence) takes logarithmic time.
+A binary search is a dichotomic divide and conquer search algorithm.
+
+## 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 should write:
+
+```python
+raise Exception("Meaningful message indicating the source of the error")
+```
+
+## Running the tests
+
+To run the tests, run the appropriate command below ([why they are different](https://github.com/pytest-dev/pytest/issues/1629#issue-161422224)):
+
+- Python 2.7: `py.test binary_search_test.py`
+- Python 3.4+: `pytest binary_search_test.py`
+
+Alternatively, you can tell Python to run the pytest module (allowing the same command to be used regardless of Python version):
+`python -m pytest binary_search_test.py`
+
+### Common `pytest` options
+
+- `-v` : enable verbose output
+- `-x` : stop running tests on first failure
+- `--ff` : run failures from previous test before running other test cases
+
+For other options, see `python -m pytest -h`
+
+## Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the solution is in the `$EXERCISM_WORKSPACE/python/binary-search` 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 [Running the Tests](http://exercism.io/tracks/python/tests).
+
+## Source
+
+Wikipedia [http://en.wikipedia.org/wiki/Binary_search_algorithm](http://en.wikipedia.org/wiki/Binary_search_algorithm)
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

binary-search-tree/__pycache__/binary_search_tree_test.cpython-36-PYTEST.pyc

@@ -0,0 +1,18 @@
+"""Exercise from https://exercism.io/my/tracks/python"""
+
+
+def binary_search(list_of_numbers, number):
+    """Returns the index of `number` in the sorted list `list_of_numbers`.
+    Raise ``ValueError`` if `number` is not in `list_of_numbers`."""
+    left, right = 0, len(list_of_numbers)-1
+    while right >= left:
+        middle = (left+right)//2
+        middle_number = list_of_numbers[middle]
+        if middle_number == number:
+            return middle
+        if middle_number < number:
+            left = middle + 1
+        else:
+            right = middle - 1
+
+    raise ValueError("Not found.")

binary-search/.pytest_cache/v/cache/lastfailed

@@ -0,0 +1,59 @@
+import unittest
+
+from binary_search import binary_search
+
+
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
+
+class BinarySearchTest(unittest.TestCase):
+    def test_finds_value_in_array_with_one_element(self):
+        self.assertEqual(binary_search([6], 6), 0)
+
+    def test_finds_value_in_middle_of_array(self):
+        self.assertEqual(binary_search([1, 3, 4, 6, 8, 9, 11], 6), 3)
+
+    def test_finds_value_at_beginning_of_array(self):
+        self.assertEqual(binary_search([1, 3, 4, 6, 8, 9, 11], 1), 0)
+
+    def test_finds_value_at_end_of_array(self):
+        self.assertEqual(binary_search([1, 3, 4, 6, 8, 9, 11], 11), 6)
+
+    def test_finds_value_in_array_of_odd_length(self):
+        self.assertEqual(
+            binary_search([1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 634],
+                          144), 9)
+
+    def test_finds_value_in_array_of_even_length(self):
+        self.assertEqual(
+            binary_search([1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377], 21),
+            5)
+
+    def test_identifies_value_missing(self):
+        with self.assertRaisesWithMessage(ValueError):
+            binary_search([1, 3, 4, 6, 8, 9, 11], 7)
+
+    def test_value_smaller_than_arrays_minimum(self):
+        with self.assertRaisesWithMessage(ValueError):
+            binary_search([1, 3, 4, 6, 8, 9, 11], 0)
+
+    def test_value_larger_than_arrays_maximum(self):
+        with self.assertRaisesWithMessage(ValueError):
+            binary_search([1, 3, 4, 6, 8, 9, 11], 13)
+
+    def test_empty_array(self):
+        with self.assertRaisesWithMessage(ValueError):
+            binary_search([], 1)
+
+    # Utility functions
+    def setUp(self):
+        try:
+            self.assertRaisesRegex
+        except AttributeError:
+            self.assertRaisesRegex = self.assertRaisesRegexp
+
+    def assertRaisesWithMessage(self, exception):
+        return self.assertRaisesRegex(exception, r".+")
+
+
+if __name__ == '__main__':
+    unittest.main()

binary-search/.pytest_cache/v/cache/nodeids

@@ -0,0 +1,43 @@
+import random
+
+
+def main():
+    for _ in range(1000):
+        list_of_numbers = sorted([random.randint(1, 30) for _ in range(random.randint(10, 30))])
+        number = random.choice(list_of_numbers)
+        position = binary_search(list_of_numbers, number, debug=True)
+        assert list_of_numbers[position] == number
+
+def state_repr(list_of_numbers, left, middle, right):
+    text = ""
+    for i, number in enumerate(list_of_numbers):
+        number_text = str(number)
+        if i == middle:
+            number_text = "(" + number_text + ")"
+        left_text = "[" if left == i else " "
+        right_text = "]" if right == i else " "
+        text += left_text + number_text + right_text
+    return text
+
+
+def binary_search(list_of_numbers, number, debug=False):
+    if debug:
+        print("Looking for {} in {}".format(number, list_of_numbers))
+    left, right = 0, len(list_of_numbers)-1
+    while right-left >= 0:
+        middle = left + (right-left)//2
+        middle_number = list_of_numbers[middle]
+        if debug:
+            print(state_repr(list_of_numbers, left, middle, right))
+        if middle_number == number:
+            return middle
+        if middle_number < number:
+            left = middle + 1
+        else:
+            right = middle - 1
+
+    return None
+
+
+if __name__ == "__main__":
+    main()

binary-search/.solution.json

@@ -0,0 +1 @@
+{}

binary-search/README.md

@@ -0,0 +1,16 @@
+[
+  "book_store_test.py::BookStoreTest::test_empty_basket",
+  "book_store_test.py::BookStoreTest::test_five_different_books",
+  "book_store_test.py::BookStoreTest::test_four_different_books",
+  "book_store_test.py::BookStoreTest::test_four_groups_of_4_are_cheaper_than_2_groups_each_of_5_and_3",
+  "book_store_test.py::BookStoreTest::test_group_of_4_plus_group_of_2_is_cheaper_than_2_groups_of_3",
+  "book_store_test.py::BookStoreTest::test_only_a_single_book",
+  "book_store_test.py::BookStoreTest::test_three_copies_of_first_book_and_2_each_of_remaining",
+  "book_store_test.py::BookStoreTest::test_three_different_books",
+  "book_store_test.py::BookStoreTest::test_three_each_of_first_2_books_and_2_each_of_remaining_books",
+  "book_store_test.py::BookStoreTest::test_two_copies_of_each_book",
+  "book_store_test.py::BookStoreTest::test_two_different_books",
+  "book_store_test.py::BookStoreTest::test_two_each_of_first_4_books_and_1_copy_each_of_rest",
+  "book_store_test.py::BookStoreTest::test_two_groups_of_4_is_cheaper_than_group_of_5_plus_group_of_3",
+  "book_store_test.py::BookStoreTest::test_two_of_the_same_book"
+]