trackler 2.0.0.1 → 2.0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9fff91f419bbd95eb001c7301034cbc92258f23a
-  data.tar.gz: dce4a5c8121cf481fc009dbe4a46724f5c2da472
+  metadata.gz: 6ecd79fc11b28fd57fad197537efd30d929a39a2
+  data.tar.gz: a260adf3ee20c762dc65638fb762284607c54761
 SHA512:
-  metadata.gz: 6e84750de6af3b699e3b2aa498f8dab12820be37e78d5f5898141e42f2d7ab80b14827e006972fc497e1f816b848e45285d45d0a627487d61a289e2ac01bca2e
-  data.tar.gz: e8d7320afbd63cf0045ee8a92880332e26f1f9e43d2183af992d9cfff5132b0be3a3ef2d8780f2b287fab1e2696e8e1a694b980200a7860552cefcaba427f8a2
+  metadata.gz: b74c1f2b78cfed39a431f5bdae4fa8822008aa987087985e9c1508d3f39710aaa32460d5e168c252d745ed579d319047734a533e38766b854e12e67a92ac8ddc
+  data.tar.gz: 4d597f2e379ed5010ab9d881051991a20d7afe9b3200e4d8d38d6de3560727b7c096c960aa9762291255e04d45cf6034df034f7e7ff49fb66788ee070d8f215d

data/bin/bump-content

@@ -1,6 +1,8 @@
 #!/usr/bin/env ruby
 
-system("bin/update")
+unless system("bin/update")
+  exit 1
+end
 
 file = File.absolute_path("../../lib/trackler/version.rb", __FILE__)
 

data/bin/verify-metadata

@@ -6,8 +6,8 @@ require_relative '../lib/trackler'
 
 omissions = []
 Trackler.tracks.each do |track|
-  track.problems.each do |slug|
-    unless Trackler.problems[slug].exists?
+  track.problems.each do |problem|
+    unless Trackler.problems[problem.slug].exists?
       omissions << slug
     end
   end

data/common/exercises/alphametics/canonical-data.json

@@ -3,15 +3,10 @@
         "description": "Solve the alphametics puzzle",
         "cases": [
             {
-                "description": "solve short puzzle",
+                "description": "puzzle with three letters",
                 "puzzle": "I + BB == ILL",
                 "expected": { "I": 1, "B": 9, "L": 0 }
             },
-            {
-                "description": "solve long puzzle",
-                "puzzle": "SEND + MORE == MONEY",
-                "expected": { "S": 9, "E": 5, "N": 6, "D": 7, "M": 1, "O": 0, "R": 8, "Y": 2 }
-            },
             {
                 "description": "solution must have unique value for each letter",
                 "puzzle": "A == B",
@@ -23,13 +18,28 @@
                 "expected": null
             },
             {
-                "description": "solve puzzle with four words",
+                "description": "puzzle with four letters",
+                "puzzle": "AS + A == MOM",
+                "expected": { "A": 9, "S": 2, "M": 1, "O": 0 }
+            },
+            {
+                "description": "puzzle with six letters",
+                "puzzle": "NO + NO + TOO == LATE",
+                "expected": { "N": 7, "O": 4, "T": 9, "L": 1, "A": 0, "E": 2}
+            },
+            {
+                "description": "puzzle with seven letters",
                 "puzzle": "HE + SEES + THE == LIGHT",
                 "expected": { "E": 4, "G": 2, "H": 5, "I": 0, "L": 1, "S": 9, "T": 7 }
             },
             {
-                "description": "solve puzzle with many words",
-                "puzzle": "AND + A + STRONG + OFFENSE + AS + A + GOOD = DEFENSE",
+                "description": "puzzle with eight letters",
+                "puzzle": "SEND + MORE == MONEY",
+                "expected": { "S": 9, "E": 5, "N": 6, "D": 7, "M": 1, "O": 0, "R": 8, "Y": 2 }
+            },
+            {
+                "description": "puzzle with ten letters",
+                "puzzle": "AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE",
                 "expected": { "A": 5, "D": 3, "E": 4, "F": 7, "G": 8, "N": 0, "O": 2, "R": 1, "S": 6, "T": 9 }
             }
         ]

data/common/exercises/food-chain/canonical-data.json

