trackler 2.2.1.116 → 2.2.1.117

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0aae28d0f054933886687244d59d5cac2b1e40e2
-  data.tar.gz: 224c04be34690e5137ab56043c4b023631dce533
+  metadata.gz: 86698b18430cbc49e1e2e16167ec6aa9df9cfc40
+  data.tar.gz: c5b5f72aed663aa799b536bd3c79fcba1aeae8c7
 SHA512:
-  metadata.gz: a93c8b0204daf3f7460f2af8f9ce338c46f93a0637eefe73b19b74c74a710c8b3bd407cf4678298bf81051aeb047ae8898ed1511fca6c6f7a73303f04c68a5a0
-  data.tar.gz: 21785aa9e8b63124a89b4535d889da17fc0b265cd2ac1b3ed98c561849f051035d0938bda4eac0224cb49d68b3c0eb877ccb7fb5ad191272ba49ee7ecdb491fc
+  metadata.gz: 537f35ce200183dfda9210b561a74917663cbac1cef101f2958493fe61f905358496e068c2014ad92b6e2dd8962b4e2c96a2dd95f174d65a83265ba25c82058a
+  data.tar.gz: a025234caa3468b897a04e4002591bed0e7b7535fa52cd8920436eacf6ff443ffc3a19cb20a9b25102f63ec5d162ec86c4202fd1d3b17cacacf0d2fc92dde563

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.116"
+  VERSION = "2.2.1.117"
 end

data/tracks/c/config.json

@@ -629,6 +629,31 @@
       ],
       "unlocked_by": "beer-song",
       "uuid": "c1392944-08fd-45c3-b508-41d682f832d3"
+    },
+    {
+      "core": false,
+      "difficulty": 6,
+      "slug": "binary-search-tree",
+      "topics": [
+        "structs",
+        "arrays",
+        "recursion",
+        "control_flow_loops"
+      ],
+      "unlocked_by": "binary-search",
+      "uuid": "1b33f528-8f29-4582-a268-07be2d1a4516"
+    },
+    {
+      "difficulty": 3,
+      "slug": "diamond",
+      "topics": [
+        "arrays",
+        "functions",
+        "strings",
+        "control_flow_if_statements"
+      ],
+      "unlocked_by": "scrabble-score",
+      "uuid": "8605a296-1c67-4723-84ac-3a25d77ed015"
     }
   ],
   "foregone": [],

data/tracks/c/exercises/acronym/makefile

@@ -22,4 +22,4 @@ clean:
 
 tests.out: test/test_acronym.c src/acronym.c src/acronym.h
 	@echo Compiling $@
-	@cc $(CFLAGS) src/acronym.c test/vendor/unity.c test/test_acronym.c -o tests.out
+	@$(CC) $(CFLAGS) src/acronym.c test/vendor/unity.c test/test_acronym.c -o tests.out

data/tracks/c/exercises/all-your-base/makefile

@@ -22,4 +22,4 @@ clean:
 
 tests.out: test/test_all_your_base.c src/all_your_base.c src/all_your_base.h
 	@echo Compiling $@
-	@cc $(CFLAGS) src/all_your_base.c test/vendor/unity.c test/test_all_your_base.c -o tests.out -lm
+	@$(CC) $(CFLAGS) src/all_your_base.c test/vendor/unity.c test/test_all_your_base.c -o tests.out -lm

data/tracks/c/exercises/allergies/makefile

@@ -22,4 +22,4 @@ clean:
 
 tests.out: test/test_allergies.c src/allergies.c src/allergies.h
 	@echo Compiling $@
-	@cc $(CFLAGS) src/allergies.c test/vendor/unity.c test/test_allergies.c -o tests.out
+	@$(CC) $(CFLAGS) src/allergies.c test/vendor/unity.c test/test_allergies.c -o tests.out

data/tracks/c/exercises/anagram/makefile

@@ -22,4 +22,4 @@ clean:
 
 tests.out: test/test_anagram.c src/anagram.c src/anagram.h
 	@echo Compiling $@
-	@cc $(CFLAGS) src/anagram.c test/vendor/unity.c test/test_anagram.c -o tests.out
+	@$(CC) $(CFLAGS) src/anagram.c test/vendor/unity.c test/test_anagram.c -o tests.out

data/tracks/c/exercises/atbash-cipher/makefile

@@ -22,4 +22,4 @@ clean:
 
 tests.out: test/test_atbash_cipher.c src/atbash_cipher.c src/atbash_cipher.h
 	@echo Compiling $@
