Add binary-search-tree

Makefile

@@ -69,11 +69,14 @@ copy-exercise:
         	cp exercises/practice/$(EXERCISE)/tests/*.res $(OUTDIR)/tests/; \
 	fi
 
-# copy build artifacts for testing
-copy-all-exercises:
-	@echo "Copying exercises for testing..."
+# Ensure the root build directories exist
+ensure-build-dirs-exist:
 	@mkdir -p $(OUTDIR)/src
 	@mkdir -p $(OUTDIR)/tests
+
+# copy build artifacts for testing
+copy-all-exercises: ensure-build-dirs-exist
+	@echo "Copying exercises for testing..."
 	@for exercise in $(EXERCISES); do EXERCISE=$$exercise $(MAKE) -s copy-exercise || exit 1; done
 
 # Remove the OUTDIR
@@ -87,18 +90,18 @@ format:
 	@find . -name "node_modules" -prune -o -name "*.res" -print -o -name "*.resi" -print | xargs npx rescript format
 
 # Generate tests for all exercises
-generate-tests:
+generate-tests: ensure-build-dirs-exist
 	@echo "Generating tests from test_templates directory..."
 	@for template in $(wildcard test_templates/*_template.res.js); do \
 		echo "-> Running template: $$template"; \
 		node $$template || exit 1; \
 	done
-	@echo "Formatting files"
-	npm run res:format-fix
+	@echo "Formatting tests"
+	@npx rescript format exercises/practice/*/tests/*_test.res
 	@echo "All tests generated and formatted successfully."
 
 # Generate test for exercise
-generate-test:
+generate-test: ensure-build-dirs-exist
 ifeq ($(EXERCISE),)
 	$(error EXERCISE variable is required. usage: make generate-test EXERCISE=hello-world)
 endif
@@ -114,7 +117,7 @@ endif
 
 	@echo "-> Running template: test_templates/$(PASCAL_EXERCISE)_template.res.js"
 	@node test_templates/$(PASCAL_EXERCISE)_template.res.js || exit 1
-	npm run res:format-fix
+	npx rescript format exercises/practice/$(EXERCISE)/tests/$(PASCAL_EXERCISE)_test.res
 
 # Test a single exercise - e.g. make test-one EXERCISE=eliuds-eggs
 test-one:
@@ -126,4 +129,4 @@ test:
 	$(MAKE) -s clean
 	$(MAKE) -s check-exercise-files
 	$(MAKE) -s copy-all-exercises
-	npm run ci
+	npm run ci

bin/check-generated-tests-in-sync

@@ -5,6 +5,8 @@
 
 set -euo pipefail
 
+make ensure-build-dirs-exist
+
 npm run res:build
 make generate-tests
 

config.json

@@ -229,6 +229,14 @@
         "prerequisites": [],
         "difficulty": 4
       },
+      {
+        "slug": "binary-search-tree",
+        "name": "Binary Search Tree",
+        "uuid": "ce828ef4-9242-41b4-894a-92029dfdbd42",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 5
+      },
       {
         "slug": "change",
         "name": "Change",

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

@@ -0,0 +1,70 @@
+# Description
+
+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/.gitignore

@@ -0,0 +1,2 @@
+node_modules
+**/*.res.js

exercises/practice/binary-search-tree/.meta/BinarySearchTree.res

@@ -0,0 +1,20 @@
+type rec tree =
+  | EmptyTree
+  | TreeNode({value: int, left: tree, right: tree})
+
+let rec insert = (tree, newValue) =>
+  switch tree {
+  | EmptyTree => TreeNode({value: newValue, left: EmptyTree, right: EmptyTree})
+  | TreeNode(node) if newValue <= node.value =>
+    TreeNode({...node, left: insert(node.left, newValue)})
+  | TreeNode(node) => TreeNode({...node, right: insert(node.right, newValue)})
+  }
+
+let binarySearchTree = values => values->Array.reduce(EmptyTree, insert)
+
+let rec sortedData = tree =>
+  switch tree {
+  | EmptyTree => []
+  | TreeNode({value, left, right}) =>
+    Array.concat(Array.concat(sortedData(left), [value]), sortedData(right))
+  }

exercises/practice/binary-search-tree/.meta/BinarySearchTree.resi

@@ -0,0 +1,6 @@
+type rec tree =
+  | EmptyTree
+  | TreeNode({value: int, left: tree, right: tree})
+
+let binarySearchTree: array<int> => tree
+let sortedData: tree => array<int>

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

@@ -0,0 +1,20 @@
+{
+  "authors": [
+    "BNAndras"
+  ],
+  "files": {
+    "solution": [
+      "src/BinarySearchTree.res",
+      "src/BinarySearchTree.resi"
+    ],
+    "test": [
+      "tests/BinarySearchTree_test.res"
+    ],
+    "example": [
+      ".meta/BinarySearchTree.res",
+      ".meta/BinarySearchTree.resi"
+    ]
+  },
+  "blurb": "Insert and search for numbers in a binary tree.",
+  "source": "Josh Cheek"
+}

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 = "smaller number at left node"
+
+[22b89499-9805-4703-a159-1a6e434c1585]
+description = "same number at left node"
+
+[2e85fdde-77b1-41ed-b6ac-26ce6b663e34]
+description = "greater number at right node"
+
+[dd898658-40ab-41d0-965e-7f145bf66e0b]
+description = "can create complex tree"
+
+[9e0c06ef-aeca-4202-b8e4-97f1ed057d56]
+description = "can sort single number"
+
+[425e6d07-fceb-4681-a4f4-e46920e380bb]
+description = "can sort if second number is smaller than first"
+
+[bd7532cc-6988-4259-bac8-1d50140079ab]
+description = "can sort if second number is same as first"
+
+[b6d1b3a5-9d79-44fd-9013-c83ca92ddd36]
+description = "can sort if second number is greater than first"
+
+[d00ec9bd-1288-4171-b968-d44d0808c1c8]
+description = "can sort complex tree"

exercises/practice/binary-search-tree/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Exercism
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.