trackler 2.2.1.54 → 2.2.1.55

data/tracks/kotlin/exercises/saddle-points/README.md

@@ -15,7 +15,7 @@ So say you have a matrix like so:
 It has a saddle point at (1, 0).
 
 It's called a "saddle point" because it is greater than or equal to
-every element in its row and the less than or equal to every element in
+every element in its row and less than or equal to every element in
 its column.
 
 A matrix may have zero or more saddle points.

data/tracks/kotlin/exercises/two-fer/README.md

@@ -11,34 +11,6 @@ When X is a name or "you".
 If the given name is "Alice", the result should be "One for Alice, one for me."
 If no name is given, the result should be "One for you, one for me."
 
-## Test-Driven Development
-
-As programmers mature, they eventually want to test their code.
-
-Here at Exercism we simulate [Test-Driven
-Development](http://en.wikipedia.org/wiki/Test-driven_development) (TDD), where
-you write your tests before writing any functionality. The simulation comes in
-the form of a pre-written test suite, which will signal that you have solved
-the problem.
-
-It will also provide you with a safety net to explore other solutions without
-breaking the functionality.
-
-### A typical TDD workflow on Exercism:
-
-1. Run the test file and pick one test that's failing.
-2. Write some code to fix the test you picked.
-3. Re-run the tests to confirm the test is now passing.
-4. Repeat from step 1.
-5. Submit your solution (`exercism submit /path/to/file`)
-
-## Instructions
-
-Submissions are encouraged to be general, within reason. Having said that, it's
-also important not to over-engineer a solution.
-
-It's important to remember that the goal is to make code as expressive and
-readable as we can.
 
 
 

data/tracks/lua/config.json

@@ -920,6 +920,18 @@
       ],
       "unlocked_by": "matrix",
       "uuid": "beca7d79-9237-4344-b058-66e0fa840691"
+    },
+    {
+      "core": false,
+      "difficulty": 3,
+      "slug": "collatz-conjecture",
+      "topics": [
+        "control_flow_if_else_statements",
+        "control_flow_loops",
+        "mathematics"
+      ],
+      "unlocked_by": "difference-of-squares",
+      "uuid": "bd4cd740-b78d-11e7-abc4-cec278b6b50a"
     }
   ],
   "foregone": [],

data/tracks/lua/exercises/collatz-conjecture/README.md

