trackler 2.2.1.61 → 2.2.1.62

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3084c0fd6f70c36e263665ec8a8e12cec15e09f6
-  data.tar.gz: 8ff04ba30c6a81000a24ccbb0c8c52b5eac97447
+  metadata.gz: 1a6282e44be589af42a98d5eadad3da3614b6645
+  data.tar.gz: b848e7356527fa5be1f4570d65607e7fe44d99c4
 SHA512:
-  metadata.gz: 375777d69e212de58da88cadbc1a21361ab52be35ae2f5afdcd12d363c1ce1ed62e7cbdf0f24cfbd55ebb16fa9c7e06aaa3e3ede36ca97dcd2f30cdb3ac491e2
-  data.tar.gz: 7edba3e24c4d7679b1ef258efc321fe7b1cd3086d8942a88762f0e1a23b28e50f3f47ea3c49bfd559329c8fe35cc68c3d0586be0145143f33d39248de1ff19d5
+  metadata.gz: d59a5c6e8bfc57a717bff31c9d63ff1dcc2b1a14f18ac94f14f50526028ad9c7cb5e115164af39807eaf9eb2c8d575ff8c6e30e700435babdd9b6d77d87ca7aa
+  data.tar.gz: ad2739ff2c636371cf1e6d611f1cb9a21291059e9cde040d111f084267ae45148fa50a8adcda38c363b1d0151146bef8e4da76ac21feece7f2b4dd20525f567c

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.61"
+  VERSION = "2.2.1.62"
 end

data/problem-specifications/exercises/forth/canonical-data.json

