Add satellite exercise (exercism#275)

Author: keiravillekode

config.json

@@ -919,6 +919,14 @@
         "practices": [],
         "prerequisites": [],
         "difficulty": 8
+      },
+      {
+        "slug": "satellite",
+        "name": "Satellite",
+        "uuid": "351dfb26-5fd4-447c-a89b-c8f201f6c6bc",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 9
       }
     ]
   },

exercises/practice/satellite/.docs/instructions.md

@@ -0,0 +1,27 @@
+# Instructions
+
+Imagine you need to transmit a binary tree to a satellite approaching Alpha Centauri and you have limited bandwidth.
+Since the tree has no repeating items it can be uniquely represented by its [pre-order and in-order traversals][wiki].
+
+Write the software for the satellite to rebuild the tree from the traversals.
+
+A pre-order traversal reads the value of the current node before (hence "pre") reading the left subtree in pre-order.
+Afterwards the right subtree is read in pre-order.
+
+An in-order traversal reads the left subtree in-order then the current node and finally the right subtree in-order.
+So in order from left to right.
+
+For example the pre-order traversal of this tree is [a, i, x, f, r].
+The in-order traversal of this tree is [i, a, f, x, r]
+
+```text
+  a
+ / \
+i   x
+   / \
+  f   r
+```
+
+Note: the first item in the pre-order traversal is always the root.
+
+[wiki]: https://en.wikipedia.org/wiki/Tree_traversal

exercises/practice/satellite/.meta/config.json

@@ -0,0 +1,17 @@
+{
+  "authors": [
+    "keiravillekode"
+  ],
+  "files": {
+    "solution": [
+      "satellite.v"
+    ],
+    "test": [
+      "run_test.v"
+    ],
+    "example": [
+      ".meta/example.v"
+    ]
+  },
+  "blurb": "Rebuild binary trees from pre-order and in-order traversals."
+}

exercises/practice/satellite/.meta/example.v

@@ -0,0 +1,67 @@
+module main
+
+type Tree = Empty | Node
+
+struct Empty {}
+
+struct Node {
+	left  Tree = Empty{}
+	right Tree = Empty{}
+	value rune
+}
+
+fn tree_from_traversals(preorder string, inorder string) !Tree {
+	mut p := preorder.runes()
+	mut i := inorder.runes()
+	if p.len != i.len {
+		return error('traversals must have the same length')
+	}
+
+	if p.len == 0 {
+		return Empty{}
+	}
+
+	if repeats(p) || repeats(i) {
+		return error('traversals must contain unique items')
+	}
+
+	return traverse(none, mut p, mut i)
+}
+
+fn repeats(r []rune) bool {
+	for i in 1 .. (r.len) {
+		for j in 0 .. i {
+			if r[j] == r[i] {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+fn traverse(successor ?rune, mut preorder []rune, mut inorder []rune) !Tree {
+	if s := successor {
+		if inorder.len > 0 && inorder[0] == s {
+			return Empty{}
+		}
+	}
+
+	if preorder.len == 0 {
+		return Empty{}
+	}
+
+	value := preorder[0]
+	preorder = preorder[1..(preorder.len)]
+
+	left := traverse(value, mut preorder, mut inorder)!
+
+	if inorder.len == 0 || inorder[0] != value {
+		return error('traversals must have the same elements')
+	}
+
+	inorder = inorder[1..(inorder.len)]
+
+	right := traverse(successor, mut preorder, mut inorder)!
+
+	return Node{left, right, value}
+}

exercises/practice/satellite/.meta/tests.toml

@@ -0,0 +1,21 @@
+# This is an auto-generated file. Regular comments will be removed when this
+# file is regenerated. Regenerating will not touch any manually added keys,
+# so comments can be added in a "comment" key.
+
+[8df3fa26-811a-4165-9286-ff9ac0850d19]
+description = "Empty tree"
+
+[f945ccfc-05e3-47d7-825b-0270559d43ad]
+description = "Tree with one item"
+
+[a0121d5f-37b0-48dd-9c64-cba4c4464135]
+description = "Tree with many items"
+
+[6074041f-4891-4d81-a128-401050c2a3b0]
+description = "Reject traversals of different length"
+
+[27916ce4-45f3-4d8b-8528-496fedc157ca]
+description = "Reject inconsistent traversals of same length"
+
+[d86a3d72-76a9-43b5-9d3a-e64cb1216035]
+description = "Reject traversals with repeated items"

exercises/practice/satellite/run_test.v

@@ -0,0 +1,74 @@
+module main
+
+fn test_empty_tree() {
+	preorder := ''
+	inorder := ''
+	expected := fn () Tree {
+		return Empty{}
+	}
+	assert tree_from_traversals(preorder, inorder)! == expected()
+}
+
+fn test_tree_with_one_item() {
+	preorder := 'a'
+	inorder := 'a'
+	expected := fn () Tree {
+		return Node{
+			value: `a`
+		}
+	}
+	assert tree_from_traversals(preorder, inorder)! == expected()
+}
+
+fn test_tree_with_many_items() {
+	preorder := 'aixfr'
+	inorder := 'iafxr'
+	expected := fn () Tree {
+		return Node{
+			left:  Node{
+				value: `i`
+			}
+			right: Node{
+				left:  Node{
+					value: `f`
+				}
+				right: Node{
+					value: `r`
+				}
+				value: `x`
+			}
+			value: `a`
+		}
+	}
+	assert tree_from_traversals(preorder, inorder)! == expected()
+}
+
+fn test_reject_traversals_of_different_length() {
+	preorder := 'ab'
+	inorder := 'bar'
+	if _ := tree_from_traversals(preorder, inorder) {
+		assert false, 'Reject traversals of different length should return an error'
+	} else {
+		assert err.msg() == 'traversals must have the same length'
+	}
+}
+
+fn test_reject_inconsistent_traversals_of_same_length() {
+	preorder := 'xyz'
+	inorder := 'abc'
+	if _ := tree_from_traversals(preorder, inorder) {
+		assert false, 'Reject inconsistent traversals of same length should return an error'
+	} else {
+		assert err.msg() == 'traversals must have the same elements'
+	}
+}
+
+fn test_reject_traversals_with_repeated_items() {
+	preorder := 'aba'
+	inorder := 'baa'
+	if _ := tree_from_traversals(preorder, inorder) {
+		assert false, 'Reject traversals with repeated items should return an error'
+	} else {
+		assert err.msg() == 'traversals must contain unique items'
+	}
+}

exercises/practice/satellite/satellite.v

@@ -0,0 +1,14 @@
+module main
+
+type Tree = Empty | Node
+
+struct Empty {}
+
+struct Node {
+	left  Tree = Empty{}
+	right Tree = Empty{}
+	value rune
+}
+
+fn tree_from_traversals(preorder string, inorder string) !Tree {
+}