trackler 2.2.1.111 → 2.2.1.113

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 01d8bfdb5552025a07daa9c37f86e06af88cbf3e
-  data.tar.gz: 9ba7233e30a1774861a44b0da783675cd792cea8
+  metadata.gz: 0e4e17fbfd6725286f53a29a3080230bef5b3dcd
+  data.tar.gz: 699cefe1dddc600e28ca10c11b903b6914fc94a1
 SHA512:
-  metadata.gz: d713b6f1d0df102bebd1a8f3eb9a5467464527d54a758fd3fa662ab4f8ddeb1b4fa218556c57e44a19aa45ef7dff10da8fe3069b90ede3b7660bffa9831f6422
-  data.tar.gz: bd11a04b89ff78e87f44015621ddc02abd8ed7409f0263983c59a0860e9d3da5041492617655a4055c2639af23824b5e2595ab1bfce3d34db740a66b9ec31666
+  metadata.gz: 9d8bd5fa9fa3ecd2797859ee707f79f03fe034d500cdea054b2d260c89dc75394f0a597ee98376e190a6a43b82138ebefefad9e3beeb5cddf582ef6bb374a480
+  data.tar.gz: 9c1ef17519b4a583c0db16c842619f7f33fae053dd845f09cdab449547b0d33c53a61b31adeea1c657e4d6c468c6341175a5f3a11100704f32d6cf4fb2621b3b

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.111"
+  VERSION = "2.2.1.113"
 end

data/problem-specifications/README.md

@@ -66,7 +66,9 @@ is easier to understand with an example:
           ]
       , "description": "Foo'ing a word returns it reversed"
       , "property"   : "foo"