@@ -1,6 +1,6 @@
 {
   "exercise": "forth",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "comments": [
     "The cases are split into multiple sections, all with the same structure.",
     "In all cases, the `expected` key is the resulting stack",
@@ -10,12 +10,6 @@
     {
       "description": "parsing and numbers",
       "cases": [
-        {
-          "description": "empty input results in empty stack",
-          "property": "evaluate",
-          "input": [],
-          "expected": []
-        },
         {
           "description": "numbers just get pushed onto the stack",
           "property": "evaluate",

data/problem-specifications/exercises/meetup/description.md

@@ -1,21 +1,25 @@
 Calculate the date of meetups.
 
-Typically meetups happen on the same day of the week.  In this exercise, you will take
-a description of a meetup date, and return the actual meetup date.
+Typically meetups happen on the same day of the week.  In this exercise, you
+will take a description of a meetup date, and return the actual meetup date.
 
 Examples of general descriptions are:
 
-- the first Monday of January 2017
-- the third Tuesday of January 2017
-- the Wednesteenth of January 2017
-- the last Thursday of January 2017
+- The first Monday of January 2017
+- The third Tuesday of January 2017
+- The wednesteenth of January 2017
+- The last Thursday of January 2017
 
-Note that "Monteenth", "Tuesteenth", etc are all made up words. There
-was a meetup whose members realized that there are exactly 7 numbered days in a month that
-end in '-teenth'. Therefore, one is guaranteed that each day of the week
+The descriptors you are expected to parse are:
+first, second, third, fourth, fifth, last, monteenth, tuesteenth, wednesteenth,
+thursteenth, friteenth, saturteenth, sunteenth
+
+Note that "monteenth", "tuesteenth", etc are all made up words. There was a
+meetup whose members realized that there are exactly 7 numbered days in a month
+that end in '-teenth'. Therefore, one is guaranteed that each day of the week
 (Monday, Tuesday, ...) will have exactly one date that is named with '-teenth'
 in every month.
 
-Given examples of a meetup dates, each containing a month, day, year, and descriptor
-(first, second, teenth, etc), calculate the date of the actual meetup.
-For example, if given "First Monday of January 2017", the correct meetup date is 2017/1/2
+Given examples of a meetup dates, each containing a month, day, year, and
+descriptor calculate the date of the actual meetup.  For example, if given
+"The first Monday of January 2017", the correct meetup date is 2017/1/2.

data/problem-specifications/exercises/sum-of-multiples/description.md

@@ -1,7 +1,7 @@
-Given a number, find the sum of all the multiples of particular numbers up to
+Given a number, find the sum of all the unique multiples of particular numbers up to
 but not including that number.
 
-If we list all the natural numbers up to but not including 20 that are
-multiples of either 3 or 5, we get 3, 5, 6 and 9, 10, 12, 15, and 18.
+If we list all the natural numbers below 20 that are multiples of 3 or 5,
+we get 3, 5, 6, 9, 10, 12, 15, and 18.
 
 The sum of these multiples is 78.

data/tracks/c/config.json

@@ -247,7 +247,6 @@
       "slug": "anagram",
       "topics": [
         "filtering",
-        "memory_management",
         "strings",
         "structs"
       ],
@@ -442,6 +441,20 @@
       "unlocked_by": "atbash-cipher",
       "uuid": "55b87cc2-c3a0-438a-b2b6-116ad6356802"
     },
+    {
+      "core": false,
+      "difficulty": 4,
+      "slug": "sublist",
+      "topics": [
+        "pointers",
+        "arrays",
+        "searching",
+        "control_flow_if_statements",
+        "control_flow_loops"
+      ],
+      "unlocked_by": "palindrome-products",
+      "uuid": "928e9860-0df9-5180-8529-7024c991b3616adc21a"
+    },
     {
       "core": false,
       "difficulty": 2,

data/tracks/c/exercises/anagram/src/anagram.h

@@ -3,11 +3,26 @@
 
 #define MAX_STR_LEN 20
 
-struct vector {
-   char (*vec)[MAX_STR_LEN];
-   int size;
+enum anagram_status {
+   UNCHECKED = -1,
+   NOT_ANAGRAM,
+   IS_ANAGRAM
 };
 
-struct vector anagrams_for(char *, struct vector);
+struct candidate {
+   enum anagram_status is_anagram;
+   const char *candidate;
+};
+
+struct candidates {
+   struct candidate *candidate;
+   size_t count;
+};
+
+/**
+ * @description - determines if any of the words in candidate are anagrams
+ *                for word.  Word buffer and candidate structures may be modified.
+ */
+void anagrams_for(const char *word, struct candidates *candidates);
 
 #endif

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

@@ -5,56 +5,43 @@
 
 #include "anagram.h"
 
-char *lower_case(char *p)
+static void to_lower_case(char p[])
 {
-   int len = strlen(p) + 1;
-   char *lower = (char *)malloc(len);
-   memcpy(lower, p, len);
-   p = lower;
-   while (*p) {
-      *p = tolower(*p);
-      p++;
+   char *tmp = p;
+   while (*tmp) {
+      *tmp = tolower(*tmp);
+      tmp++;
    }
-
-   return lower;
 }
 
-int compare(const void *a, const void *b)
+static int compare(const void *a, const void *b)
 {
    return *(const char *)a - *(const char *)b;
 }
 
-struct vector anagrams_for(char *in, struct vector vin)
+void anagrams_for(const char *word, struct candidates *candidates)
 {
-   struct vector vout = {
-      malloc(MAX_STR_LEN * sizeof(char *)),
-      0
-   };
-   char (*vout_vecp)[MAX_STR_LEN] = vout.vec;
-
-   char *lower = lower_case(in);
-   char *sorted = malloc(strlen(in) + 1);
-   memcpy(sorted, lower, strlen(in) + 1);
-   qsort(sorted, strlen(sorted), 1, compare);
-
-   char (*vecp)[MAX_STR_LEN] = vin.vec;
-   int x;
-   for (x = 0; x < vin.size; x++) {
-      char *input_lower = lower_case((char *)vecp);
-      if (strcmp(input_lower, lower) != 0) {
-         char *input_sorted = input_lower;
-         qsort(input_sorted, strlen(input_sorted), 1, compare);
-         if (strcmp(sorted, input_sorted) == 0) {
-            strcpy(*vout_vecp, *vecp);
-            vout_vecp++;
-            vout.size++;
+   char lower_word[MAX_STR_LEN] = { 0 };
+   strncpy(&lower_word[0], word, MAX_STR_LEN);
+   to_lower_case(&lower_word[0]);
+   char sorted_word[MAX_STR_LEN] = { 0 };
+   strncpy(&sorted_word[0], &lower_word[0], MAX_STR_LEN);
+   qsort(&sorted_word, strlen(sorted_word), 1, compare);
+   for (int i = 0; i < (int)candidates->count; i++) {
+      char lower_candidate[MAX_STR_LEN] = { 0 };
+      strncpy(&lower_candidate[0], candidates->candidate[i].candidate,
+              MAX_STR_LEN);
+      to_lower_case(&lower_candidate[0]);
+      if (strcmp(&lower_candidate[0], &lower_word[0]) == 0) {
+         candidates->candidate[i].is_anagram = NOT_ANAGRAM;
+      }
+      if (candidates->candidate[i].is_anagram == UNCHECKED) {
+         qsort(&lower_candidate[0], strlen(&lower_candidate[0]), 1, compare);
+         if (strcmp(&sorted_word[0], &lower_candidate[0]) == 0) {
+            candidates->candidate[i].is_anagram = IS_ANAGRAM;
+         } else {
+            candidates->candidate[i].is_anagram = NOT_ANAGRAM;
          }
       }
-      free(input_lower);
-      vecp++;
    }
-
-   free(lower);
-   free(sorted);
-   return vout;
 }

data/tracks/c/exercises/anagram/test/test_anagram.c

@@ -4,11 +4,9 @@
 #include "vendor/unity.h"
 #include "../src/anagram.h"
 
-// Empty vector for when expected output is nothing
-static struct vector empty = {
-   NULL,
-   0
-};
+#define MAX_STR_LEN 20
+
+struct candidates candidates;
 
 void setUp(void)
 {
@@ -16,25 +14,27 @@ void setUp(void)
 
 void tearDown(void)
 {
+   free(candidates.candidate);
 }
 
-static int stringcmp(const void *a, const void *b)
+static struct candidates build_candidates(char *inputs, size_t count)
 {
-   return strcmp(a, b);
+   struct candidates result;
+   result.count = count;
+   result.candidate = malloc(sizeof(struct candidate) * count);
+   for (int i = 0; i < (int)count; i++) {
+      result.candidate[i].candidate = &inputs[i * MAX_STR_LEN];
+      result.candidate[i].is_anagram = UNCHECKED;
+   }
+
+   return result;
 }
 
-// Asserts that the two input vectors are equal
-static void assert_equal_vector(struct vector vout, struct vector expected)
+static void assert_correct_anagrams(struct candidates *candidates,
+                                    enum anagram_status expected[])
 {
-   // Sort actual and expected outputs for consistency
-   qsort(expected.vec, expected.size, sizeof(char) * MAX_STR_LEN, stringcmp);
-   qsort(vout.vec, vout.size, sizeof(char) * MAX_STR_LEN, stringcmp);
-
-   TEST_ASSERT_EQUAL(expected.size, vout.size);
-   for (int x = 0; x < vout.size; x++) {
-      TEST_ASSERT_EQUAL(strlen(expected.vec[x]), strlen(vout.vec[x]));
-      TEST_ASSERT_EQUAL_MEMORY(expected.vec[x], vout.vec[x],
-                               strlen(expected.vec[x]));
+   for (int i = 0; i < (int)candidates->count; i++) {
+      TEST_ASSERT_EQUAL(expected[i], candidates->candidate[i].is_anagram);
    }
 }
 
@@ -47,14 +47,14 @@ void test_no_matches(void)
       "pants"
    };
 
-   struct vector vin = {
-      inputs,
-      sizeof(inputs) / MAX_STR_LEN
-   };
+   char word[] = { "diaper" };
 
-   struct vector vout = anagrams_for("diaper", vin);
-   assert_equal_vector(vout, empty);
-   free(vout.vec);
+   candidates = build_candidates(*inputs, sizeof(inputs) / MAX_STR_LEN);
+   enum anagram_status expected[] =
+       { NOT_ANAGRAM, NOT_ANAGRAM, NOT_ANAGRAM, NOT_ANAGRAM };
+
+   anagrams_for(word, &candidates);
+   assert_correct_anagrams(&candidates, expected);
 }
 
 void test_detect_simple_anagram(void)
@@ -66,23 +66,14 @@ void test_detect_simple_anagram(void)
       "at"
    };
 
-   char outputs[][MAX_STR_LEN] = {
-      "tan"
-   };
+   char word[] = { "ant" };
 
-   struct vector vin = {
-      inputs,
-      sizeof(inputs) / MAX_STR_LEN
-   };
+   candidates = build_candidates(*inputs, sizeof(inputs) / MAX_STR_LEN);
+   enum anagram_status expected[] = { IS_ANAGRAM, NOT_ANAGRAM, NOT_ANAGRAM };
 
-   struct vector expected = {
-      outputs,
-      sizeof(outputs) / MAX_STR_LEN
-   };
+   anagrams_for(word, &candidates);
+   assert_correct_anagrams(&candidates, expected);
 
-   struct vector vout = anagrams_for("ant", vin);
-   assert_equal_vector(vout, expected);
-   free(vout.vec);
 }
 
 void test_does_not_confuse_different_duplicates(void)
@@ -92,14 +83,13 @@ void test_does_not_confuse_different_duplicates(void)
       "eagle"
    };
 
-   struct vector vin = {
-      inputs,
-      sizeof(inputs) / MAX_STR_LEN
-   };
+   char word[] = { "galea" };
+
+   candidates = build_candidates(*inputs, sizeof(inputs) / MAX_STR_LEN);
+   enum anagram_status expected[] = { NOT_ANAGRAM };
 
-   struct vector vout = anagrams_for("galea", vin);
-   assert_equal_vector(vout, empty);
-   free(vout.vec);
+   anagrams_for(word, &candidates);
+   assert_correct_anagrams(&candidates, expected);
 }
 
 void test_eliminate_anagram_subsets(void)
@@ -110,14 +100,13 @@ void test_eliminate_anagram_subsets(void)
       "goody"
    };
 
-   struct vector vin = {
-      inputs,
-      sizeof(inputs) / MAX_STR_LEN
-   };
+   char word[] = { "good" };
+
+   candidates = build_candidates(*inputs, sizeof(inputs) / MAX_STR_LEN);
+   enum anagram_status expected[] = { NOT_ANAGRAM, NOT_ANAGRAM };
 
-   struct vector vout = anagrams_for("good", vin);
-   assert_equal_vector(vout, empty);
-   free(vout.vec);
+   anagrams_for(word, &candidates);
+   assert_correct_anagrams(&candidates, expected);
 }
 
 void test_detect_anagram(void)
@@ -130,23 +119,14 @@ void test_detect_anagram(void)
       "banana"
    };
 
-   char outputs[][MAX_STR_LEN] = {
-      "inlets"
-   };
-
-   struct vector vin = {
-      inputs,
-      sizeof(inputs) / MAX_STR_LEN
-   };
+   char word[] = { "listen" };
 
-   struct vector expected = {
-      outputs,
-      sizeof(outputs) / MAX_STR_LEN
-   };
+   candidates = build_candidates(*inputs, sizeof(inputs) / MAX_STR_LEN);
+   enum anagram_status expected[] =
+       { NOT_ANAGRAM, NOT_ANAGRAM, IS_ANAGRAM, NOT_ANAGRAM };
 
-   struct vector vout = anagrams_for("listen", vin);
-   assert_equal_vector(vout, expected);
-   free(vout.vec);
+   anagrams_for(word, &candidates);
+   assert_correct_anagrams(&candidates, expected);
 }
 
 void test_multiple_anagrams(void)
@@ -161,25 +141,16 @@ void test_multiple_anagrams(void)
       "leading"
    };
 
-   char outputs[][MAX_STR_LEN] = {
-      "gallery",
-      "regally",
-      "largely"
-   };
-
-   struct vector vin = {
-      inputs,
-      sizeof(inputs) / MAX_STR_LEN
-   };
+   char word[] = { "allergy" };
 
-   struct vector expected = {
-      outputs,
-      sizeof(outputs) / MAX_STR_LEN
+   candidates = build_candidates(*inputs, sizeof(inputs) / MAX_STR_LEN);
+   enum anagram_status expected[] =
+       { IS_ANAGRAM, NOT_ANAGRAM, IS_ANAGRAM, NOT_ANAGRAM, IS_ANAGRAM,
+      NOT_ANAGRAM
    };
 
-   struct vector vout = anagrams_for("allergy", vin);
-   assert_equal_vector(vout, expected);
-   free(vout.vec);
+   anagrams_for(word, &candidates);
+   assert_correct_anagrams(&candidates, expected);
 }
 
 void test_case_insensitive_anagrams(void)
@@ -191,105 +162,82 @@ void test_case_insensitive_anagrams(void)
       "radishes"
    };
 