@@ -106,7 +106,7 @@
             {
                 "description": "multiple verses",
                 "start verse": 1,
-                "end verse": 2,
+                "end verse": 3,
                 "expected": [
                     "I know an old lady who swallowed a fly.",
                     "I don't know why she swallowed the fly. Perhaps she'll die.",
@@ -114,6 +114,12 @@
                     "I know an old lady who swallowed a spider.",
                     "It wriggled and jiggled and tickled inside her.",
                     "She swallowed the spider to catch the fly.",
+                    "I don't know why she swallowed the fly. Perhaps she'll die.",
+                    "",
+                    "I know an old lady who swallowed a bird.",
+                    "How absurd to swallow a bird!",
+                    "She swallowed the bird to catch the spider that wriggled and jiggled and tickled inside her.",
+                    "She swallowed the spider to catch the fly.",
                     "I don't know why she swallowed the fly. Perhaps she'll die."
                 ]
             },

data/common/exercises/grains/canonical-data.json

@@ -0,0 +1,66 @@
+{
+  "#": [
+    "The final tests of square test error conditions",
+    "The expection for these tests is -1, indicating an error",
+    "In these cases you should expect an error as is idiomatic for your language"
+  ],
+  "square": {
+    "description": "returns the number of grains on the square",
+    "cases": [
+      {
+        "description": "1",
+        "input": 1,
+        "expected": 1
+      },
+      {
+        "description": "2",
+        "input": 2,
+        "expected": 2
+      },
+      {
+        "description": "3",
+        "input": 3,
+        "expected": 4
+      },
+      {
+        "description": "4",
+        "input": 4,
+        "expected": 8
+      },
+      {
+        "description": "16",
+        "input": 16,
+        "expected": 32768
+      },
+      {
+        "description": "32",
+        "input": 32,
+        "expected": 2147483648
+      },
+      {
+        "description": "64",
+        "input": 64,
+        "expected": 9223372036854775808
+      },
+      {
+        "description": "square 0 raises an exception",
+        "input": 0,
+        "expected": -1
+      },
+      {
+        "description": "negative square raises an exception",
+        "input": -1,
+        "expected": -1
+      },
+      {
+        "description": "square greater than 64 raises an exception",
+        "input": 65,
+        "expected": -1
+      }
+    ]
+  },
+  "total": {
+    "description": "returns the total number of grains on the board",
+    "expected": 18446744073709551615
+  }
+}

data/common/exercises/raindrops/description.md

@@ -6,10 +6,9 @@
 
 ## Examples
 
-- 28's factors are 2, 4, **7**, 14.
+- 28's factors are 1, 2, 4, **7**, 14, 28.
   - In raindrop-speak, this would be a simple "Plong".
-- 30's factors are 2, **3**, **5**, 6, 15.
+- 30's factors are 1, 2, **3**, **5**, 6, 15, 30.
   - In raindrop-speak, this would be a "PlingPlang".
-- 34 only has two factors- 2 and 17.
-  - Raindrop-speak doesn't know what to make of that,
-    so it just goes with the straightforward "34".
+- 34 has four factors: 1, 2, 17, and 34.
+  - In raindrop-speak, this would be "34".

data/common/exercises/triangle/canonical-data.json

@@ -8,88 +8,115 @@
         "They're degenerate triangles with all three vertices collinear.",
         "(In contrast, we will test (0, 0, 0, Illegal), as it is a point).",
 
-        "The expectation are given as strings,",
-        "but your language may use the appropriate representations.",
-        "For example, enums, variants, or tagged unions all are viable candidates.",
+        "The tests assert properities of the triangle are true or false.",
+        "See: https://github.com/exercism/x-common/issues/379 for disscussion of this approach",
 
-        "Your track may choose to have the 'illegal' result be another member of the enum/variant/union/etc.,",
-        "or instead to signal an error/exception/etc. on an illegal triangle.",
-
-        "If appropriate for your track, you'll need to ensure that no pair of expected values are equal.",
-        "Otherwise, an implementation that always returns a constant value may falsely pass the tests.",
-        "See https://github.com/exercism/xgo/pull/208"
+        "How you handle invalid triangles is up to you. These tests suggest a triangle",
+        "is returned, but all of its properties are false. But you could also have the creation",
+        "of an invalid triangle return an error or exception. Choose what is idiomatic for",
+        "your language."
     ],