-	@cc $(CFLAGS) src/atbash_cipher.c test/vendor/unity.c test/test_atbash_cipher.c -o tests.out
+	@$(CC) $(CFLAGS) src/atbash_cipher.c test/vendor/unity.c test/test_atbash_cipher.c -o tests.out

data/tracks/c/exercises/beer-song/makefile

@@ -22,4 +22,4 @@ clean:
 
 tests.out: test/test_beer_song.c src/beer_song.c src/beer_song.h
 	@echo Compiling $@
-	@cc $(CFLAGS) src/beer_song.c test/vendor/unity.c test/test_beer_song.c -o tests.out
+	@$(CC) $(CFLAGS) src/beer_song.c test/vendor/unity.c test/test_beer_song.c -o tests.out

data/tracks/c/exercises/binary-search-tree/README.md

@@ -0,0 +1,53 @@
+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:
+
+      4
+     /
+    2
+
+If we then added 6, it would look like this:
+
+      4
+     / \
+    2   6
+
+If we then added 3, it would look like this
+
+       4
+     /   \
+    2     6
+     \
+      3
+
+And if we then added 1, 5, and 7, it would look like this
+
+          4
+        /   \
+       /     \
+      2       6
+     / \     / \
+    1   3   5   7
+

data/tracks/c/exercises/binary-search-tree/makefile

@@ -0,0 +1,25 @@
+CFLAGS  = -std=c99
+CFLAGS += -g
+CFLAGS += -Wall
+CFLAGS += -Wextra
+CFLAGS += -pedantic
+CFLAGS += -Werror
+
+VFLAGS  = --quiet
+VFLAGS += --tool=memcheck
+VFLAGS += --leak-check=full
+VFLAGS += --error-exitcode=1
+
+test: tests.out
+	@./tests.out
+
+memcheck: tests.out
+	@valgrind $(VFLAGS) ./tests.out
+	@echo "Memory check passed"
+
+clean:
+	rm -rf *.o *.out *.out.dSYM
+
+tests.out: test/test_binary_search_tree.c src/binary_search_tree.c src/binary_search_tree.h
+	@echo Compiling $@
+	@$(CC) $(CFLAGS) src/binary_search_tree.c test/vendor/unity.c test/test_binary_search_tree.c -o tests.out

data/tracks/c/exercises/binary-search-tree/src/example.c

@@ -0,0 +1,102 @@
+#include "binary_search_tree.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#define CHUNK_SIZE 100
+static bool mem_ok;
+static int *parsed_tree;
+static size_t parsed_len;
+
+static void free_tree(node_t * head)
+{
+   if (head == NULL)
+      return;
+   free_tree(head->right);
+   free_tree(head->left);
+   free(head);
+}
+
+static node_t *add_node(node_t * head, int data)
+{
+   if (!mem_ok)
+      return NULL;
+
+   if (head == NULL) {
+      head = malloc(sizeof(node_t));
+      if (head == NULL) {
+         fprintf(stderr, "Memory error!\n");
+         mem_ok = false;
+         return NULL;
+      }
+      head->data = data;
+      head->left = NULL;
+      head->right = NULL;
+
+   } else if (head->data >= data) {
+      head->left = add_node(head->left, data);
+
+   } else if (head->data < data) {
+      head->right = add_node(head->right, data);
+
+   }
+   return head;
+}
+
+static void walk_tree(node_t * head)
+{
+   if (head == NULL || !mem_ok)
+      return;
+
+   walk_tree(head->left);
+   parsed_tree[parsed_len++] = head->data;
+   if (parsed_len % CHUNK_SIZE == 0) {
+      parsed_tree =
+          realloc(parsed_tree, sizeof(int) * (parsed_len + CHUNK_SIZE));
+      if (parsed_tree == NULL) {
+         fprintf(stderr, "Memory error!\n");
+         mem_ok = false;
+         return;
+      }
+   }
+   walk_tree(head->right);
+}
+
+node_t *build_tree(int *tree_data, size_t tree_data_len)
+{
+   if (tree_data == NULL || tree_data_len == 0)
+      return NULL;
+
+   node_t *head = NULL;
+   mem_ok = true;
+   for (size_t i = 0; i < tree_data_len; i++) {
+      node_t *tmp = add_node(head, tree_data[i]);
+      if (tmp == NULL) {
+         free_tree(head);
+         return NULL;
+      }
+      head = tmp;
+   }
+
+   return head;
+}
+
+int *sorted_data(node_t * head)
+{
+   if (head == NULL)
+      return NULL;
+
+   parsed_tree = malloc(sizeof(int) * CHUNK_SIZE);
+   if (parsed_tree == NULL) {
+      fprintf(stderr, "Memory error!\n");
+      return NULL;
+   }
+
+   mem_ok = true;
+   parsed_len = 0;
+   walk_tree(head);
+   if (!mem_ok)
+      return NULL;
+
+   return parsed_tree;
+}

