trackler 2.2.1.117 → 2.2.1.118

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 86698b18430cbc49e1e2e16167ec6aa9df9cfc40
-  data.tar.gz: c5b5f72aed663aa799b536bd3c79fcba1aeae8c7
+  metadata.gz: 66abff986feb8a1f8154e773673f580604efc53c
+  data.tar.gz: c89d411e969b41da2b3aecd01cdf82b0dd8bbaf8
 SHA512:
-  metadata.gz: 537f35ce200183dfda9210b561a74917663cbac1cef101f2958493fe61f905358496e068c2014ad92b6e2dd8962b4e2c96a2dd95f174d65a83265ba25c82058a
-  data.tar.gz: a025234caa3468b897a04e4002591bed0e7b7535fa52cd8920436eacf6ff443ffc3a19cb20a9b25102f63ec5d162ec86c4202fd1d3b17cacacf0d2fc92dde563
+  metadata.gz: cd29181a45f5d886605ed8ba63b8c5efae514a23e21b5dab03705d9c1413c3adc4c8a8d687340aee461cf19e04a3338ab0e854d58b32b0c696483dfba86a1716
+  data.tar.gz: 7d18ef16291d535e0acfa4c4c72ae1a2e627dd70b7a62f8e10f73409e4c99d0517b88ac64203dfbf4aa629aa5c99e76eb8b25950e1b095caeb9e68f93ae91054

data/lib/trackler/version.rb

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

data/tracks/c/exercises/palindrome-products/src/example.c

@@ -2,64 +2,34 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <limits.h>
+#include <stdbool.h>
 
-static int palindrome(int n);
-static int addfactors(factor_t ** p, int i, int k);
-static void free_ll(struct factors *p);
-
-product_t *get_palindrome_product(int from, int to)
+__attribute__ ((optimize("-O3")))
+static bool palindrome(int n)
 {
-   product_t *res = malloc(sizeof(product_t));
-   if (res == NULL) {
-      fprintf(stderr, "Memory error!\n");
-      return NULL;
-   }
+   /* 0 is palindrome */
+   if (n == 0)
+      return true;
 
-   res->error[MAXERR - 1] = '\0';
-   res->smallest = INT_MAX;
-   res->largest = INT_MIN;
-   res->factors_lg = NULL;
-   res->factors_sm = NULL;
+   /* negative can not be palindrome */
+   if (n < 0)
+      return false;
 
-   if (from > to) {
-      snprintf(res->error, MAXERR - 1,
-               "invalid input: min is %i and max is %i", from, to);
-      return res;
-   }
+   int tail;
 
-   int i, k, n;
-   int err = 0;
-   for (i = from; i <= to; i++)
-      for (k = i; k <= to; k++)
-         if (palindrome(n = i * k)) {
-            if (n <= res->smallest) {
-               res->smallest = n;
-               err = addfactors(&res->factors_sm, i, k);
-            } else if (n >= res->largest) {
-               res->largest = n;
-               err = addfactors(&res->factors_lg, i, k);
-            }
-            if (err) {
-               free(res);
-               return NULL;
-            }
-         }
+   /* a not-null number can not start with 0 */
+   if ((tail = n % 10) == 0)
+      return false;
+   n /= 10;
 
-   if ((res->smallest == INT_MAX) || (res->largest == INT_MIN)) {
-      snprintf(res->error, MAXERR - 1,
-               "no palindrome with factors in the range %i to %i", from, to);
-      return res;
+   /* split and reverse the second half */
+   while (n > tail) {
+      tail = (tail * 10) + (n % 10);
+      n /= 10;
    }
-   return res;
-}
 
-void free_product(product_t * p)
-{
-   if (p == NULL)
-      return;
-   free_ll(p->factors_lg);
-   free_ll(p->factors_sm);
-   free(p);
+   return (n == tail)           /* even length */
+       ||(n == tail / 10);      /* odd length - discard the middle */
 }
 
 static void free_ll(struct factors *p)
@@ -71,9 +41,9 @@ static void free_ll(struct factors *p)
    free(p);
 }
 
-static int addfactors(factor_t ** p, int i, int k)
+static int addfactors(factor_t ** p, int factor_one, int factor_two)
 {
-   int n = i * k;
+   int n = factor_one * factor_two;
    if ((*p == NULL) || (((*p)->factor_a) * (*p)->factor_b != n)) {
       free_ll(*p);
       *p = NULL;
@@ -86,24 +56,63 @@ static int addfactors(factor_t ** p, int i, int k)
    }
 
    tmp->next = *p;
-   tmp->factor_a = i;
-   tmp->factor_b = k;
+   tmp->factor_a = factor_one;
+   tmp->factor_b = factor_two;
    *p = tmp;
    return 0;
 }
 
