trackler 2.2.1.43 → 2.2.1.44

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 34df3f47653a28428d9f5588ab2f351e03a061d8
-  data.tar.gz: c8a16096a4baaa4da33666a818d1f7ab231e3934
+  metadata.gz: 714ae73cefc7a2a7e1951109345f0990d0965f43
+  data.tar.gz: 0ba267cd29b36ca834b159d90b915015260f77f5
 SHA512:
-  metadata.gz: 4fcb85a26186da30f62ffbe241a7ee2f5dd79bb577948a23e1edbe871765eb17a295336d7504d796254ad71630dc0b92387e2c2ce526d38fb4f0bc44e098c1cb
-  data.tar.gz: c3ec3d29c0520e8de6a8cfd0330671d0eecebeeed90bfdfeaf041ea2cae79fa5280703df38eaee744cb62cceea96393cc8dbda4494c435c37ab185abad46a366
+  metadata.gz: 84549ff0c9b5ec4287fe2f4fae35d22f2ffcd8cc8bd5441bae7a255bdaa7667cde0947a9c623a22d8447bda433c07fe56bf3ab17c7c3c34a372ac71781f3378a
+  data.tar.gz: 29834346cd14bf9bed64b0843c918eeb78277e8f7424664a00ac1a7cd14220c32526c1496c9ca8b0951153ea251f739f28d64710450488b67a6ba6c6302b757b

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.43"
+  VERSION = "2.2.1.44"
 end

data/problem-specifications/exercises/lens-person/description.md

@@ -3,5 +3,5 @@ Use lenses to update nested records (specific to languages with immutable data).
 Updating fields of nested records is kind of annoying in Haskell. One solution
 is to use [lenses](https://wiki.haskell.org/Lens).  Implement several record
 accessing functions using lenses, you may use any library you want. The test
-suite also allows you to avoid lenses alltogether so you can experiment with
+suite also allows you to avoid lenses altogether so you can experiment with
 different approaches.

data/problem-specifications/exercises/palindrome-products/description.md

@@ -3,19 +3,12 @@ Detect palindrome products in a given range.
 A palindromic number is a number that remains the same when its digits are
 reversed. For example, `121` is a palindromic number but `112` is not.
 
-Given the definition of a palindromic number, we define a palindrome _product_
-to be the product `c`, such that `a * b = c`, where `c` is a palindromic number and
- `a` and `b` are integers (possibly, but _not_ necessarily palindromic numbers).
+Given a range of numbers, find the largest and smallest palindromes which
+are products of numbers within that range.
 
-For example, the palindromic number 9009 can be written as the palindrome
-product: `91 * 99 = 9009`.
-
-It's possible (and indeed common) for a palindrome product to be the product
-of multiple combinations of numbers. For example, the palindrome product `9` has
-the factors `(1, 9)` and `(3, 3)`.
-
-Write a program that given a range of integers, returns the smallest and largest
-palindromic product of factors within that range, along with all the factors in the range for that product.
+Your solution should return the largest and smallest palindromes, along with the
+factors of each within the range. If the largest or smallest palindrome has more 
+than one pair of factors within the range, then return all the pairs.
 
 ## Example 1
 

data/problem-specifications/exercises/pascals-triangle/canonical-data.json

@@ -1,6 +1,6 @@
 {
   "exercise": "pascals-triangle",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "comments": [
     "Expectations are represented here as an array of arrays.",
     "How you represent this idiomatically in your language is up to you.",
@@ -45,12 +45,6 @@
           "property": "rows",
           "count": -1,
           "expected": -1
-        },
-        {
-          "description": "null/no rows",
-          "property": "rows",
-          "count": null,
-          "expected": -1
         }
       ]
     }

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

@@ -8,70 +8,71 @@
 typedef struct {
    const char *text;
    int number;
-} TextToIntLookup_t;
+} text_to_int_lookup_t;
 