-   char outputs[][MAX_STR_LEN] = {
-      "Carthorse"
-   };
-
-   struct vector vin = {
-      inputs,
-      sizeof(inputs) / MAX_STR_LEN
-   };
+   char word[] = { "Orchestra" };
 
-   struct vector expected = {
-      outputs,
-      sizeof(outputs) / MAX_STR_LEN
-   };
+   candidates = build_candidates(*inputs, sizeof(inputs) / MAX_STR_LEN);
+   enum anagram_status expected[] = { NOT_ANAGRAM, IS_ANAGRAM, NOT_ANAGRAM };
 
-   struct vector vout = anagrams_for("Orchestra", vin);
-   assert_equal_vector(vout, expected);
-   free(vout.vec);
+   anagrams_for(word, &candidates);
+   assert_correct_anagrams(&candidates, expected);
 }
 
-void test_unicode_anagrams(void)
+void test_does_not_detect_a_word_as_its_own_anagram(void)
 {
    TEST_IGNORE();
-   // These words don't make sense, they're just greek letters cobbled together.
    char inputs[][MAX_STR_LEN] = {
-      "ΒΓΑ",
-      "ΒΓΔ",
-      "γβα"
-   };
-
-   char outputs[][MAX_STR_LEN] = {
-      "ΒΓΑ"
+      "banana"
    };
 
-   struct vector vin = {
-      inputs,
-      sizeof(inputs) / MAX_STR_LEN
-   };
+   char word[] = { "banana" };
 
-   struct vector expected = {
-      outputs,
-      sizeof(outputs) / MAX_STR_LEN
-   };
+   candidates = build_candidates(*inputs, sizeof(inputs) / MAX_STR_LEN);
+   enum anagram_status expected[] = { NOT_ANAGRAM };
 
-   struct vector vout = anagrams_for("ΑΒΓ", vin);
-   assert_equal_vector(vout, expected);
-   free(vout.vec);
+   anagrams_for(word, &candidates);
+   assert_correct_anagrams(&candidates, expected);
 }
 