-static int palindrome(int n)
+product_t *get_palindrome_product(int from, int to)
 {
-   if (n < 0)
-      n *= -1;
-   int r = 0;
-   int nn = n;
+   product_t *result = malloc(sizeof(product_t));
+   if (result == NULL) {
+      fprintf(stderr, "Memory error!\n");
+      return NULL;
+   }
 
-   /* inverse n in r */
-   while (n >= 1) {
-      r = (r * 10) + (n % 10);
-      n /= 10;
+   result->error[MAXERR - 1] = '\0';
+   result->smallest = INT_MAX;
+   result->largest = INT_MIN;
+   result->factors_lg = NULL;
+   result->factors_sm = NULL;
+
+   if (from > to) {
+      snprintf(result->error, MAXERR - 1,
+               "invalid input: min is %i and max is %i", from, to);
+      return result;
+   }
+
+   int i, k, n;
+   int err = 0;
+   for (i = from; i <= to; i++)
+      for (k = i; k <= to; k++)
+         if (palindrome(n = i * k)) {
+            if (n <= result->smallest) {
+               result->smallest = n;
+               err = addfactors(&result->factors_sm, i, k);
+            } else if (n >= result->largest) {
+               result->largest = n;
+               err = addfactors(&result->factors_lg, i, k);
+            }
+            if (err) {
+               free(result);
+               return NULL;
+            }
+         }
+
+   if ((result->smallest == INT_MAX) || (result->largest == INT_MIN)) {
+      snprintf(result->error, MAXERR - 1,
+               "no palindrome with factors in the range %i to %i", from, to);
+      return result;
    }
+   return result;
+}
 
-   return (nn == r);
+void free_product(product_t * p)
+{
+   if (p == NULL)
+      return;
+   free_ll(p->factors_lg);
+   free_ll(p->factors_sm);
+   free(p);
 }

data/tracks/c/exercises/palindrome-products/src/example.h

@@ -3,13 +3,11 @@
 
 #define MAXERR 100
 
-struct factors {
+typedef struct factors {
    int factor_a;
    int factor_b;
    struct factors *next;
-};
-
-typedef struct factors factor_t;
+} factor_t;
 
 struct product {
    int smallest;

data/tracks/ceylon/exercises/largest-series-product/example/Series.ceylon

@@ -1,13 +1,25 @@
-class Error() {}
+abstract class Error() of InvalidWindowSize | InvalidDigit {}
+class InvalidWindowSize() extends Error() {
+    shared actual default Boolean equals(Object that) => that is InvalidWindowSize;
+}
+class InvalidDigit(Character c) extends Error() {
+    shared actual default Boolean equals(Object that) {
+        if (is InvalidDigit that) {
+            return that.c == c;
+        }
+        return false;
+    }
+}
 
 Integer|Error largestProduct(String digits, Integer window) {
     if (window<0 || window>digits.size) {
-        return Error();
+        return InvalidWindowSize();
     }
-    value parsed = [for (d in digits) if (('0'..'9').contains(d)) d.integer - '0'.integer];
-    if (parsed.size < digits.size) {
-        return Error();
+    value invalids = [for (d in digits) if (!('0'..'9').contains(d)) d];
+    if (nonempty invalids) {
+        return InvalidDigit(invalids[0]);
     }
+    value parsed = [for (d in digits) d.integer - '0'.integer];
     value ranges = { for (i in 0 .. (digits.size - window)) parsed[i:window] };
     return max({ for (r in ranges) r.fold(1)((acc, e) => acc * e) });
 }

data/tracks/ceylon/exercises/largest-series-product/source/largestseriesproduct/Series.ceylon

@@ -1,4 +1,15 @@
-class Error() {}
+abstract class Error() of InvalidWindowSize | InvalidDigit {}
+class InvalidWindowSize() extends Error() {
+    shared actual default Boolean equals(Object that) => that is InvalidWindowSize;
+}
+class InvalidDigit(Character c) extends Error() {
+    shared actual default Boolean equals(Object that) {
+        if (is InvalidDigit that) {
+            return that.c == c;
+        }
+        return false;
+    }
+}
 
 Integer|Error largestProduct(String digits, Integer window) {
     return nothing;

data/tracks/ceylon/exercises/largest-series-product/source/largestseriesproduct/SeriesTest.ceylon

@@ -4,7 +4,7 @@ import ceylon.test {
 
 // Tests adapted from problem-specifications version 1.1.0
 
-{[String, Integer, Integer?]*} cases => {
+{[String, Integer, Integer|Error]*} cases => {
     // finds the largest product if span equals length
     ["29", 2, 18],
     // can find the largest product of 2 with numbers in order
@@ -24,26 +24,21 @@ import ceylon.test {
     // reports zero if all spans include zero
     ["99099", 3, 0],
     // rejects span longer than string length
-    ["123", 4, null],
+    ["123", 4, InvalidWindowSize()],
     // reports 1 for empty string and empty product (0 span)
     ["", 0, 1],
     // reports 1 for nonempty string and empty product (0 span)
     ["123", 0, 1],
     // rejects empty string and nonzero span
-    ["", 1, null],
+    ["", 1, InvalidWindowSize()],
     // rejects invalid character in digits
-    ["1234a5", 2, null],
+    ["1234a5", 2, InvalidDigit('a')],
     // rejects negative span
-    ["12345", -1, null]
+    ["12345", -1, InvalidWindowSize()]
 };
 
 test
 parameters (`value cases`)
-void testLargestProduct(String digits, Integer window, Integer? expected) {
-    value result = largestProduct(digits, window);
-    if (exists expected) {
-        assertEquals(result, expected);
-    } else if (!is Error result) {
-        fail("should have errored, but got ``result``");
-    }
+void testLargestProduct(String digits, Integer window, Integer|Error expected) {
+    assertEquals(largestProduct(digits, window), expected);
 }

data/tracks/haskell/config.json

@@ -400,7 +400,7 @@
       "unlocked_by": null,
       "difficulty": 4,
       "topics": [
-        "Maybe"
+        "Either"
       ]
     },
     {
@@ -410,7 +410,7 @@
       "unlocked_by": null,
       "difficulty": 4,
       "topics": [
-        "Maybe"
+        "Either"
       ]
     },
     {

data/tracks/haskell/exercises/all-your-base/examples/success-standard/src/Base.hs

@@ -1,20 +1,23 @@
-module Base (rebase) where
+module Base (Error(..), rebase) where
 
 import Control.Monad (foldM)
 import Data.List     (unfoldr)
 import Data.Tuple    (swap)
 
-rebase :: Integral a => a -> a -> [a] -> Maybe [a]
+data Error a = InvalidInputBase | InvalidOutputBase | InvalidDigit a
+    deriving (Show, Eq)
+
+rebase :: Integral a => a -> a -> [a] -> Either (Error a) [a]
 rebase ibase obase ds
-    | ibase < 2 = Nothing
-    | obase < 2 = Nothing
+    | ibase < 2 = Left InvalidInputBase
+    | obase < 2 = Left InvalidOutputBase
     | otherwise = toDigits obase <$> fromDigits ibase ds
   where
 
     fromDigits base = foldM f 0
       where
-        f acc x | x >= 0 && x < base = Just (acc * base + x)
-                | otherwise          = Nothing
+        f acc x | x >= 0 && x < base = Right (acc * base + x)
+                | otherwise          = Left (InvalidDigit x)
 
     toDigits base = reverse . unfoldr f
       where

data/tracks/haskell/exercises/all-your-base/src/Base.hs

@@ -1,4 +1,7 @@
-module Base (rebase) where
+module Base (Error(..), rebase) where
 
-rebase :: Integral a => a -> a -> [a] -> Maybe [a]
+data Error a = InvalidInputBase | InvalidOutputBase | InvalidDigit a
+    deriving (Show, Eq)
+
+rebase :: Integral a => a -> a -> [a] -> Either (Error a) [a]
 rebase inputBase outputBase inputDigits = error "You need to implement this function."

data/tracks/haskell/exercises/all-your-base/test/Tests.hs

@@ -4,7 +4,7 @@ import Data.Foldable     (for_)
 import Test.Hspec        (Spec, describe, it, shouldBe)
 import Test.Hspec.Runner (configFastFail, defaultConfig, hspecWith)
 
-import Base (rebase)
+import Base (Error(..), rebase)
 
 main :: IO ()
 main = hspecWith defaultConfig {configFastFail = True} specs
@@ -18,11 +18,11 @@ specs = describe "rebase" $ for_ cases test
         assertion  = expression `shouldBe` outputDigits
         expression = rebase inputBase outputBase inputDigits
 
-data Case = Case { description  ::        String
-                 , inputBase    ::        Integer
-                 , inputDigits  ::       [Integer]
-                 , outputBase   ::        Integer
-                 , outputDigits :: Maybe [Integer]
+data Case = Case { description  :: String
+                 , inputBase    :: Integer
+                 , inputDigits  :: [Integer]
+                 , outputBase   :: Integer
+                 , outputDigits :: Either (Error Integer) [Integer]
                  }
 
 cases :: [Case]
@@ -30,49 +30,49 @@ cases = [ Case { description  = "single bit one to decimal"
                , inputBase    = 2
                , inputDigits  = [1]
                , outputBase   = 10
-               , outputDigits = Just [1]
+               , outputDigits = Right [1]
                }
         , Case { description  = "binary to single decimal"
                , inputBase    = 2
                , inputDigits  = [1, 0, 1]
                , outputBase   = 10
-               , outputDigits = Just [5]
+               , outputDigits = Right [5]
                }
         , Case { description  = "single decimal to binary"
                , inputBase    = 10
                , inputDigits  = [5]
                , outputBase   = 2
-               , outputDigits = Just [1, 0, 1]
+               , outputDigits = Right [1, 0, 1]
                }
         , Case { description  = "binary to multiple decimal"
                , inputBase    = 2
                , inputDigits  = [1, 0, 1, 0, 1, 0]
                , outputBase   = 10
-               , outputDigits = Just [4, 2]
+               , outputDigits = Right [4, 2]
                }
         , Case { description  = "decimal to binary"
                , inputBase    = 10
                , inputDigits  = [4, 2]
                , outputBase   = 2
-               , outputDigits = Just [1, 0, 1, 0, 1, 0]
+               , outputDigits = Right [1, 0, 1, 0, 1, 0]
                }
         , Case { description  = "trinary to hexadecimal"
                , inputBase    = 3
                , inputDigits  = [1, 1, 2, 0]
                , outputBase   = 16
-               , outputDigits = Just [2, 10]
+               , outputDigits = Right [2, 10]
                }
         , Case { description  = "hexadecimal to trinary"
                , inputBase    = 16
                , inputDigits  = [2, 10]
                , outputBase   = 3
-               , outputDigits = Just [1, 1, 2, 0]
+               , outputDigits = Right [1, 1, 2, 0]
                }
         , Case { description  = "15-bit integer"
                , inputBase    = 97
                , inputDigits  = [3, 46, 60]
                , outputBase   = 73
-               , outputDigits = Just [6, 10, 45]
+               , outputDigits = Right [6, 10, 45]
                }
 
           -- The following three cases are [0] in all-your-base.json.
@@ -81,79 +81,80 @@ cases = [ Case { description  = "single bit one to decimal"
                , inputBase    = 2
                , inputDigits  = []
                , outputBase   = 10
-               , outputDigits = Just []
+               , outputDigits = Right []
                }
         , Case { description  = "single zero"
                , inputBase    = 10
                , inputDigits  = [0]
                , outputBase   = 2
-               , outputDigits = Just []
+               , outputDigits = Right []
                }
         , Case { description  = "multiple zeros"
                , inputBase    = 10
                , inputDigits  = [0, 0, 0]
                , outputBase   = 2
-               , outputDigits = Just []
+               , outputDigits = Right []
                }
 
         , Case { description  = "leading zeros"
                , inputBase    = 7
                , inputDigits  = [0, 6, 0]
                , outputBase   = 10
-               , outputDigits = Just [4, 2]
+               , outputDigits = Right [4, 2]
                }
         , Case { description  = "input base is one"
                , inputBase    = 1
                , inputDigits  = [0]
                , outputBase   = 10
-               , outputDigits = Nothing
+               , outputDigits = Left InvalidInputBase
                }
         , Case { description  = "input base is zero"
                , inputBase    = 0
                , inputDigits  = []
                , outputBase   = 10
-               , outputDigits = Nothing
+               , outputDigits = Left InvalidInputBase
                }
         , Case { description  = "input base is negative"
                , inputBase    = -2
                , inputDigits  = [1]
                , outputBase   = 10
-               , outputDigits = Nothing
+               , outputDigits = Left InvalidInputBase
                }
         , Case { description  = "negative digit"
                , inputBase    = 2
                , inputDigits  = [1, -1, 1, 0, 1, 0]
                , outputBase   = 10
-               , outputDigits = Nothing
+               , outputDigits = Left (InvalidDigit (-1))
                }
         , Case { description  = "invalid positive digit"
                , inputBase    = 2
                , inputDigits  = [1, 2, 1, 0, 1, 0]
                , outputBase   = 10
-               , outputDigits = Nothing
+               , outputDigits = Left (InvalidDigit 2)
                }
         , Case { description  = "output base is one"
                , inputBase    = 2
                , inputDigits  = [1, 0, 1, 0, 1, 0]
                , outputBase   = 1
-               , outputDigits = Nothing
+               , outputDigits = Left InvalidOutputBase
                }
         , Case { description  = "output base is zero"
                , inputBase    = 10
                , inputDigits  = [7]
                , outputBase   = 0
-               , outputDigits = Nothing
+               , outputDigits = Left InvalidOutputBase
                }
         , Case { description  = "output base is negative"
                , inputBase    = 2
                , inputDigits  = [1]
                , outputBase   = -7
-               , outputDigits = Nothing
+               , outputDigits = Left InvalidOutputBase
                }
         , Case { description  = "both bases are negative"
                , inputBase    = -2
                , inputDigits  = [1]
                , outputBase   = -7
-               , outputDigits = Nothing
+               -- debatable: This could be Left InvalidOutputBase as well.
+               , outputDigits = Left InvalidInputBase
                }
         ]