@@ -0,0 +1,43 @@
+# Collatz Conjecture
+
+The Collatz Conjecture or 3x+1 problem can be summarized as follows:
+
+Take any positive integer n. If n is even, divide n by 2 to get n / 2. If n is
+odd, multiply n by 3 and add 1 to get 3n + 1. Repeat the process indefinitely.
+The conjecture states that no matter which number you start with, you will
+always reach 1 eventually.
+
+Given a number n, return the number of steps required to reach 1.
+
+## Examples
+
+Starting with n = 12, the steps would be as follows:
+
+0. 12
+1. 6
+2. 3
+3. 10
+4. 5
+5. 16
+6. 8
+7. 4
+8. 2
+9. 1
+
+Resulting in 9 steps. So for input n = 12, the return value would be 9.
+
+## Running the tests
+
+To run the tests, run the command `busted .` from within the exercise directory.
+
+## Further information
+
+For more detailed information about the Lua track, including how to get help if
+you're having trouble, please visit the exercism.io [Lua language page](http://exercism.io/languages/lua/about).
+
+## Source
+
+An unsolved problem in mathematics named after mathematician Lothar Collatz [https://en.wikipedia.org/wiki/3x_%2B_1_problem](https://en.wikipedia.org/wiki/3x_%2B_1_problem)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/lua/exercises/collatz-conjecture/collatz-conjecture_spec.lua

@@ -0,0 +1,33 @@
+local conjecture = require('collatz-conjecture')
+
+describe('collatz-conjecture', function()
+  it('zero steps for one', function()
+    assert.are.equal(0, conjecture(1))
+  end)
+
+  it('divide if even', function()
+    assert.are.equal(4, conjecture(16))
+  end)
+
+  it('even and odd steps', function()
+    assert.are.equal(9, conjecture(12))
+  end)
+
+  it('large number of even and odd steps', function()
+    assert.are.equal(152, conjecture(1000000))
+  end)
+
+  it('zero is an error', function()
+    assert.has_error(
+      function() conjecture(0) end,
+      'Only positive numbers are allowed'
+    )
+  end)
+
+  it('negative value is an error', function()
+    assert.has_error(
+      function() conjecture(-15) end,
+      'Only positive numbers are allowed'
+    )
+  end)
+end)

data/tracks/lua/exercises/collatz-conjecture/example.lua

@@ -0,0 +1,16 @@
+return function(n)
+  assert(n > 0, 'Only positive numbers are allowed')
+
+  local steps = 0
+
+  while n > 1 do
+    if n % 2 == 0 then
+      n = n / 2
+    else
+      n = 3 * n + 1
+    end
+    steps = steps + 1
+  end
+
+  return steps
+end

data/tracks/python/config.json

@@ -539,7 +539,10 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
-
+        "loops",
+        "type_conversion",
+        "integers",
+        "matrices"
       ]
     },
     {

data/tracks/python/exercises/binary-search/binary_search_test.py

@@ -3,6 +3,8 @@ import unittest
 from binary_search import binary_search
 
 
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+
 class BinarySearchTests(unittest.TestCase):
     def test_finds_value_in_array_with_one_element(self):
         self.assertEqual(binary_search([6], 6), 0)

data/tracks/python/exercises/change/change_test.py

@@ -2,6 +2,8 @@ import unittest
 
 from change import find_minimum_coins
 
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
+
 
 class ChangeTest(unittest.TestCase):
     def test_single_coin_change(self):

data/tracks/python/exercises/circular-buffer/circular_buffer_test.py

@@ -7,43 +7,41 @@ from circular_buffer import (
 )
 
 
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.1
+
 class CircularBufferTest(unittest.TestCase):
     def test_read_empty_buffer(self):
         buf = CircularBuffer(1)
         with self.assertRaises(BufferEmptyException):
             buf.read()
 
+    def test_read_just_written_item(self):
+        buf = CircularBuffer(1)
+        buf.write('1')
+        self.assertEqual(buf.read(), '1')
+
     def test_write_and_read_back_one_item(self):
         buf = CircularBuffer(1)
         buf.write('1')
-        self.assertEqual('1', buf.read())
+        self.assertEqual(buf.read(), '1')
         with self.assertRaises(BufferEmptyException):
             buf.read()
 
-    def test_write_and_read_back_multiple_items(self):
+    def test_write_and_read_back_multiple_items_ordered(self):
         buf = CircularBuffer(2)
         buf.write('1')
         buf.write('2')
         self.assertEqual(buf.read(), '1')
         self.assertEqual(buf.read(), '2')
-        with self.assertRaises(BufferEmptyException):
-            buf.read()
 
-    def test_clearing_buffer(self):
-        buf = CircularBuffer(3)
-        for c in '123':
-            buf.write(c)
-        buf.clear()
-        with self.assertRaises(BufferEmptyException):
-            buf.read()
+    def test_full_buffer_cant_written(self):
+        buf = CircularBuffer(1)
         buf.write('1')
-        buf.write('2')
-        self.assertEqual(buf.read(), '1')
-        buf.write('3')
-        self.assertEqual(buf.read(), '2')
+        with self.assertRaises(BufferFullException):
+            buf.write('2')
 
     def test_alternate_write_and_read(self):
-        buf = CircularBuffer(2)
+        buf = CircularBuffer(1)
         buf.write('1')
         self.assertEqual(buf.read(), '1')
         buf.write('2')
@@ -53,56 +51,64 @@ class CircularBufferTest(unittest.TestCase):
         buf = CircularBuffer(3)
         buf.write('1')
         buf.write('2')
-        buf.read()
+        self.assertEqual(buf.read(), '1')
         buf.write('3')
-        buf.read()
+        self.assertEqual(buf.read(), '2')
         self.assertEqual(buf.read(), '3')
 
-    def test_write_full_buffer(self):
-        buf = CircularBuffer(2)
+    def test_clearing_buffer(self):
+        buf = CircularBuffer(1)
         buf.write('1')
-        buf.write('2')
-        with self.assertRaises(BufferFullException):
-            buf.write('A')
+        buf.clear()
+        with self.assertRaises(BufferEmptyException):
+            buf.read()
 
-    def test_overwrite_full_buffer(self):
-        buf = CircularBuffer(2)
+    def test_clear_free_buffer_for_write(self):
+        buf = CircularBuffer(1)
         buf.write('1')
+        buf.clear()
         buf.write('2')
-        buf.overwrite('A')
         self.assertEqual(buf.read(), '2')
-        self.assertEqual(buf.read(), 'A')
-        with self.assertRaises(BufferEmptyException):
-            buf.read()
+
+    def test_clear_does_nothin_empty_buffer(self):
+        buf = CircularBuffer(1)
+        buf.clear()
+        buf.write('1')
+        self.assertEqual(buf.read(), '1')
 
     def test_overwrite_non_full_buffer(self):
         buf = CircularBuffer(2)
-        buf.overwrite('1')
+        buf.write('1')
         buf.overwrite('2')
         self.assertEqual(buf.read(), '1')
         self.assertEqual(buf.read(), '2')
-        with self.assertRaises(BufferEmptyException):
-            buf.read()
 
-    def test_alternate_read_and_overwrite(self):
-        buf = CircularBuffer(5)
-        for c in '123':
-            buf.write(c)
-        buf.read()
-        buf.read()
+    def test_overwrite_replaces_oldest_item(self):
+        buf = CircularBuffer(2)
+        buf.write('1')
+        buf.write('2')
+        buf.overwrite('3')
+        self.assertEqual(buf.read(), '2')
+        self.assertEqual(buf.read(), '3')
+
+    def test_write_full_buffer(self):
+        buf = CircularBuffer(2)
+        buf.write('1')
+        buf.write('2')
+        with self.assertRaises(BufferFullException):
+            buf.write('A')
+
+    def test_over_write_replaces_oldest_remaning_item(self):
+        buf = CircularBuffer(3)
+        buf.write('1')
+        buf.write('2')
+        buf.write('3')
+        self.assertEqual(buf.read(), '1')
         buf.write('4')
-        buf.read()
-        for c in '5678':
-            buf.write(c)
-        buf.overwrite('A')
-        buf.overwrite('B')
-        self.assertEqual(buf.read(), '6')
-        self.assertEqual(buf.read(), '7')
-        self.assertEqual(buf.read(), '8')
-        self.assertEqual(buf.read(), 'A')
-        self.assertEqual(buf.read(), 'B')
-        with self.assertRaises(BufferEmptyException):
-            buf.read()
+        buf.overwrite('5')
+        self.assertEqual(buf.read(), '3')
+        self.assertEqual(buf.read(), '4')
+        self.assertEqual(buf.read(), '5')
 
 
 if __name__ == '__main__':

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

@@ -11,8 +11,10 @@ def is_integer(string):
 
 
 def evaluate(input_data):
+    if not input_data:
+        return []
     defines = {}
-    while input_data[0][0] == ':':
+    while input_data[0][:1] == ':':
         values = input_data.pop(0).split()
         values.pop()
         values.pop(0)

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

@@ -4,13 +4,30 @@ from forth import evaluate, StackUnderflowError
 
 
 # Tests adapted from `problem-specifications//canonical-data.json` @ v1.2.0
+# Tests for case-insensitivity are track-specific
+
+class ForthParsingTest(unittest.TestCase):
+    def test_empty_input_empty_stack(self):
+        input_data = []
+        expected = []
+        self.assertEqual(evaluate(input_data), expected)
+
+    def test_empty_line_empty_stack(self):
+        input_data = [""]
+        expected = []
+        self.assertEqual(evaluate(input_data), expected)
+
+    def test_numbers_just_get_pushed_to_stack(self):
+        input_data = ["1 2 3 4 5"]
+        expected = [1, 2, 3, 4, 5]
+        self.assertEqual(evaluate(input_data), expected)
 
 
 class ForthAdditionTest(unittest.TestCase):
     def test_can_add_two_numbers(self):
         input_data = ["1 2 +"]
         expected = [3]
-        self.assertEqual(expected, evaluate(input_data))
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_errors_if_there_is_nothing_on_the_stack(self):
         input_data = ["+"]
@@ -27,7 +44,7 @@ class ForthSubtractionTest(unittest.TestCase):
     def test_can_subtract_two_numbers(self):
         input_data = ["3 4 -"]
         expected = [-1]
-        self.assertEqual(expected, evaluate(input_data))
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_errors_if_there_is_nothing_on_the_stack(self):
         input_data = ["-"]
@@ -44,7 +61,7 @@ class ForthMultiplicationTest(unittest.TestCase):
     def test_can_multiply_two_numbers(self):
         input_data = ["2 4 *"]
         expected = [8]
-        self.assertEqual(expected, evaluate(input_data))
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_errors_if_there_is_nothing_on_the_stack(self):
         input_data = ["*"]
@@ -59,14 +76,14 @@ class ForthMultiplicationTest(unittest.TestCase):
 
 class ForthDivisionTest(unittest.TestCase):
     def test_can_divide_two_numbers(self):
-        input_data = ["3 4 -"]
-        expected = [-1]
-        self.assertEqual(expected, evaluate(input_data))
+        input_data = ["12 3 /"]
+        expected = [4]
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_performs_integer_division(self):
         input_data = ["8 3 /"]
         expected = [2]
-        self.assertEqual(expected, evaluate(input_data))
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_errors_if_dividing_by_zero(self):
         input_data = ["4 0 /"]
@@ -88,24 +105,24 @@ class ForthCombinedArithmeticTest(unittest.TestCase):
     def test_addition_and_subtraction(self):
         input_data = ["1 2 + 4 -"]
         expected = [-1]
-        self.assertEqual(expected, evaluate(input_data))
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_multiplication_and_division(self):
         input_data = ["2 4 * 3 /"]
         expected = [2]
-        self.assertEqual(expected, evaluate(input_data))
+        self.assertEqual(evaluate(input_data), expected)
 
 
 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))
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_is_case_insensitive(self):
         input_data = ["1 2 Dup"]
         expected = [1, 2, 2]