-      , "input"      : "lion"
+      , "input"      : {
+          "word"       : "lion"
+        }
       , "expected"   : "noil"
       }
     , { "description": "Bar'ing a name returns its parts combined"
@@ -85,7 +87,9 @@ is easier to understand with an example:
       , "cases":
           [ { "description": "Foo'ing a number returns nothing"
             , "property"   : "foo"
-            , "input"      : "42"
+            , "input"      : {
+                "word"       : "42"
+              }
             , "expected"   : null
             }
           , { "description": "Bar'ing a name with numbers gives an error"

data/problem-specifications/exercises/go-counting/canonical-data.json

@@ -0,0 +1,200 @@
+{
+  "exercise": "go-counting",
+  "version": "1.0.0",
+  "comments": [
+    "Territory consists of [x, y] coordinate pairs."
+  ],
+  "cases": [
+    {
+      "description": "Black corner territory on 5x5 board",
+      "property": "territory",
+      "input": {
+        "board": [
+          "  B  ",
+          " B B ",
+          "B W B",
+          " W W ",
+          "  W  "
+        ],
+        "x": 0,
+        "y": 1
+      },
+      "expected": {
+        "owner": "BLACK",
+        "territory": [[0, 0], [0, 1], [1, 0]]
+      }
+    },
+    {
+      "description": "White center territory on 5x5 board",
+      "property": "territory",
+      "input": {
+        "board": [
+          "  B  ",
+          " B B ",
+          "B W B",
+          " W W ",
+          "  W  "
+        ],
+        "x": 2,
+        "y": 3
+      },
+      "expected": {
+        "owner": "WHITE",
+        "territory": [[2, 3]]
+      }
+    },
+    {
+      "description": "Open corner territory on 5x5 board",
+      "property": "territory",
+      "input": {
+        "board": [
+          "  B  ",
+          " B B ",
+          "B W B",
+          " W W ",
+          "  W  "
+        ],
+        "x": 1,
+        "y": 4
+      },
+      "expected": {
+        "owner": "NONE",
+        "territory": [[0, 3], [0, 4], [1, 4]]
+      }
+    },
+    {
+      "description": "A stone and not a territory on 5x5 board",
+      "property": "territory",
+      "input": {
+        "board": [
+          "  B  ",
+          " B B ",
+          "B W B",
+          " W W ",
+          "  W  "
+        ],
+        "x": 1,
+        "y": 1
+      },
+      "expected": {
+        "owner": "NONE",
+        "territory": []
+      }
+    },
+    {
+      "description": "Invalid because X is too low for 5x5 board",
+      "property": "territory",
+      "input": {
+        "board": [
+          "  B  ",
+          " B B ",
+          "B W B",
+          " W W ",
+          "  W  "
+        ],
+        "x": -1,
+        "y": 1
+      },
+      "expected": {
+        "error": "Invalid coordinate"
+      }
+    },
+    {
+      "description": "Invalid because X is too high for 5x5 board",
+      "property": "territory",
+      "input": {
+        "board": [
+          "  B  ",
+          " B B ",
+          "B W B",
+          " W W ",
+          "  W  "
+        ],
+        "x": 5,
+        "y": 1
+      },
+      "expected": {
+        "error": "Invalid coordinate"
+      }
+    },
+    {
+      "description": "Invalid because Y is too low for 5x5 board",
+      "property": "territory",
+      "input": {
+        "board": [
+          "  B  ",
+          " B B ",
+          "B W B",
+          " W W ",
+          "  W  "
+        ],
+        "x": 1,
+        "y": -1
+      },
+      "expected": {
+        "error": "Invalid coordinate"
+      }
+    },
+    {
+      "description": "Invalid because Y is too high for 5x5 board",
+      "property": "territory",
+      "input": {
+        "board": [
+          "  B  ",
+          " B B ",
+          "B W B",
+          " W W ",
+          "  W  "
+        ],
+        "x": 1,
+        "y": 5
+      },
+      "expected": {
+        "error": "Invalid coordinate"
+      }
+    },
+    {
+      "description": "One territory is the whole board",
+      "property": "territories",
+      "input": {
+        "board": [
+          " "
+        ]
+      },
+      "expected": {
+        "territoryBlack": [],
+        "territoryWhite": [],
+        "territoryNone": [[0, 0]]
+      }
+    },
+    {
+      "description": "Two territory rectangular board",
+      "property": "territories",
+      "input": {
+        "board": [
+          " BW ",
+          " BW "
+        ]
+      },
+      "expected": {
+        "territoryBlack": [[0, 0], [0, 1]],
+        "territoryWhite": [[3, 0], [3, 1]],
+        "territoryNone": []
+      }
+    },
+    {
+      "description": "Two region rectangular board",
+      "property": "territories",
+      "input": {
+        "board": [
+          " B "
+        ]
+      },
+      "expected": {
+        "territoryBlack": [[0, 0], [2, 0]],
+        "territoryWhite": [],
+        "territoryNone": []
+      }
+    }
+  ]
+}

data/problem-specifications/exercises/go-counting/description.md

@@ -9,6 +9,8 @@ Write a function that determines the territory of each player. You may
 assume that any stones that have been stranded in enemy territory have
 already been taken off the board.
 
+Write a function that determines the territory which includes a specified coordinate.
+
 Multiple empty intersections may be encircled at once and for encircling
 only horizontal and vertical neighbours count. In the following diagram
 the stones which matter are marked "O" and the stones that don't are

data/tracks/c/config.json

@@ -581,6 +581,30 @@
       ],
       "unlocked_by": "hamming",
       "uuid": "62f539e7-f682-412d-bf86-38503e7cebca"
+    },
+    {
+      "core": false,
+      "difficulty": 3,
+      "slug": "minesweeper",
+      "topics": [
+        "strings",
+        "arrays",
+        "control_flow_if_statements"
+      ],
+      "unlocked_by": "scrabble-score",
+      "uuid": "2e97072f-9e77-4ddd-9d75-6162a927bab1"
+    },
+    {
+      "core": false,
+      "difficulty": 4,
+      "slug": "run-length-encoding",
+      "topics": [
+        "algorithms",
+        "strings",
+        "control_flow_if_statements"
+      ],
+      "unlocked_by": "atbash-cipher",
+      "uuid": "b22152b9-99d1-411c-8cf2-f89e8f5f8141"
     }
   ],
   "foregone": [],

data/tracks/c/exercises/minesweeper/README.md

@@ -0,0 +1,26 @@
+Add the numbers to a minesweeper board.
+
+Minesweeper is a popular game where the user has to find the mines using
+numeric hints that indicate how many mines are directly adjacent
+(horizontally, vertically, diagonally) to a square.
+
+In this exercise you have to create some code that counts the number of
+mines adjacent to a square and transforms boards like this (where `*`
+indicates a mine):
+
+    +-----+
+    | * * |
+    |  *  |
+    |  *  |
+    |     |
+    +-----+
+
+into this:
+
+    +-----+
+    |1*3*1|
+    |13*31|
+    | 2*2 |
+    | 111 |
+    +-----+
+

data/tracks/c/exercises/minesweeper/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_minesweeper.c src/minesweeper.c src/minesweeper.h
+	@echo Compiling $@
+	@cc $(CFLAGS) src/minesweeper.c test/vendor/unity.c test/test_minesweeper.c -o tests.out

