trackler 2.2.1.45 → 2.2.1.46

data/tracks/python/exercises/forth/README.md

@@ -0,0 +1,43 @@
+# Forth
+
+Implement an evaluator for a very simple subset of Forth.
+
+[Forth](https://en.wikipedia.org/wiki/Forth_%28programming_language%29)
+is a stack-based programming language. Implement a very basic evaluator
+for a small subset of Forth.
+
+Your evaluator has to support the following words:
+
+- `+`, `-`, `*`, `/` (integer arithmetic)
+- `DUP`, `DROP`, `SWAP`, `OVER` (stack manipulation)
+
+Your evaluator also has to support defining new words using the
+customary syntax: `: word-name definition ;`.
+
+To keep things simple the only data type you need to support is signed
+integers of at least 16 bits size.
+
+You should use the following rules for the syntax: a number is a
+sequence of one or more (ASCII) digits, a word is a sequence of one or
+more letters, digits, symbols or punctuation that is not a number.
+(Forth probably uses slightly different rules, but this is close
+enough.)
+
+Words are case-insensitive.
+
+## Hints
+- To parse the text, you could try to use the [Sprache](https://github.com/sprache/Sprache/blob/develop/README.md) library. You can also find a good tutorial [here](https://www.thomaslevesque.com/2017/02/23/easy-text-parsing-in-c-with-sprache/).
+
+
+### Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.
+
+For example, if you're submitting `bob.py` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/python/bob/bob.py`.
+
+
+For more detailed information about running tests, code style and linting,
+please see the [help page](http://exercism.io/languages/python).
+
+## 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/forth/example.py

@@ -0,0 +1,58 @@
+class StackUnderflowError(Exception):
+    pass
+
+
+def is_integer(string):
+    try:
+        int(string)
+        return True
+    except ValueError:
+        return False
+
+
+def evaluate(input_data):
+    defines = {}
+    while input_data[0][0] == ':':
+        values = input_data.pop(0).split()
+        values.pop()
+        values.pop(0)
+        key = values.pop(0)
+        if is_integer(key):
+            raise ValueError()
+        defines[key] = values
+    stack = []
+    input_data = input_data[-1].split()
+    while any(input_data):
+        word = input_data.pop(0).lower()
+        try:
+            if is_integer(word):
+                stack.append(int(word))
+            elif word in defines:
+                input_data = defines[word] + input_data
+            elif word == '+':
+                stack.append(stack.pop() + stack.pop())
+            elif word == '-':
+                stack.append(-stack.pop() + stack.pop())
+            elif word == '*':
+                stack.append(stack.pop() * stack.pop())
+            elif word == '/':
+                divider = stack.pop()
+                if divider == 0:
+                    raise ZeroDivisionError()
+                stack.append(int(stack.pop() / divider))
+            elif word == 'dup':
+                stack.append(stack[-1])
+            elif word == 'drop':
+                stack.pop()
+            elif word == 'swap':
+                stack.append(stack[-2])
+                del stack[-3]
+            elif word == 'over':
+                stack.append(stack[-2])
+            else:
+                raise ValueError()
+        except ZeroDivisionError:
+            raise
+        except IndexError:
+            raise StackUnderflowError()
+    return stack

data/tracks/python/exercises/forth/forth.py

@@ -0,0 +1,2 @@
+def evaluate(input_data):
+    pass

data/tracks/python/exercises/forth/forth_test.py

@@ -0,0 +1,254 @@
+import unittest
+
+from example import evaluate, StackUnderflowError
+
+
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.2.0
+
+
+class ForthAdditionTest(unittest.TestCase):
+    def test_can_add_two_numbers(self):
+        input_data = ["1 2 +"]
+        expected = [3]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_errors_if_there_is_nothing_on_the_stack(self):
+        input_data = ["+"]
+        with self.assertRaises(StackUnderflowError):
+            evaluate(input_data)
+
+    def test_errors_if_there_is_only_one_value_on_the_stack(self):
+        input_data = ["1 +"]
+        with self.assertRaises(StackUnderflowError):
+            evaluate(input_data)
+
+
+class ForthSubtractionTest(unittest.TestCase):
+    def test_can_subtract_two_numbers(self):
+        input_data = ["3 4 -"]
+        expected = [-1]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_errors_if_there_is_nothing_on_the_stack(self):
+        input_data = ["-"]
+        with self.assertRaises(StackUnderflowError):
+            evaluate(input_data)
+
+    def test_errors_if_there_is_only_one_value_on_the_stack(self):
+        input_data = ["1 -"]
+        with self.assertRaises(StackUnderflowError):
+            evaluate(input_data)
+
+
+class ForthMultiplicationTest(unittest.TestCase):
+    def test_can_multiply_two_numbers(self):
+        input_data = ["2 4 *"]
+        expected = [8]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_errors_if_there_is_nothing_on_the_stack(self):
+        input_data = ["*"]
+        with self.assertRaises(StackUnderflowError):
+            evaluate(input_data)
+
+    def test_errors_if_there_is_only_one_value_on_the_stack(self):
+        input_data = ["1 *"]
+        with self.assertRaises(StackUnderflowError):
+            evaluate(input_data)
+
+
+class ForthDivisionTest(unittest.TestCase):
+    def test_can_divide_two_numbers(self):
+        input_data = ["3 4 -"]
+        expected = [-1]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_performs_integer_division(self):
+        input_data = ["8 3 /"]
+        expected = [2]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_errors_if_dividing_by_zero(self):
+        input_data = ["4 0 /"]
+        with self.assertRaises(ZeroDivisionError):
+            evaluate(input_data)
+
+    def test_errors_if_there_is_nothing_on_the_stack(self):
+        input_data = ["/"]
+        with self.assertRaises(StackUnderflowError):
+            evaluate(input_data)
+
+    def test_errors_if_there_is_only_one_value_on_the_stack(self):
+        input_data = ["1 /"]
+        with self.assertRaises(StackUnderflowError):
+            evaluate(input_data)
+
+
+class ForthCombinedArithmeticTest(unittest.TestCase):
+    def test_addition_and_subtraction(self):
+        input_data = ["1 2 + 4 -"]
+        expected = [-1]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_multiplication_and_division(self):
+        input_data = ["2 4 * 3 /"]
+        expected = [2]
+        self.assertEqual(expected, evaluate(input_data))
+
+
+class ForthDupTest(unittest.TestCase):
+    def test_copies_the_top_value_on_the_stack(self):
+        input_data = ["1 DUP"]
+        expected = [1, 1]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_is_case_insensitive(self):
+        input_data = ["1 2 Dup"]
+        expected = [1, 2, 2]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_errors_if_there_is_nothing_on_the_stack(self):
+        input_data = ["dup"]
+        with self.assertRaises(StackUnderflowError):
+            evaluate(input_data)
+
+
+class ForthDropTest(unittest.TestCase):
+    def test_removes_the_top_value_on_the_stack_if_it_is_the_only_one(self):
+        input_data = ["1 DROP"]
+        expected = []
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_removes_the_top_value_on_the_stack_if_it_not_the_only_one(self):
+        input_data = ["3 4 DROP"]
+        expected = [3]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_is_case_insensitive(self):
+        input_data = ["1 2 Drop"]
+        expected = [1]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_errors_if_there_is_nothing_on_the_stack(self):
+        input_data = ["drop"]
+        with self.assertRaises(StackUnderflowError):
+            evaluate(input_data)
+
+
+class ForthSwapTest(unittest.TestCase):
+    def test_swaps_only_two_values_on_stack(self):
+        input_data = ["1 2 SWAP"]
+        expected = [2, 1]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_swaps_two_two_values_on_stack(self):
+        input_data = ["1 2 3 SWAP"]
+        expected = [1, 3, 2]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_is_case_insensitive(self):
+        input_data = ["3 4 Swap"]
+        expected = [4, 3]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_errors_if_there_is_nothing_on_the_stack(self):
+        input_data = ["swap"]
+        with self.assertRaises(StackUnderflowError):
+            evaluate(input_data)
+
+    def test_errors_if_there_is_only_one_value_on_the_stack(self):
+        input_data = ["1 swap"]
+        with self.assertRaises(StackUnderflowError):
+            evaluate(input_data)
+
+
+class ForthOverTest(unittest.TestCase):
+    def test_copies_the_second_element_if_there_are_only_two(self):
+        input_data = ["1 2 OVER"]
+        expected = [1, 2, 1]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_copies_the_second_element_if_there_are_more_than_two(self):
+        input_data = ["1 2 3 OVER"]
+        expected = [1, 2, 3, 2]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_is_case_insensitive(self):
+        input_data = ["3 4 Over"]
+        expected = [3, 4, 3]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_errors_if_there_is_nothing_on_the_stack(self):
+        input_data = ["over"]
+        with self.assertRaises(StackUnderflowError):
+            evaluate(input_data)
+
+    def test_errors_if_there_is_only_one_value_on_the_stack(self):
+        input_data = ["1 over"]
+        with self.assertRaises(StackUnderflowError):
+            evaluate(input_data)
+
+
+class ForthUserDefinedWordsTest(unittest.TestCase):
+    def test_can_consist_of_built_in_words(self):
+        input_data = [
+            ": dup-twice dup dup ;",
+            "1 dup-twice"
+        ]
+        expected = [1, 1, 1]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_execute_in_the_right_order(self):
+        input_data = [
+            ": countup 1 2 3 ;",
+            "countup"
+        ]
+        expected = [1, 2, 3]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_can_override_other_user_defined_words(self):
+        input_data = [
+            ": foo dup ;",
+            ": foo dup dup ;",
+            "1 foo"
+        ]
+        expected = [1, 1, 1]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_can_override_built_in_words(self):
+        input_data = [
+            ": swap dup ;",
+            "1 swap"
+        ]
+        expected = [1, 1]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_can_override_built_in_operators(self):
+        input_data = [
+            ": + * ;",
+            "3 4 +"
+        ]
+        expected = [12]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_is_case_insensitive(self):
+        input_data = [
+            ": foo dup ;",
+            "1 FOO"
+        ]
+        expected = [1, 1]
+        self.assertEqual(expected, evaluate(input_data))
+
+    def test_cannot_redefine_numbers(self):
+        input_data = [": 1 2 ;"]
+        with self.assertRaises(ValueError):
+            evaluate(input_data)
+
+    def test_errors_if_executing_a_non_existent_word(self):
+        input_data = ["foo"]
+        with self.assertRaises(ValueError):
+            evaluate(input_data)
+
+
+if __name__ == '__main__':
+    unittest.main()

data/tracks/python/exercises/gigasecond/gigasecond_test.py

@@ -5,7 +5,7 @@ from datetime import datetime
 from gigasecond import add_gigasecond
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
 class GigasecondTest(unittest.TestCase):
     def test_date_only_specification_of_time(self):

data/tracks/python/exercises/grep/grep_test.py

@@ -4,7 +4,7 @@ import unittest
 from grep import grep
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
 ILIADFILENAME = 'iliad.txt'
 ILIADCONTENTS = '''Achilles sing, O Goddess! Peleus' son;

data/tracks/python/exercises/hello-world/hello_world_test.py

@@ -3,7 +3,7 @@ import unittest
 import hello_world
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
 class HelloWorldTests(unittest.TestCase):
     def test_hello(self):

data/tracks/python/exercises/isogram/isogram_test.py

@@ -8,34 +8,34 @@ from isogram import is_isogram
 class TestIsogram(unittest.TestCase):
 
     def test_empty_string(self):
-        self.assertTrue(is_isogram(""))
+        self.assertIs(is_isogram(""), True)
 
     def test_isogram_with_only_lower_case_characters(self):
-        self.assertTrue(is_isogram("isogram"))
+        self.assertIs(is_isogram("isogram"), True)
 
     def test_word_with_one_duplicated_character(self):
-        self.assertFalse(is_isogram("eleven"))
+        self.assertIs(is_isogram("eleven"), False)
 
     def test_longest_reported_english_isogram(self):
-        self.assertTrue(is_isogram("subdermatoglyphic"))
+        self.assertIs(is_isogram("subdermatoglyphic"), True)
 
     def test_word_with_duplicated_character_in_mixed_case(self):
-        self.assertFalse(is_isogram("Alphabet"))
+        self.assertIs(is_isogram("Alphabet"), False)
 
     def test_hypothetical_isogrammic_word_with_hyphen(self):
-        self.assertTrue(is_isogram("thumbscrew-japingly"))
+        self.assertIs(is_isogram("thumbscrew-japingly"), True)
 
     def test_isogram_with_duplicated_non_letter_character(self):
-        self.assertTrue(is_isogram("Hjelmqvist-Gryb-Zock-Pfund-Wax"))
+        self.assertIs(is_isogram("Hjelmqvist-Gryb-Zock-Pfund-Wax"), True)
 
     def test_made_up_name_that_is_an_isogram(self):
-        self.assertTrue(is_isogram("Emily Jung Schwartzkopf"))
+        self.assertIs(is_isogram("Emily Jung Schwartzkopf"), True)
 
     def test_duplicated_character_in_the_middle(self):
-        self.assertFalse(is_isogram("accentor"))
+        self.assertIs(is_isogram("accentor"), False)
 
     def test_isogram_with_duplicated_letter_and_nonletter_character(self):
-        self.assertFalse(is_isogram("Aleph Bot Chap"))
+        self.assertIs(is_isogram("Aleph Bot Chap"), False)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/largest-series-product/largest_series_product_test.py

@@ -11,7 +11,7 @@ import unittest
 from largest_series_product import largest_product
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
 class SeriesTest(unittest.TestCase):
     def test_finds_the_largest_product_if_span_equals_length(self):

data/tracks/python/exercises/leap/leap_test.py

@@ -3,20 +3,20 @@ import unittest
 from leap import is_leap_year
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
 class YearTest(unittest.TestCase):
     def test_year_not_divisible_by_4(self):
-        self.assertFalse(is_leap_year(2015))
+        self.assertIs(is_leap_year(2015), False)
 
     def test_year_divisible_by_4_not_divisible_by_100(self):
-        self.assertTrue(is_leap_year(2016))
+        self.assertIs(is_leap_year(2016), True)
 
     def test_year_divisible_by_100_not_divisible_by_400(self):
-        self.assertFalse(is_leap_year(2100))
+        self.assertIs(is_leap_year(2100), False)
 
     def test_year_divisible_by_400(self):
-        self.assertTrue(is_leap_year(2000))
+        self.assertIs(is_leap_year(2000), True)
 
 
 if __name__ == '__main__':