-void test_misleading_unicode_anagrams(void)
+void test_does_not_detect_a_differently_cased_word_as_its_own_anagram(void)
 {
    TEST_IGNORE();
-   // Despite what a human might think these words different letters, the input uses Greek A and B
-   // while the list of potential anagrams uses Latin A and B.
    char inputs[][MAX_STR_LEN] = {
-      "ABΓ"
+      "bAnana"
    };
 
-   struct vector vin = {
-      inputs,
-      sizeof(inputs) / MAX_STR_LEN
-   };
+   char word[] = { "banana" };
+
+   candidates = build_candidates(*inputs, sizeof(inputs) / MAX_STR_LEN);
+   enum anagram_status expected[] = { NOT_ANAGRAM };
 
-   struct vector vout = anagrams_for("ΑΒΓ", vin);
-   assert_equal_vector(vout, empty);
-   free(vout.vec);
+   anagrams_for(word, &candidates);
+   assert_correct_anagrams(&candidates, expected);
 }
 
-void test_does_not_detect_a_word_as_its_own_anagram(void)
+void test_unicode_anagrams(void)
 {
-   TEST_IGNORE();
+   TEST_IGNORE();               // This is an extra credit test.  Delete this line to accept the challenge
+   // These words don't make sense, they're just greek letters cobbled together.
    char inputs[][MAX_STR_LEN] = {
-      "banana"
+      "ΒΓΑ",
+      "ΒΓΔ",
+      "γβα"
    };
 
-   struct vector vin = {
-      inputs,
-      sizeof(inputs) / MAX_STR_LEN
-   };
+   char word[] = { "ΑΒΓ" };
+
+   candidates = build_candidates(*inputs, sizeof(inputs) / MAX_STR_LEN);
+   enum anagram_status expected[] = { IS_ANAGRAM, NOT_ANAGRAM, NOT_ANAGRAM };
 
-   struct vector vout = anagrams_for("banana", vin);
-   assert_equal_vector(vout, empty);
-   free(vout.vec);
+   anagrams_for(word, &candidates);
+   assert_correct_anagrams(&candidates, expected);
 }
 