-static bool isLeapyear(int year)
+static bool is_leap_year(int year)
 {
    return ((((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0));
 }
 
-static int daysInMonth(int year, int month)
+static int days_in_month(int year, int month)
 {
-   int numberOfDays = 31;
+   int number_of_days = 31;
 
    switch (month) {
    case 4:
    case 6:
    case 9:
    case 11:
-      numberOfDays = 30;
+      number_of_days = 30;
       break;
    case 2:
-      if (isLeapyear(year)) {
-         numberOfDays = 29;
+      if (is_leap_year(year)) {
+         number_of_days = 29;
       } else {
-         numberOfDays = 28;
+         number_of_days = 28;
       }
       break;
    }
-   return numberOfDays;
+   return number_of_days;
 }
 
-static int getNumberGivenText(const char *text, TextToIntLookup_t * lookup,
-                              size_t numberEntries)
+static int get_number_given_text(const char *text,
+                                 text_to_int_lookup_t * lookup,
+                                 size_t number_entries)
 {
-   int matchNumber = -1;
+   int match_number = -1;
 
-   for (size_t index = 0; index < numberEntries; index++) {
+   for (size_t index = 0; index < number_entries; index++) {
       if (0 == strcmp(text, lookup[index].text)) {
-         matchNumber = lookup[index].number;
+         match_number = lookup[index].number;
          break;
       }
    }
-   return matchNumber;
+   return match_number;
 }
 
-static int getDayOfWeekFromDate(unsigned int year, unsigned int month,
-                                unsigned int day)
+static int get_day_of_week_from_date(unsigned int year, unsigned int month,
+                                     unsigned int day)
 {
-   struct tm firstDayOfTestMonth;
-   time_t midnightFirstDayofTestMonth;
-
-   firstDayOfTestMonth.tm_year = year - 1900;
-   firstDayOfTestMonth.tm_mon = month - 1;
-   firstDayOfTestMonth.tm_mday = day;
-   firstDayOfTestMonth.tm_hour = 0;
-   firstDayOfTestMonth.tm_min = 0;
-   firstDayOfTestMonth.tm_sec = 0;
-   firstDayOfTestMonth.tm_isdst = 0;
-   midnightFirstDayofTestMonth = mktime(&firstDayOfTestMonth);
-
-   return (localtime(&midnightFirstDayofTestMonth)->tm_wday);
+   struct tm first_day_of_test_month;
+   time_t midnight_first_day_of_test_month;
+
+   first_day_of_test_month.tm_year = year - 1900;
+   first_day_of_test_month.tm_mon = month - 1;
+   first_day_of_test_month.tm_mday = day;
+   first_day_of_test_month.tm_hour = 0;
+   first_day_of_test_month.tm_min = 0;
+   first_day_of_test_month.tm_sec = 0;
+   first_day_of_test_month.tm_isdst = 0;
+   midnight_first_day_of_test_month = mktime(&first_day_of_test_month);
+
+   return (localtime(&midnight_first_day_of_test_month)->tm_wday);
 }
 
-static int getWeekOfMonth(const char *week)
+static int get_week_of_month(const char *week)
 {
-   TextToIntLookup_t whichWeekOfMonthLookup[] = {
+   text_to_int_lookup_t which_week_of_month_lookup[] = {
       {"first", 1},
       {"second", 2},
       {"third", 3},
@@ -81,14 +82,14 @@ static int getWeekOfMonth(const char *week)
       {"teenth", 7}
    };
 
-   return getNumberGivenText(week, &whichWeekOfMonthLookup[0],
-                             sizeof(whichWeekOfMonthLookup) /
-                             sizeof(TextToIntLookup_t));
+   return get_number_given_text(week, &which_week_of_month_lookup[0],
+                                sizeof(which_week_of_month_lookup) /
+                                sizeof(text_to_int_lookup_t));
 }
 
-static int getRequestedDayOfWeek(const char *dayOfWeek)
+static int get_requested_day_of_week(const char *day_of_week)
 {
-   TextToIntLookup_t dayLookup[] = {
+   text_to_int_lookup_t day_lookup[] = {
       {"Sunday", 0},
       {"Monday", 1},
       {"Tuesday", 2},
@@ -98,42 +99,45 @@ static int getRequestedDayOfWeek(const char *dayOfWeek)
       {"Saturday", 6}
    };
 
-   return getNumberGivenText(dayOfWeek, &dayLookup[0],
-                             sizeof(dayLookup) / sizeof(TextToIntLookup_t));
+   return get_number_given_text(day_of_week, &day_lookup[0],
+                                sizeof(day_lookup) /
+                                sizeof(text_to_int_lookup_t));
 }
 
-int meetupDayOfMonth(unsigned int year, unsigned int month, const char *week,
-                     const char *dayOfWeek)
+int meetup_day_of_month(unsigned int year, unsigned int month, const char *week,
+                        const char *day_of_week)
 {
-   int dayOfMonth = BAD_DATE_REQUESTED;
-   int baselineDayOfWeek;
-   int daysInTestMonth = daysInMonth(year, month);
-   int dayOffset;
-   int referenceDay = 1;        // used to calculate a baseline day of week given a target date.
+   int day_of_month = BAD_DATE_REQUESTED;
+   int baseline_day_of_week;
+   int days_in_test_month = days_in_month(year, month);
+   int day_offset;
+   int reference_day = 1;       // used to calculate a baseline day of week given a target date.
 
-   int whichWeekOfMonth = getWeekOfMonth(week);
-   int targetDayInWeek = getRequestedDayOfWeek(dayOfWeek);
+   int which_week_of_month = get_week_of_month(week);
+   int target_day_in_week = get_requested_day_of_week(day_of_week);
 
    // check for valid lookup...
-   if ((whichWeekOfMonth >= 0) && (targetDayInWeek >= 0)) {
+   if ((which_week_of_month >= 0) && (target_day_in_week >= 0)) {
       // first - fifth Xday of month
-      if (whichWeekOfMonth <= 5) {
-         dayOffset = 1 + ((whichWeekOfMonth - 1) * 7);
+      if (which_week_of_month <= 5) {
+         day_offset = 1 + ((which_week_of_month - 1) * 7);
       } else {
          // code for last Xday of month
-         if (6 == whichWeekOfMonth) {
-            referenceDay = daysInTestMonth - 6; // use the last unique day near end of month as reference
+         if (6 == which_week_of_month) {
+            reference_day = days_in_test_month - 6;     // use the last unique day near end of month as reference
          } else {
-            referenceDay = 13;  // use first teenth day as reference
+            reference_day = 13; // use first teenth day as reference
          }
-         dayOffset = referenceDay;
+         day_offset = reference_day;
       }
-      baselineDayOfWeek = getDayOfWeekFromDate(year, month, referenceDay);
-      dayOfMonth = dayOffset + ((targetDayInWeek + 7 - baselineDayOfWeek) % 7);
+      baseline_day_of_week =
+          get_day_of_week_from_date(year, month, reference_day);
+      day_of_month =
+          day_offset + ((target_day_in_week + 7 - baseline_day_of_week) % 7);
    }
 
-   if (dayOfMonth > daysInTestMonth) {
-      dayOfMonth = BAD_DATE_REQUESTED;
+   if (day_of_month > days_in_test_month) {
+      day_of_month = BAD_DATE_REQUESTED;
    }
-   return dayOfMonth;
+   return day_of_month;
 }

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

@@ -1,7 +1,7 @@
 #ifndef MEETUP_H
 #define MEETUP_H
 
-int meetupDayOfMonth(unsigned int year, unsigned int month, const char *week,
-                     const char *dayOfWeek);
+int meetup_day_of_month(unsigned int year, unsigned int month, const char *week,
+                        const char *day_of_week);
 
 #endif

data/tracks/c/exercises/meetup/test/test_meetup.c

@@ -2,18 +2,18 @@
 #include "../src/meetup.h"
 
 // Using XMacros to create the tests
-#define EXPAND_MEETUP_TEST_AS_TEST(test_name, year, month, week, dayOfWeek, dayOfMonth)\
+#define EXPAND_MEETUP_TEST_AS_TEST(test_name, year, month, week, day_of_week, day_of_month_expected)\
    void test_name(void)\
    {\
-   int actualDayOfMonth = meetupDayOfMonth(year, month, week, dayOfWeek);\
+   int actual_day_of_month = meetup_day_of_month(year, month, week, day_of_week);\
    \
-   TEST_ASSERT_EQUAL_INT(dayOfMonth, actualDayOfMonth);\
+   TEST_ASSERT_EQUAL_INT(day_of_month_expected, actual_day_of_month);\
    }\
 
 
 // below expands to multiple routines...that are all designed to test the returned day of month
 // the fields are:
-//    text - test name, int year, int month, char *week, char *dayofWeek, int dayOfMonthExpecte (0=invalid)
+//    text - test name, int year, int month, char *week, char *day_of_week, int day_of_month_expected (0=invalid)
 
 #define MEETUP_TESTS(ENTRY) \
    ENTRY(test_monteenth_of_May_2013, 2013, 5, "teenth", "Monday", 13)\

data/tracks/cfml/config.json

@@ -1,169 +1,179 @@
-{
-  "active": true,
-  "blurb": "CFML (ColdFusion Markup Language) is an open source and commercial (JIT) compiled dynamic and loosely typed JVM scripting language that embodies classic OO, and functional programming, making it easy to learn, fun to use. CFML brings the power and scalability of the J2EE ecosystem but without the boilerplate of Java.",
-  "exercises": [
-    {
-      "difficulty": 1,
-      "slug": "hello-world",
-      "topics": null,
-      "uuid": "ab04a390-0969-4a17-8081-c852b23ed88c"
-    },
-    {
-      "core": false,
-      "difficulty": 1,
-      "slug": "leap",
-      "topics": null,
-      "unlocked_by": null,
-      "uuid": "03a98e5b-03b7-45e5-a580-611ef5dab4e5"
-    },
-    {
-      "difficulty": 1,
-      "slug": "raindrops",
-      "topics": null,
-      "uuid": "9273C0A7-CB7E-4F3F-8993-F1621CE1F700"
-    },
-    {
-      "difficulty": 1,
-      "slug": "scrabble-score",
-      "topics": null,
-      "uuid": "1065F8DF-E6C6-4473-A633-4FA4B49A5314"
-    },
-    {
-      "difficulty": 1,
-      "slug": "difference-of-squares",
-      "topics": null,
-      "uuid": "4E91AD44-8F3D-40DC-899E-253C91B134F6"
-    },
-    {
-      "difficulty": 1,
-      "slug": "secret-handshake",
-      "topics": null,
-      "uuid": "0AC79782-B370-4954-8455-6300A734E1B8"
-    },
-    {
-      "difficulty": 1,
-      "slug": "space-age",
-      "topics": null,
-      "uuid": "0B14F23A-DAD4-4965-8ABD-8A107DFD6C00"
-    },
-    {
-      "difficulty": 1,
-      "slug": "acronym",
-      "topics": null,
-      "uuid": "9894F2F7-2DBE-4001-885B-FD2C029C6731"
-    },
-    {
-      "difficulty": 1,
-      "slug": "rna-transcription",
-      "topics": null,
-      "uuid": "11C48AFF-4A54-4B3C-AF5E-53048D4BA98B"
-    },
-    {
-      "difficulty": 1,
-      "slug": "pangram",
-      "topics": null,
-      "uuid": "113A2FF7-E72E-49DD-A2CF-0EB25894707D"
-    },
-    {
-      "difficulty": 1,
-      "slug": "hamming",
-      "topics": null,
-      "uuid": "4063A554-424C-4173-81EE-FEAC7CC51E8A"
-    },
-    {
-      "difficulty": 1,
-      "slug": "gigasecond",
-      "topics": null,
-      "uuid": "00B82E7F-804C-4401-BB7F-0565DEA02567"
-    },
-    {
-      "difficulty": 1,
-      "slug": "sum-of-multiples",
-      "topics": null,
-      "uuid": "C6F38ACB-A6BD-41EE-A2F8-A9680B3F61D2"
-    },
-    {
-      "difficulty": 1,
-      "slug": "luhn",
-      "topics": null,
-      "uuid": "685ADB7B-1DC9-4409-993D-51034DF6F744"
-    },
-    {
-      "difficulty": 1,
-      "slug": "triangle",
-      "topics": null,
-      "uuid": "8D0FA71A-3314-432E-BF1F-E6A5F823FC36"
-    },
-    {
-      "difficulty": 1,
-      "slug": "largest-series-product",
-      "topics": null,
-      "uuid": "A35C9BE1-F26A-40C8-8C05-99C33C552E6F"
-    },
-    {
-      "difficulty": 1,
-      "slug": "grains",
-      "topics": null,
-      "uuid": "E25686EE-B888-4533-86C2-5A5D96F5270E"
-    },
-    {
-      "difficulty": 1,
-      "slug": "atbash-cipher",
-      "topics": null,
-      "uuid": "C35391BD-900F-4756-8DFE-A96EA04250F8"
-    },
-    {
-      "difficulty": 1,
-      "slug": "nth-prime",
-      "topics": null,
-      "uuid": "15151E41-195C-40DD-B296-C2C19B38CAEA"
-    },
-    {
-      "difficulty": 1,
-      "slug": "pig-latin",
-      "topics": null,
-      "uuid": "3FDDA0E3-AE90-4834-B6DC-A5E367A5A029"
-    },
-    {
-      "difficulty": 1,
-      "slug": "flatten-array",
-      "topics": null,
-      "uuid": "B0E72A09-49E2-4973-BFF4-88C678F4BE55"
-    },
-    {
-      "difficulty": 1,
-      "slug": "saddle-points",
-      "topics": null,
-      "uuid": "063C4BB9-3280-4C69-B164-237732AE00EF"
-    },
-    {
-      "difficulty": 1,
-      "slug": "diamond",
-      "topics": null,
-      "uuid": "DECA4C79-DA5D-43A8-90B8-3A5BE73EAFF5"
-    },
-    {
-      "difficulty": 1,
-      "slug": "isogram",
-      "topics": null,
-      "uuid": "FC8922A3-E29D-451D-9947-A2781C0FF787"
-    },
-    {
-      "difficulty": 1,
-      "slug": "bob",
-      "topics": null,
-      "uuid": "12BBECF4-93EB-40F2-AC13-8CF28B550F0A"
-    },
-    {
-      "difficulty": 1,
-      "slug": "word-count",
-      "topics": null,
-      "uuid": "C61E97BE-6C66-4F1F-87ED-D21C4ED2A8E2"
-    }
-  ],
-  "foregone": [],
-  "ignore_pattern": "Solution",
-  "language": "CFML",
-  "solution_pattern": "Solution.cfc",
-  "test_pattern": "Test.cfc"
-}
+{
+    "active":true,
+    "blurb":"CFML (ColdFusion Markup Language) is an open source and commercial (JIT) compiled dynamic and loosely typed JVM scripting language that embodies classic OO, and functional programming, making it easy to learn, fun to use. CFML brings the power and scalability of the J2EE ecosystem but without the boilerplate of Java.",
+    "exercises":[
+        {
+            "difficulty":1,
+            "slug":"hello-world",
+            "topics":null,
+            "uuid":"ab04a390-0969-4a17-8081-c852b23ed88c"
+        },
+        {
+            "core":false,
+            "difficulty":1,
+            "slug":"leap",
+            "topics":null,
+            "unlocked_by":null,
+            "uuid":"03a98e5b-03b7-45e5-a580-611ef5dab4e5"
+        },
+        {
+            "difficulty":1,
+            "slug":"raindrops",
+            "topics":null,
+            "uuid":"9273C0A7-CB7E-4F3F-8993-F1621CE1F700"
+        },
+        {
+            "difficulty":1,
+            "slug":"scrabble-score",
+            "topics":null,
+            "uuid":"1065F8DF-E6C6-4473-A633-4FA4B49A5314"
+        },
+        {
+            "difficulty":1,
+            "slug":"difference-of-squares",
+            "topics":null,
+            "uuid":"4E91AD44-8F3D-40DC-899E-253C91B134F6"
+        },
+        {
+            "difficulty":1,
+            "slug":"secret-handshake",
+            "topics":null,
+            "uuid":"0AC79782-B370-4954-8455-6300A734E1B8"
+        },
+        {
+            "difficulty":1,
+            "slug":"space-age",
+            "topics":null,
+            "uuid":"0B14F23A-DAD4-4965-8ABD-8A107DFD6C00"
+        },
+        {
+            "difficulty":1,
+            "slug":"acronym",
+            "topics":null,
+            "uuid":"9894F2F7-2DBE-4001-885B-FD2C029C6731"
+        },
+        {
+            "difficulty":1,
+            "slug":"rna-transcription",
+            "topics":null,
+            "uuid":"11C48AFF-4A54-4B3C-AF5E-53048D4BA98B"
+        },
+        {
+            "difficulty":1,
+            "slug":"pangram",
+            "topics":null,
+            "uuid":"113A2FF7-E72E-49DD-A2CF-0EB25894707D"
+        },
+        {
+            "difficulty":1,
+            "slug":"hamming",
+            "topics":null,
+            "uuid":"4063A554-424C-4173-81EE-FEAC7CC51E8A"
+        },
+        {
+            "difficulty":1,
+            "slug":"gigasecond",
+            "topics":null,
+            "uuid":"00B82E7F-804C-4401-BB7F-0565DEA02567"
+        },
+        {
+            "difficulty":1,
+            "slug":"sum-of-multiples",
+            "topics":null,
+            "uuid":"C6F38ACB-A6BD-41EE-A2F8-A9680B3F61D2"
+        },
+        {
+            "difficulty":1,
+            "slug":"luhn",
+            "topics":null,
+            "uuid":"685ADB7B-1DC9-4409-993D-51034DF6F744"
+        },
+        {
+            "difficulty":1,
+            "slug":"triangle",
+            "topics":null,
+            "uuid":"8D0FA71A-3314-432E-BF1F-E6A5F823FC36"
+        },
+        {
+            "difficulty":1,
+            "slug":"largest-series-product",
+            "topics":null,
+            "uuid":"A35C9BE1-F26A-40C8-8C05-99C33C552E6F"
+        },
+        {
+            "difficulty":1,
+            "slug":"grains",
+            "topics":null,
+            "uuid":"E25686EE-B888-4533-86C2-5A5D96F5270E"
+        },
+        {
+            "difficulty":1,
+            "slug":"atbash-cipher",
+            "topics":null,
+            "uuid":"C35391BD-900F-4756-8DFE-A96EA04250F8"
+        },
+        {
+            "difficulty":1,
+            "slug":"nth-prime",
+            "topics":null,
+            "uuid":"15151E41-195C-40DD-B296-C2C19B38CAEA"
+        },
+        {
+            "difficulty":1,
+            "slug":"pig-latin",
+            "topics":null,
+            "uuid":"3FDDA0E3-AE90-4834-B6DC-A5E367A5A029"
+        },
+        {
+            "difficulty":1,
+            "slug":"flatten-array",
+            "topics":null,
+            "uuid":"B0E72A09-49E2-4973-BFF4-88C678F4BE55"
+        },
+        {
+            "difficulty":1,
+            "slug":"saddle-points",
+            "topics":null,
+            "uuid":"063C4BB9-3280-4C69-B164-237732AE00EF"
+        },
+        {
+            "difficulty":1,
+            "slug":"diamond",
+            "topics":null,
+            "uuid":"DECA4C79-DA5D-43A8-90B8-3A5BE73EAFF5"
+        },
+        {
+            "difficulty":1,
+            "slug":"isogram",
+            "topics":null,
+            "uuid":"FC8922A3-E29D-451D-9947-A2781C0FF787"
+        },
+        {
+            "difficulty":1,
+            "slug":"bob",
+            "topics":null,
+            "uuid":"12BBECF4-93EB-40F2-AC13-8CF28B550F0A"
+        },
+        {
+            "difficulty":1,
+            "slug":"word-count",
+            "topics":null,
+            "uuid":"C61E97BE-6C66-4F1F-87ED-D21C4ED2A8E2"
+        },
+        {
+            "difficulty":5,
+            "slug":"markdown",
+            "uuid":"4594B907-8080-4A23-AD06-BE85FC28D088",
+            "topics":[
+                
+            ]
+        }
+    ],
+    "foregone":[
+        
+    ],
+    "ignore_pattern":"Solution",
+    "language":"CFML",
+    "solution_pattern":"Solution.cfc",
+    "test_pattern":"Test.cfc"
+}