Add binary-search-tree (#131)

Author: glennj

config.json

@@ -602,6 +602,14 @@
         "prerequisites": [],
         "difficulty": 4
       },
+      {
+        "slug": "binary-search-tree",
+        "name": "Binary Search Tree",
+        "uuid": "338954f7-9a12-46fc-9c5f-3345a83baa48",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 5
+      },
       {
         "slug": "camicia",
         "name": "Camicia",

exercises/practice/binary-search-tree/.busted

@@ -0,0 +1,5 @@
+return {
+  default = {
+    ROOT = { '.' }
+  }
+}

exercises/practice/binary-search-tree/.docs/instructions.md

@@ -0,0 +1,70 @@
+# Instructions
+
+Insert and search for numbers in a binary tree.
+
+When we need to represent sorted data, an array does not make a good data structure.
+
+Say we have the array `[1, 3, 4, 5]`, and we add 2 to it so it becomes `[1, 3, 4, 5, 2]`.
+Now we must sort the entire array again!
+We can improve on this by realizing that we only need to make space for the new item `[1, nil, 3, 4, 5]`, and then adding the item in the space we added.
+But this still requires us to shift many elements down by one.
+
+Binary Search Trees, however, can operate on sorted data much more efficiently.
+
+A binary search tree consists of a series of connected nodes.
+Each node contains a piece of data (e.g. the number 3), a variable named `left`, and a variable named `right`.
+The `left` and `right` variables point at `nil`, or other nodes.
+Since these other nodes in turn have other nodes beneath them, we say that the left and right variables are pointing at subtrees.
+All data in the left subtree is less than or equal to the current node's data, and all data in the right subtree is greater than the current node's data.
+
+For example, if we had a node containing the data 4, and we added the data 2, our tree would look like this:
+
+![A graph with root node 4 and a single child node 2.](https://assets.exercism.org/images/exercises/binary-search-tree/tree-4-2.svg)
+
+```text
+      4
+     /
+    2
+```
+
+If we then added 6, it would look like this:
+
+![A graph with root node 4 and two child nodes 2 and 6.](https://assets.exercism.org/images/exercises/binary-search-tree/tree-4-2-6.svg)
+
+```text
+      4
+     / \
+    2   6
+```
+
+If we then added 3, it would look like this
+
+![A graph with root node 4, two child nodes 2 and 6, and a grandchild node 3.](https://assets.exercism.org/images/exercises/binary-search-tree/tree-4-2-6-3.svg)
+
+```text
+       4
+     /   \
+    2     6
+     \
+      3
+```
+
+And if we then added 1, 5, and 7, it would look like this
+
+![A graph with root node 4, two child nodes 2 and 6, and four grandchild nodes 1, 3, 5 and 7.](https://assets.exercism.org/images/exercises/binary-search-tree/tree-4-2-6-1-3-5-7.svg)
+
+```text
+          4
+        /   \
+       /     \
+      2       6
+     / \     / \
+    1   3   5   7
+```
+
+## Credit
+
+The images were created by [habere-et-dispertire][habere-et-dispertire] using [PGF/TikZ][pgf-tikz] by Till Tantau.
+
+[habere-et-dispertire]: https://exercism.org/profiles/habere-et-dispertire
+[pgf-tikz]: https://en.wikipedia.org/wiki/PGF/TikZ

exercises/practice/binary-search-tree/.meta/config.json

@@ -0,0 +1,18 @@
+{
+  "authors": [
+    "glennj"
+  ],
+  "files": {
+    "solution": [
+      "binary_search_tree.moon"
+    ],
+    "test": [
+      "binary_search_tree_spec.moon"
+    ],
+    "example": [
+      ".meta/example.moon"
+    ]
+  },
+  "blurb": "Insert and search for numbers in a binary tree.",
+  "source": "Josh Cheek"
+}

exercises/practice/binary-search-tree/.meta/example.moon

@@ -0,0 +1,26 @@
+class BinarySearchTree
+  new: (items = {}) =>
+    @add item for item in *items
+
+  add: (item) =>
+    if not @value
+      @value = item
+    elseif item <= @value
+      if not @left then @left = @@!
+      @left\add item
+    else
+      if not @right then @right = @@!
+      @right\add item
+
+  data: =>
+    {
+      data: @value
+      left: @left and @left\data! or nil
+      right: @right and @right\data! or nil
+    }
+
+  sorted: (list = {}) =>
+    if @left then @left\sorted list
+    table.insert list, @value
+    if @right then @right\sorted list
+    list

exercises/practice/binary-search-tree/.meta/spec_generator.moon

@@ -0,0 +1,35 @@
+stringx = require 'pl.stringx'
+import dump from require 'moon'
+
+bst = (t, level) ->
+  dumped = dump t
+  dumped = dumped\gsub('%[(.-)%] =', '%1:')
+  lines = [indent line, level for line in *(stringx.splitlines dumped)]
+  table.concat(lines, "\n")\gsub('{%s+}', 'nil')\gsub('^%s+', '')
+
+string_list = (list) ->
+  "{#{table.concat [quote word for word in *list], ', '}}"
+
+
+{
+  module_name: 'BinarySearchTree',
+
+  generate_test: (case, level) ->
+    local lines
+    switch case.property
+      when 'data'
+        lines = {
+          "tree = BinarySearchTree #{string_list case.input.treeData}"
+          "result = tree\\data!"
+          "expected = #{bst case.expected, level}",
+          "assert.are.same expected, result"
+        }
+      when 'sortedData'
+        lines = {
+          "tree = BinarySearchTree #{string_list case.input.treeData}"
+          "result = tree\\sorted!"
+          "expected = #{string_list case.expected}",
+          "assert.are.same expected, result"
+        }
+    table.concat [indent line, level for line in *lines], '\n'
+}

exercises/practice/binary-search-tree/.meta/tests.toml

@@ -0,0 +1,40 @@
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+
+[e9c93a78-c536-4750-a336-94583d23fafa]
+description = "data is retained"
+
+[7a95c9e8-69f6-476a-b0c4-4170cb3f7c91]
+description = "insert data at proper node -> smaller number at left node"
+
+[22b89499-9805-4703-a159-1a6e434c1585]
+description = "insert data at proper node -> same number at left node"
+
+[2e85fdde-77b1-41ed-b6ac-26ce6b663e34]
+description = "insert data at proper node -> greater number at right node"
+
+[dd898658-40ab-41d0-965e-7f145bf66e0b]
+description = "can create complex tree"
+
+[9e0c06ef-aeca-4202-b8e4-97f1ed057d56]
+description = "can sort data -> can sort single number"
+
+[425e6d07-fceb-4681-a4f4-e46920e380bb]
+description = "can sort data -> can sort if second number is smaller than first"
+
+[bd7532cc-6988-4259-bac8-1d50140079ab]
+description = "can sort data -> can sort if second number is same as first"
+
+[b6d1b3a5-9d79-44fd-9013-c83ca92ddd36]
+description = "can sort data -> can sort if second number is greater than first"
+
+[d00ec9bd-1288-4171-b968-d44d0808c1c8]
+description = "can sort data -> can sort complex tree"

exercises/practice/binary-search-tree/binary_search_tree.moon

@@ -0,0 +1,9 @@
+class BinarySearchTree
+  new: (items) =>
+    error 'Implement the constructor'
+
+  data: =>
+    error 'Implement the data method'
+
+  sorted: =>
+    error 'Implement the sorted method'

exercises/practice/binary-search-tree/binary_search_tree_spec.moon

@@ -0,0 +1,120 @@
+BinarySearchTree = require 'binary_search_tree'
+
+describe 'binary-search-tree', ->
+  it 'data is retained', ->
+    tree = BinarySearchTree {'4'}
+    result = tree\data!
+    expected = {
+        right: nil
+        data: "4"
+        left: nil
+    }
+    assert.are.same expected, result
+
+  describe 'insert data at proper node', ->
+    pending 'smaller number at left node', ->
+      tree = BinarySearchTree {'4', '2'}
+      result = tree\data!
+      expected = {
+          right: nil
+          data: "4"
+          left: {
+              right: nil
+              data: "2"
+              left: nil
+          }
+      }
+      assert.are.same expected, result
+
+    pending 'same number at left node', ->
+      tree = BinarySearchTree {'4', '4'}
+      result = tree\data!
+      expected = {
+          right: nil
+          data: "4"
+          left: {
+              right: nil
+              data: "4"
+              left: nil
+          }
+      }
+      assert.are.same expected, result
+
+    pending 'greater number at right node', ->
+      tree = BinarySearchTree {'4', '5'}
+      result = tree\data!
+      expected = {
+          right: {
+              right: nil
+              data: "5"
+              left: nil
+          }
+          data: "4"
+          left: nil
+      }
+      assert.are.same expected, result
+
+  pending 'can create complex tree', ->
+    tree = BinarySearchTree {'4', '2', '6', '1', '3', '5', '7'}
+    result = tree\data!
+    expected = {
+        right: {
+            right: {
+                right: nil
+                data: "7"
+                left: nil
+            }
+            data: "6"
+            left: {
+                right: nil
+                data: "5"
+                left: nil
+            }
+        }
+        data: "4"
+        left: {
+            right: {
+                right: nil
+                data: "3"
+                left: nil
+            }
+            data: "2"
+            left: {
+                right: nil
+                data: "1"
+                left: nil
+            }
+        }
+    }
+    assert.are.same expected, result
+
+  describe 'can sort data', ->
+    pending 'can sort single number', ->
+      tree = BinarySearchTree {'2'}
+      result = tree\sorted!
+      expected = {'2'}
+      assert.are.same expected, result
+
+    pending 'can sort if second number is smaller than first', ->
+      tree = BinarySearchTree {'2', '1'}
+      result = tree\sorted!
+      expected = {'1', '2'}
+      assert.are.same expected, result
+
+    pending 'can sort if second number is same as first', ->
+      tree = BinarySearchTree {'2', '2'}
+      result = tree\sorted!
+      expected = {'2', '2'}
+      assert.are.same expected, result
+
+    pending 'can sort if second number is greater than first', ->
+      tree = BinarySearchTree {'2', '3'}
+      result = tree\sorted!
+      expected = {'2', '3'}
+      assert.are.same expected, result
+
+    pending 'can sort complex tree', ->
+      tree = BinarySearchTree {'2', '1', '3', '6', '7', '5'}
+      result = tree\sorted!
+      expected = {'1', '2', '3', '5', '6', '7'}
+      assert.are.same expected, result