-    "cases": [
+    "equilateral": {
+      "description": "returns true if the triangle is equilateral",
+      "cases": [
         {
-            "description": "equilateral triangle has all sides equal",
-            "sides": [2, 2, 2],
-            "expected": "equilateral"
+              "description": "true if all sides are equal",
+              "sides": [2, 2, 2],
+              "expected": true
         },
         {
-            "description": "larger equilateral triangle",
-            "sides": [10, 10, 10],
-            "expected": "equilateral"
+              "description": "false if any side is unequal",
+              "sides": [2, 3, 2],
+              "expected": false
         },
         {
-            "description": "isosceles triangle with last two sides equal",
-            "sides": [3, 4, 4],
-            "expected": "isosceles"
+              "description": "false if no sides are equal",
+              "sides": [5, 4, 6],
+              "expected": false
         },
         {
-            "description": "isosceles triangle with first two sides equal",
-            "sides": [4, 4, 3],
-            "expected": "isosceles"
+              "description": "All zero sides are illegal, so the triangle is not equilateral",
+              "sides": [0, 0, 0],
+              "expected": false
         },
         {
-            "description": "isosceles triangle with first and last sides equal",
-            "sides": [4, 3, 4],
-            "expected": "isosceles"
+              "#": "Your track may choose to skip this test and deal only with integers if appropriate",
+              "description": "sides may be floats",
+              "sides": [0.5, 0.5, 0.5],
+              "expected": true
+        }
+      ]
+    },
+    "isosceles": {
+      "description": "returns true if the triangle is isosceles",
+      "cases": [
+        {
+              "description": "true if last two sides are equal",
+              "sides": [3, 4, 4],
+              "expected": true
         },
         {
-            "description": "isosceles triangle with unequal side larger than equal sides",
-            "sides": [4, 7, 4],
-            "expected": "isosceles"
+              "description": "true if first two sides are equal",
+              "sides": [4, 4, 3],
+              "expected": true
         },
         {
-            "description": "scalene triangle has no equal sides",
-            "sides": [3, 4, 5],
-            "expected": "scalene"
+              "description": "true if first and last sides are equal",
+              "sides": [4, 3, 4],
+              "expected": true
         },
         {
-            "description": "2a == b+c looks like equilateral, but isn't always",
-            "sides": [5, 4, 6],
-            "expected": "scalene"
+              "description": "equilateral triangles are also isosceles",
+              "sides": [4, 4, 4],
+              "expected": true
         },
         {
-            "description": "larger scalene triangle",
-            "sides": [10, 11, 12],
-            "expected": "scalene"
+              "description": "false if no sides are equal",
+              "sides": [2, 3, 4],
+              "expected": false
         },
         {
-            "description": "scalene triangle with sides in descending order",
-            "sides": [5, 4, 2],
-            "expected": "scalene"
+              "description": "Sides that violate triangle inequality are not isosceles, even if two are equal",
+              "sides": [1, 1, 3],
+              "expected": false
+        },
+        {
+              "#": "Your track may choose to skip this test and deal only with integers if appropriate",
+              "description": "sides may be floats",
+              "sides": [0.5, 0.4, 0.5],
+              "expected": true
+        }
+      ]
+    },
+    "scalene": {
+      "description": "returns true if the triangle is scalene",
+      "cases": [
+        {
+              "description": "true if no sides are equal",
+              "sides": [5, 4, 6],
+              "expected": true
         },
         {
-            "#": "Your track may choose to skip this test and deal only with integers if appropriate",
-            "description": "small scalene triangle with floating point values",
-            "sides": [0.4, 0.6, 0.3],
-            "expected": "scalene"
+              "description": "false if all sides are equal",
+              "sides": [4, 4, 4],
+              "expected": false
         },
         {
-            "description": "a triangle violating the triangle inequality is illegal",
-            "sides": [7, 3, 2],
-            "expected": "illegal"
+              "description": "false if two sides are equal",
+              "sides": [4, 4, 3],
+              "expected": false
         },
         {
-            "description": "two sides equal, but still violates triangle inequality",
-            "sides": [1, 1, 3],
-            "expected": "illegal"
+              "description": "Sides that violate triangle inequality are not scalene, even if they are all different",
+              "sides": [7, 3, 2],
+              "expected": false
         },
         {
-            "description": "triangles with all sides zero are illegal",
-            "sides": [0, 0, 0],
-            "expected": "illegal"
+              "#": "Your track may choose to skip this test and deal only with integers if appropriate",
+              "description": "sides may be floats",
+              "sides": [0.5, 0.4, 0.6],
+              "expected": true
         }
-    ]
+      ]
+    }
 }

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.0.1"
+  VERSION = "2.0.0.2"
 end