data/tracks/c/exercises/binary-search-tree/src/example.h

@@ -0,0 +1,16 @@
+#ifndef BINARY_SEARCH_TREE_H
+#define BINARY_SEARCH_TREE_H
+#include <stddef.h>
+
+typedef struct node node_t;
+
+struct node {
+   node_t *right;
+   node_t *left;
+   int data;
+};
+
+node_t *build_tree(int *tree_data, size_t tree_data_len);
+int *sorted_data(node_t * tree);
+
+#endif

data/tracks/c/exercises/binary-search-tree/test/test_binary_search_tree.c

@@ -0,0 +1,217 @@
+#include "vendor/unity.h"
+#include "../src/binary_search_tree.h"
+#include <stdlib.h>
+#include <stdbool.h>
+
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0]))
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+static void free_tree(node_t * tree)
+{
+   if (tree == NULL)
+      return;
+   free_tree(tree->left);
+   free_tree(tree->right);
+   free(tree);
+}
+
+void test_data_data_is_retained(void)
+{
+   int tree_data[] = { 4 };
+   node_t *tree = build_tree(tree_data, ARRAY_SIZE(tree_data));
+
+   TEST_ASSERT_NOT_NULL(tree);
+   TEST_ASSERT_EQUAL_INT(4, tree->data);
+   TEST_ASSERT_NULL(tree->left);
+   TEST_ASSERT_NULL(tree->right);
+
+   free_tree(tree);
+}
+
+void test_data_smaller_number_at_left_node(void)
+{
+   TEST_IGNORE();               // delete this line to run test
+   int tree_data[] = { 4, 2 };
+   node_t *tree = build_tree(tree_data, ARRAY_SIZE(tree_data));
+
+   TEST_ASSERT_NOT_NULL(tree);
+   TEST_ASSERT_EQUAL_INT(4, tree->data);
+   TEST_ASSERT_NOT_NULL(tree->left);
+   TEST_ASSERT_NULL(tree->right);
+
+   TEST_ASSERT_EQUAL_INT(2, tree->left->data);
+   TEST_ASSERT_NULL(tree->left->left);
+   TEST_ASSERT_NULL(tree->left->right);
+
+   free_tree(tree);
+}
+
+void test_data_same_number_at_left_node(void)
+{
+   TEST_IGNORE();
+   int tree_data[] = { 4, 4 };
+   node_t *tree = build_tree(tree_data, ARRAY_SIZE(tree_data));
+
+   TEST_ASSERT_NOT_NULL(tree);
+   TEST_ASSERT_EQUAL_INT(4, tree->data);
+   TEST_ASSERT_NOT_NULL(tree->left);
+   TEST_ASSERT_NULL(tree->right);
+
+   TEST_ASSERT_EQUAL_INT(4, tree->left->data);
+   TEST_ASSERT_NULL(tree->left->left);
+   TEST_ASSERT_NULL(tree->left->right);
+
+   free_tree(tree);
+}
+
+void test_data_greater_number_at_right_node(void)
+{
+   TEST_IGNORE();
+   int tree_data[] = { 4, 5 };
+   node_t *tree = build_tree(tree_data, ARRAY_SIZE(tree_data));
+
+   TEST_ASSERT_NOT_NULL(tree);
+   TEST_ASSERT_EQUAL_INT(4, tree->data);
+   TEST_ASSERT_NULL(tree->left);
+   TEST_ASSERT_NOT_NULL(tree->right);
+
+   TEST_ASSERT_EQUAL_INT(5, tree->right->data);
+   TEST_ASSERT_NULL(tree->right->left);
+   TEST_ASSERT_NULL(tree->right->right);
+
+   free_tree(tree);
+}
+
+void test_data_can_create_complex_tree(void)
+{
+   TEST_IGNORE();
+   int tree_data[] = { 4, 2, 6, 1, 3, 5, 7 };
+   node_t *tree = build_tree(tree_data, ARRAY_SIZE(tree_data));
+
+   TEST_ASSERT_NOT_NULL(tree);
+   TEST_ASSERT_EQUAL_INT(4, tree->data);
+   TEST_ASSERT_NOT_NULL(tree->left);
+   TEST_ASSERT_NOT_NULL(tree->right);
+
+   TEST_ASSERT_EQUAL_INT(2, tree->left->data);
+   TEST_ASSERT_NOT_NULL(tree->left->left);
+   TEST_ASSERT_NOT_NULL(tree->left->right);
+
+   TEST_ASSERT_EQUAL_INT(6, tree->right->data);
+   TEST_ASSERT_NOT_NULL(tree->right->left);
+   TEST_ASSERT_NOT_NULL(tree->right->right);
+
+   TEST_ASSERT_EQUAL_INT(1, tree->left->left->data);
+   TEST_ASSERT_NULL(tree->left->left->left);
+   TEST_ASSERT_NULL(tree->left->left->right);
+
+   TEST_ASSERT_EQUAL_INT(3, tree->left->right->data);
+   TEST_ASSERT_NULL(tree->left->right->left);
+   TEST_ASSERT_NULL(tree->left->right->right);
+
+   TEST_ASSERT_EQUAL_INT(5, tree->right->left->data);
+   TEST_ASSERT_NULL(tree->right->left->left);
+   TEST_ASSERT_NULL(tree->right->left->right);
+
+   TEST_ASSERT_EQUAL_INT(7, tree->right->right->data);
+   TEST_ASSERT_NULL(tree->right->right->left);
+   TEST_ASSERT_NULL(tree->right->right->right);
+
+   free_tree(tree);
+}
+
+void test_sorted_data_can_sort_single_number(void)
+{
+   TEST_IGNORE();
+   int tree_data[] = { 2 };
+   node_t *tree = build_tree(tree_data, ARRAY_SIZE(tree_data));
+
+   int expected[] = { 2 };
+   int *actual = sorted_data(tree);
+   TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, ARRAY_SIZE(expected));
+
+   free_tree(tree);
+   free(actual);
+}
+
+void test_sorted_data_can_sort_if_second_number_is_smaller_than_first(void)
+{
+   TEST_IGNORE();
+   int tree_data[] = { 2, 1 };
+   node_t *tree = build_tree(tree_data, ARRAY_SIZE(tree_data));
+
+   int expected[] = { 1, 2 };
+   int *actual = sorted_data(tree);
+   TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, ARRAY_SIZE(expected));
+
+   free_tree(tree);
+   free(actual);
+}
+
+void test_sorted_data_can_sort_if_second_number_is_same_as_first(void)
+{
+   TEST_IGNORE();
+   int tree_data[] = { 2, 2 };
+   node_t *tree = build_tree(tree_data, ARRAY_SIZE(tree_data));
+
+   int expected[] = { 2, 2 };
+   int *actual = sorted_data(tree);
+   TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, ARRAY_SIZE(expected));
+
+   free_tree(tree);
+   free(actual);
+}
+
+void test_sorted_data_can_sort_if_second_number_is_greater_than_first(void)
+{
+   TEST_IGNORE();
+   int tree_data[] = { 2, 3 };
+   node_t *tree = build_tree(tree_data, ARRAY_SIZE(tree_data));
+
+   int expected[] = { 2, 3 };
+   int *actual = sorted_data(tree);
+   TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, ARRAY_SIZE(expected));
+
+   free_tree(tree);
+   free(actual);
+}
+
+void test_sorted_data_can_sort_complex_tree(void)
+{
+   TEST_IGNORE();
+   int tree_data[] = { 2, 1, 3, 6, 7, 5 };
+   node_t *tree = build_tree(tree_data, ARRAY_SIZE(tree_data));
+
+   int expected[] = { 1, 2, 3, 5, 6, 7 };
+   int *actual = sorted_data(tree);
+   TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, ARRAY_SIZE(expected));
+
+   free_tree(tree);
+   free(actual);
+}
+
+int main(void)
+{
+   UnityBegin("test/test_binary_search_tree.c");
+
+   RUN_TEST(test_data_data_is_retained);
+   RUN_TEST(test_data_smaller_number_at_left_node);
+   RUN_TEST(test_data_same_number_at_left_node);
+   RUN_TEST(test_data_greater_number_at_right_node);
+   RUN_TEST(test_data_can_create_complex_tree);
+   RUN_TEST(test_sorted_data_can_sort_single_number);
+   RUN_TEST(test_sorted_data_can_sort_if_second_number_is_smaller_than_first);
+   RUN_TEST(test_sorted_data_can_sort_if_second_number_is_same_as_first);
+   RUN_TEST(test_sorted_data_can_sort_if_second_number_is_greater_than_first);
+   RUN_TEST(test_sorted_data_can_sort_complex_tree);
+
+   UnityEnd();
+   return 0;
+}