data/tracks/c/exercises/minesweeper/src/example.c

@@ -0,0 +1,64 @@
+#include "minesweeper.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+static void set_single_field(char **minefield, const size_t row,
+                             const size_t col)
+{
+   if (minefield[row][col] == '*')
+      return;
+
+   const char c = minefield[row][col];
+   minefield[row][col] = (c == ' ') ? '1' : c + 1;
+}
+
+static void increment_neighbors(char **minefield, const size_t row_count,
+                                const size_t col_count, const size_t row,
+                                const size_t col)
+{
+   const size_t from_row = row ? row - 1 : row;
+   const size_t to_row = (row + 1 < row_count) ? row + 1 : row;
+   const size_t from_col = col ? col - 1 : col;
+   const size_t to_col = (col + 1 < col_count) ? col + 1 : col;
+
+   for (size_t i = from_row; i <= to_row; i++) {
+      for (size_t k = from_col; k <= to_col; k++)
+         set_single_field(minefield, i, k);
+   }
+}
+
+char **annotate(const char **minefield, const size_t rows)
+{
+   if (minefield == NULL || *minefield == NULL || rows == 0)
+      return NULL;
+
+   const size_t cols = strlen(minefield[0]);
+
+   char **annotated = malloc(sizeof(char *) * rows);
+   if (annotated == NULL) {
+      fprintf(stderr, "Memory error!\n");
+      return NULL;
+   }
+
+   char *all_rows = malloc(rows * (cols + 1));
+   if (all_rows == NULL) {
+      fprintf(stderr, "Memory error!\n");
+      free(annotated);
+      return NULL;
+   }
+
+   for (size_t i = 0; i < rows; i++) {
+      annotated[i] = &all_rows[i * (cols + 1)];
+      strcpy(annotated[i], minefield[i]);
+   }
+
+   for (size_t i = 0; i < rows; i++) {
+      for (size_t k = 0; k < cols; k++) {
+         if (minefield[i][k] == '*')
+            increment_neighbors(annotated, rows, cols, i, k);
+      }
+   }
+
+   return annotated;
+}

data/tracks/c/exercises/minesweeper/src/example.h

@@ -0,0 +1,7 @@
+#ifndef MINESWEEPER_H
+#define MINESWEEPER_H
+#include <stddef.h>
+
+char **annotate(const char **minefield, const size_t rows);
+
+#endif

data/tracks/c/exercises/minesweeper/test/test_minesweeper.c