data/tracks/c/config.json

@@ -4,25 +4,6 @@
   "repository": "https://github.com/exercism/xc",
   "checklist_issue": 8,
   "active": false,
-  "problems": [
-    "hello-world",
-    "anagram",
-    "leap",
-    "gigasecond",
-    "hamming",
-    "raindrops",
-    "bob",
-    "grains",
-    "largest-series-product",
-    "pangram",
-    "nth-prime",
-    "beer-song",
-    "rna-transcription",
-    "difference-of-squares",
-    "sum-of-multiples",
-    "binary-search",
-    "roman-numerals"
-  ],
   "exercises": [{
     "slug": "hello-world",
     "difficulty": 1,
@@ -155,6 +136,32 @@
       "control-flow (loops)",
       "strings"
     ]
+  }, {
+    "slug": "allergies",
+    "difficulty": 4,
+    "topics": [
+      "control-flow (if-statements)",
+      "control-flow (loops)",
+      "structs",
+      "memory management"
+    ]
+  }, {
+    "difficulty": 5,
+    "slug": "atbash-cipher",
+    "topics": [
+      "control-flow (loops)",
+      "control-flow (if-else statements)",
+      "strings"
+    ]
+  }, {
+    "difficulty": 4,
+    "slug": "phone-number",
+    "topics": [
+      "strings",
+      "memory management",
+      "control-flow (loops)",
+      "control-flow (if-else statements)"
+    ]
   }],
   "deprecated": [
 

data/tracks/c/exercises/allergies/makefile

@@ -0,0 +1,15 @@
+CFLAGS  = -std=c99
+CFLAGS += -Wall
+CFLAGS += -Wextra
+CFLAGS += -pedantic
+CFLAGS += -Werror
+
+test: tests.out
+	@./tests.out
+
+clean:
+	rm -f *.o *.out
+
+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

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

@@ -0,0 +1,21 @@
+#ifndef _ALLERGIES_H
+#define _ALLERGIES_H
+
+typedef enum {
+   Allergen_Eggs = 0,
+   Allergen_Peanuts,
+   Allergen_Shellfish,
+   Allergen_Strawberries,
+   Allergen_Tomatoes,
+   Allergen_Chocolate,
+   Allergen_Pollen,
+   Allergen_Cats,
+   Allergen_Count
+} Allergen_t;
+
+typedef struct {
+   int count;
+   Allergen_t *allergens;
+} Allergen_List_t;
+
+#endif

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

@@ -0,0 +1,32 @@
+#include "allergies.h"
+#include <stdlib.h>
+
+static const unsigned int scores[] = {
+   1,
+   2,
+   4,
+   8,
+   16,
+   32,
+   64,
+   128
+};
+
+bool is_allergic_to(Allergen_t allergen, unsigned int score)
+{
+   return ((score & scores[allergen]) == scores[allergen]);
+}
+
+void get_allergens(unsigned int score, Allergen_List_t * list)
+{
+   list->allergens = calloc(Allergen_Count, sizeof(Allergen_t));
+   list->count = 0;
+
+   for (Allergen_t allergen = 0; allergen < Allergen_Count; allergen++) {
+      if (is_allergic_to(allergen, score)) {
+         score -= scores[allergen];
+         list->allergens[list->count] = allergen;
+         list->count++;
+      }
+   }
+}

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

@@ -0,0 +1,26 @@
+#ifndef _ALLERGIES_H
+#define _ALLERGIES_H
+
+#include <stdbool.h>
+
+typedef enum {
+   Allergen_Eggs = 0,
+   Allergen_Peanuts,
+   Allergen_Shellfish,
+   Allergen_Strawberries,
+   Allergen_Tomatoes,
+   Allergen_Chocolate,
+   Allergen_Pollen,
+   Allergen_Cats,
+   Allergen_Count
+} Allergen_t;
+
+typedef struct {
+   int count;
+   Allergen_t *allergens;
+} Allergen_List_t;
+
+bool is_allergic_to(Allergen_t allergen, unsigned int score);
+void get_allergens(unsigned int score, Allergen_List_t * list);
+
+#endif