-        self.assertEqual(expected, evaluate(input_data))
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_errors_if_there_is_nothing_on_the_stack(self):
         input_data = ["dup"]
@@ -117,17 +134,17 @@ 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))
+        self.assertEqual(evaluate(input_data), expected)
 
     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))
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_is_case_insensitive(self):
         input_data = ["1 2 Drop"]
         expected = [1]
-        self.assertEqual(expected, evaluate(input_data))
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_errors_if_there_is_nothing_on_the_stack(self):
         input_data = ["drop"]
@@ -139,17 +156,17 @@ 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))
+        self.assertEqual(evaluate(input_data), expected)
 
     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))
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_is_case_insensitive(self):
         input_data = ["3 4 Swap"]
         expected = [4, 3]
-        self.assertEqual(expected, evaluate(input_data))
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_errors_if_there_is_nothing_on_the_stack(self):
         input_data = ["swap"]
@@ -166,17 +183,17 @@ 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))
+        self.assertEqual(evaluate(input_data), expected)
 
     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))
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_is_case_insensitive(self):
         input_data = ["3 4 Over"]
         expected = [3, 4, 3]
-        self.assertEqual(expected, evaluate(input_data))
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_errors_if_there_is_nothing_on_the_stack(self):
         input_data = ["over"]
@@ -196,7 +213,7 @@ class ForthUserDefinedWordsTest(unittest.TestCase):
             "1 dup-twice"
         ]
         expected = [1, 1, 1]