-void test_does_not_detect_a_differently_cased_word_as_its_own_anagram(void)
+void test_misleading_unicode_anagrams(void)
 {
-   TEST_IGNORE();
+   TEST_IGNORE();               //This is an extra credit test, are you up for the challenge
+   // Despite what a human might think these words different letters, the input uses Greek A and B
+   // while the list of potential anagrams uses Latin A and B.
    char inputs[][MAX_STR_LEN] = {
-      "bAnana"
+      "ABΓ"
    };
 
-   struct vector vin = {
-      inputs,
-      sizeof(inputs) / MAX_STR_LEN
-   };
+   char word[] = { "ΑΒΓ" };
+
+   candidates = build_candidates(*inputs, sizeof(inputs) / MAX_STR_LEN);
+   enum anagram_status expected[] = { NOT_ANAGRAM };
 
-   struct vector vout = anagrams_for("banana", vin);
-   assert_equal_vector(vout, empty);
-   free(vout.vec);
+   anagrams_for(word, &candidates);
+   assert_correct_anagrams(&candidates, expected);
 }
 
 int main(void)
@@ -307,8 +255,8 @@ int main(void)
    RUN_TEST(test_does_not_detect_a_differently_cased_word_as_its_own_anagram);
 
    // Bonus points
-   // RUN_TEST(test_unicode_anagrams);
-   // RUN_TEST(test_misleading_unicode_anagrams);
+   RUN_TEST(test_unicode_anagrams);
+   RUN_TEST(test_misleading_unicode_anagrams);
 
    UnityEnd();
    return 0;