@@ -0,0 +1,261 @@
+#include "vendor/unity.h"
+#include "../src/minesweeper.h"
+#include <stdlib.h>
+
+#define ARRAY_SIZE(arr) (sizeof(arr)/sizeof(arr[0]))
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+static void free_all(char **field)
+{
+   free(field[0]);
+   free(field);
+}
+
+void test_annotate_no_rows(void)
+{
+   const char **minefield = NULL;
+   const size_t rows = 0;
+   char **actual = annotate(minefield, rows);
+   TEST_ASSERT_NULL(actual);
+}
+
+void test_annotate_no_columns(void)
+{
+   TEST_IGNORE();               // delete this line to run test
+   const char *minefield[] = {
+      ""
+   };
+   const char *expected[] = { "" };
+   const size_t rows = ARRAY_SIZE(expected);
+   char **actual = annotate(minefield, rows);
+   TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, rows);
+   free_all(actual);
+}
+
+void test_annotate_no_mines(void)
+{
+   TEST_IGNORE();
+   const char *minefield[] = {
+      "   ",
+      "   ",
+      "   "
+   };
+   const char *expected[] = {
+      "   ",
+      "   ",
+      "   "
+   };
+   const size_t rows = ARRAY_SIZE(expected);
+   char **actual = annotate(minefield, rows);
+   TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, rows);
+   free_all(actual);
+}
+
+void test_annotate_minefield_with_only_mines(void)
+{
+   TEST_IGNORE();
+   const char *minefield[] = {
+      "***",
+      "***",
+      "***"
+   };
+   const char *expected[] = {
+      "***",
+      "***",
+      "***"
+   };
+   const size_t rows = ARRAY_SIZE(expected);
+   char **actual = annotate(minefield, rows);
+   TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, rows);
+   free_all(actual);
+}
+
+void test_annotate_mine_surrounded_by_spaces(void)
+{
+   TEST_IGNORE();
+   const char *minefield[] = {
+      "   ",
+      " * ",
+      "   "
+   };
+   const char *expected[] = {
+      "111",
+      "1*1",
+      "111"
+   };
+   const size_t rows = ARRAY_SIZE(expected);
+   char **actual = annotate(minefield, rows);
+   TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, rows);
+   free_all(actual);
+}
+
+void test_annotate_space_surrounded_by_mines(void)
+{
+   TEST_IGNORE();
+   const char *minefield[] = {
+      "***",
+      "* *",
+      "***"
+   };
+   const char *expected[] = {
+      "***",
+      "*8*",
+      "***"
+   };
+   const size_t rows = ARRAY_SIZE(expected);
+   char **actual = annotate(minefield, rows);
+   TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, rows);
+   free_all(actual);
+}
+
+void test_annotate_horizontal_line(void)
+{
+   TEST_IGNORE();
+   const char *minefield[] = {
+      " * * "
+   };
+   const char *expected[] = {
+      "1*2*1"
+   };
+   const size_t rows = ARRAY_SIZE(expected);
+   char **actual = annotate(minefield, rows);
+   TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, rows);
+   free_all(actual);
+}
+
+void test_annotate_horizontal_line_mines_at_edges(void)
+{
+   TEST_IGNORE();
+   const char *minefield[] = {
+      "*   *"
+   };
+   const char *expected[] = {
+      "*1 1*"
+   };
+   const size_t rows = ARRAY_SIZE(expected);
+   char **actual = annotate(minefield, rows);
+   TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, rows);
+   free_all(actual);
+}
+
+void test_annotate_vertical_line(void)
+{
+   TEST_IGNORE();
+   const char *minefield[] = {
+      " ",
+      "*",
+      " ",
+      "*",
+      " "
+   };
+   const char *expected[] = {
+      "1",
+      "*",
+      "2",
+      "*",
+      "1"
+   };
+   const size_t rows = ARRAY_SIZE(expected);
+   char **actual = annotate(minefield, rows);
+   TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, rows);
+   free_all(actual);
+}
+
+void test_annotate_vertical_line_mines_at_edges(void)
+{
+   TEST_IGNORE();
+   const char *minefield[] = {
+      "*",
+      " ",
+      " ",
+      " ",
+      "*"
+   };
+   const char *expected[] = {
+      "*",
+      "1",
+      " ",
+      "1",
+      "*"
+   };
+   const size_t rows = ARRAY_SIZE(expected);
+   char **actual = annotate(minefield, rows);
+   TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, rows);
+   free_all(actual);
+}
+
+void test_annotate_cross(void)
+{
+   TEST_IGNORE();
+   const char *minefield[] = {
+      "  *  ",
+      "  *  ",
+      "*****",
+      "  *  ",
+      "  *  "
+   };
+   const char *expected[] = {
+      " 2*2 ",
+      "25*52",
+      "*****",
+      "25*52",
+      " 2*2 "
+   };
+   const size_t rows = ARRAY_SIZE(expected);
+   char **actual = annotate(minefield, rows);
+   TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, rows);
+   free_all(actual);
+}
+
+void test_annotate_large_minefield(void)
+{
+   TEST_IGNORE();
+   const char *minefield[] = {
+      " *  * ",
+      "  *   ",
+      "    * ",
+      "   * *",
+      " *  * ",
+      "      "
+   };
+   const char *expected[] = {
+      "1*22*1",
+      "12*322",
+      " 123*2",
+      "112*4*",
+      "1*22*2",
+      "111111"
+   };
+   const size_t rows = ARRAY_SIZE(expected);
+   char **actual = annotate(minefield, rows);
+   TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, rows);
+   free_all(actual);
+}
+
+int main(void)
+{
+   UnityBegin("test/test_minesweeper.c");
+
+   RUN_TEST(test_annotate_no_rows);
+   RUN_TEST(test_annotate_no_columns);
+   RUN_TEST(test_annotate_no_mines);
+   RUN_TEST(test_annotate_minefield_with_only_mines);
+   RUN_TEST(test_annotate_mine_surrounded_by_spaces);
+   RUN_TEST(test_annotate_space_surrounded_by_mines);
+   RUN_TEST(test_annotate_horizontal_line);
+   RUN_TEST(test_annotate_horizontal_line_mines_at_edges);
+   RUN_TEST(test_annotate_vertical_line);
+   RUN_TEST(test_annotate_vertical_line_mines_at_edges);
+   RUN_TEST(test_annotate_cross);
+   RUN_TEST(test_annotate_large_minefield);
+
+   UnityEnd();
+   return 0;
+}