-        self.assertEqual(expected, evaluate(input_data))
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_execute_in_the_right_order(self):
         input_data = [
@@ -204,7 +221,7 @@ class ForthUserDefinedWordsTest(unittest.TestCase):
             "countup"
         ]
         expected = [1, 2, 3]
-        self.assertEqual(expected, evaluate(input_data))
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_can_override_other_user_defined_words(self):
         input_data = [
@@ -213,7 +230,7 @@ class ForthUserDefinedWordsTest(unittest.TestCase):
             "1 foo"
         ]
         expected = [1, 1, 1]
-        self.assertEqual(expected, evaluate(input_data))
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_can_override_built_in_words(self):
         input_data = [
@@ -221,7 +238,7 @@ class ForthUserDefinedWordsTest(unittest.TestCase):
             "1 swap"
         ]
         expected = [1, 1]
-        self.assertEqual(expected, evaluate(input_data))
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_can_override_built_in_operators(self):
         input_data = [
@@ -229,7 +246,7 @@ class ForthUserDefinedWordsTest(unittest.TestCase):
             "3 4 +"
         ]
         expected = [12]
-        self.assertEqual(expected, evaluate(input_data))
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_is_case_insensitive(self):
         input_data = [
@@ -237,7 +254,7 @@ class ForthUserDefinedWordsTest(unittest.TestCase):
             "1 FOO"
         ]
         expected = [1, 1]
-        self.assertEqual(expected, evaluate(input_data))
+        self.assertEqual(evaluate(input_data), expected)
 
     def test_cannot_redefine_numbers(self):
         input_data = [": 1 2 ;"]