trackler 2.1.0.9 → 2.1.0.10

data/tracks/perl6/exercises/bob/example.yaml

@@ -10,6 +10,7 @@ tests: |
 exercise_comment: The name of this exercise.
 module_comment: "%*ENV<EXERCISM> is for tests not directly for the exercise, don't worry about these :)"
 version_comment: The version we will be matching against the exercise.
+lib_comment: Look for the module inside the same directory as this test file.
 plan_comment: This is how many tests we expect to run.
 use_test_comment: Check that the module can be use-d.
 version_test_comment: "If the exercise is updated, we want to make sure other people testing\nyour code don't think you've made a mistake if things have changed!"

data/tracks/perl6/exercises/grade-school/grade-school.t

@@ -6,10 +6,11 @@ use lib $?FILE.IO.dirname;
 my $exercise = 'GradeSchool';
 my $version = v1;
 my $module = %*ENV<EXERCISM> ?? 'Example' !! $exercise;
-plan 11;
+plan 10;
 
 use-ok $module or bail-out;
 require ::($module);
+
 if ::($exercise).^ver !~~ $version {
   warn "\nExercise version mismatch. Further tests may fail!"
     ~ "\n$exercise is $(::($exercise).^ver.gist). "
@@ -17,35 +18,25 @@ if ::($exercise).^ver !~~ $version {
   bail-out 'Example version must match test version.' if %*ENV<EXERCISM>;
 }
 
-my @classes;
-BEGIN { @classes = <Roster> };
-subtest 'Class(es)', {
-  plan 1;
-  eval-lives-ok "use $module; ::('$_').new or die 'Could not use .new method on class $_.\'", $_ for @classes;
-} or bail-out 'All classes must be defined and exported.';
-require ::($module) @classes.eager;
+require ::($module) <Roster>;
 
-for @classes -> $class {
-  subtest "$class class method(s)", {
-    plan 3;
-    ok ::($class).can($_), $_ for <add-student list-grade list-all>;
-  }
+subtest "Roster class methods", {
+  plan 3;
+  ok ::('Roster').can($_), $_ for <add-student list-grade list-all>;
 }
-
-my $roster = Roster.new;
-
+my $roster = ::('Roster').new;
 ok $roster.?add-student(:name('Jim'), :2grade), 'Add Jim to grade 2';
 is $roster.?list-grade(2), <Jim>, 'List grade 2';
 ok $roster.?add-student(:name('Zoe'), :2grade), 'Add Zoe to grade 2';
 ok $roster.?add-student(:name('Barb'), :1grade), 'Add Barb to grade 1';
 is $roster.?list-grade(2), <Jim Zoe>, 'List grade 2';
 is $roster.?list-grade(1), <Barb>, 'List grade 1';
-
 subtest 'Additional students', {
   plan 6;
   ok $roster.?add-student(:name($_), :1grade), "Add $_ to grade 1" for <Charlie Anna>;
   ok $roster.?add-student(:name('Alex'), :2grade), 'Add Alex to grade 2';
   ok $roster.?add-student(:name($_), :3grade), "Add $_ to grade 3" for <Tom Dick Harry>;
 }
-
 is $roster.?list-all, ('Grade 1', <Anna Barb Charlie>, 'Grade 2', <Alex Jim Zoe>, 'Grade 3', <Dick Harry Tom>), 'List all';
+
+done-testing;

data/tracks/perl6/exercises/hello-world/example.yaml

@@ -10,6 +10,7 @@ tests: |
 exercise_comment: The name of this exercise.
 module_comment: "%*ENV<EXERCISM> is for tests not directly for the exercise, don't worry about these :)"
 version_comment: The version we will be matching against the exercise.
+lib_comment: Look for the module inside the same directory as this test file.
 plan_comment: This is how many tests we expect to run.
 use_test_comment: Check that the module can be use-d.
 version_test_comment: "If the exercise is updated, we want to make sure other people testing\nyour code don't think you've made a mistake if things have changed!"

data/tracks/perl6/exercises/hello-world/hello-world.t

@@ -1,20 +1,20 @@
 #!/usr/bin/env perl6
 use v6;
 use Test;
-use lib my $dir = $?FILE.IO.dirname; # Look for the module inside the same directory as this test file.
+use lib my $dir = $?FILE.IO.dirname; #`[Look for the module inside the same directory as this test file.]
 use JSON::Tiny;
 
-my $exercise = 'HelloWorld'; # The name of this exercise.
-my $version = v2; # The version we will be matching against the exercise.
-my $module = %*ENV<EXERCISM> ?? 'Example' !! $exercise; # %*ENV<EXERCISM> is for tests not directly for the exercise, don't worry about these :)
-plan 4; # This is how many tests we expect to run.
+my $exercise = 'HelloWorld'; #`[The name of this exercise.]
+my $version = v2; #`[The version we will be matching against the exercise.]
+my $module = %*ENV<EXERCISM> ?? 'Example' !! $exercise; #`[%*ENV<EXERCISM> is for tests not directly for the exercise, don't worry about these :)]
+plan 3; #`[This is how many tests we expect to run.]
 
-# Check that the module can be use-d.
+#`[Check that the module can be use-d.]
 use-ok $module or bail-out;
 require ::($module);
 
-# If the exercise is updated, we want to make sure other people testing
-# your code don't think you've made a mistake if things have changed!
+#`[If the exercise is updated, we want to make sure other people testing
+your code don't think you've made a mistake if things have changed!]
 if ::($exercise).^ver !~~ $version {
   warn "\nExercise version mismatch. Further tests may fail!"
     ~ "\n$exercise is $(::($exercise).^ver.gist). "
@@ -22,42 +22,37 @@ if ::($exercise).^ver !~~ $version {
   bail-out 'Example version must match test version.' if %*ENV<EXERCISM>;
 }
 
-# Check that the Module 'HelloWorld' can use all of the subroutines
-# needed in the tests (only '&hello' for this one).
-my @subs;
-BEGIN { @subs = <&hello> };
-subtest 'Subroutine(s)', {
-  plan 1;
-  eval-lives-ok "use $module; ::('$_').defined or die '$_ is not defined.'", $_ for @subs;
-} or bail-out 'All subroutines must be defined and exported.';
-require ::($module) @subs.eager;
-
-# Go through the cases (hiding at the bottom of this file)
-# and check that &hello gives us the correct response.
-is hello, |.<expected description> for @(my $c-data.<cases>);
-
-# Ignore this for your exercise! Tells Exercism folks when exercise cases become out of date.
-if %*ENV<EXERCISM> && (my $c-data-file = "$dir/../../x-common/exercises/{$dir.IO.basename}/canonical-data.json".IO.resolve) ~~ :f {
-  is $c-data, from-json($c-data-file.slurp), 'canonical-data'
-} else { skip }
-
-# There are no more tests after this :)
-done-testing;
-
-# 'INIT' is a phaser, it makes sure that the test data is available before everything else
-# starts running (otherwise we'd have to shove the test data into the middle of the file!)
+#`[Import '&hello' from 'HelloWorld']
+require ::($module) <&hello>;
+
+my $c-data;
+#`[Go through the cases (hiding at the bottom of this file)
+and check that &hello gives us the correct response.]
+is &::('hello')(), |.<expected description> for @($c-data<cases>);
+
+#`[Ignore this for your exercise! Tells Exercism folks when exercise cases become out of date.]
+if %*ENV<EXERCISM> && (my $c-data-file =
+  "$dir/../../x-common/exercises/{$dir.IO.resolve.basename}/canonical-data.json".IO.resolve) ~~ :f
+{ is-deeply $c-data, from-json($c-data-file.slurp), 'canonical-data' } else { skip }
+
+done-testing; #`[There are no more tests after this :)]
+
+#`['INIT' is a phaser, it makes sure that the test data is available before everything else
+starts running (otherwise we'd have to shove the test data into the middle of the file!)]
 INIT {
-  $c-data := from-json ｢
+$c-data := from-json q:to/END/;
+
+{
+  "exercise": "hello-world",
+  "version": "1.0.0",
+  "cases": [
     {
-      "exercise": "hello-world",
-      "version": "1.0.0",
-      "cases": [
-        {
-          "description": "Say Hi!",
-          "property": "hello",
-          "expected": "Hello, World!"
-        }
-      ]
+      "description": "Say Hi!",
+      "property": "hello",
+      "expected": "Hello, World!"
     }
-  ｣
+  ]
+}
+
+END
 }

data/tracks/perl6/exercises/leap/leap.t

@@ -7,10 +7,11 @@ use JSON::Tiny;
 my $exercise = 'Leap';
 my $version = v1;
 my $module = %*ENV<EXERCISM> ?? 'Example' !! $exercise;
-plan 7;
+plan 6;
 
 use-ok $module or bail-out;
 require ::($module);
+
 if ::($exercise).^ver !~~ $version {
   warn "\nExercise version mismatch. Further tests may fail!"
     ~ "\n$exercise is $(::($exercise).^ver.gist). "
@@ -18,53 +19,50 @@ if ::($exercise).^ver !~~ $version {
   bail-out 'Example version must match test version.' if %*ENV<EXERCISM>;
 }
 
-my @subs;
-BEGIN { @subs = <&is-leap-year> };
-subtest 'Subroutine(s)', {
-  plan 1;
-  eval-lives-ok "use $module; ::('$_').defined or die '$_ is not defined.'", $_ for @subs;
-} or bail-out 'All subroutines must be defined and exported.';
-require ::($module) @subs.eager;
+require ::($module) <&is-leap-year>;
 
-is .<input>.&is-leap-year, |.<expected description> for @(my $c-data.<cases>);
+my $c-data;
+is &::('is-leap-year')(.<input>), |.<expected description> for @($c-data<cases>);
 
-if %*ENV<EXERCISM> && (my $c-data-file = "$dir/../../x-common/exercises/{$dir.IO.basename}/canonical-data.json".IO.resolve) ~~ :f {
-  is-deeply $c-data, from-json($c-data-file.slurp), 'canonical-data'
-} else { skip }
+if %*ENV<EXERCISM> && (my $c-data-file =
+  "$dir/../../x-common/exercises/{$dir.IO.resolve.basename}/canonical-data.json".IO.resolve) ~~ :f
+{ is-deeply $c-data, from-json($c-data-file.slurp), 'canonical-data' } else { skip }
 
 done-testing;
 
 INIT {
-  $c-data := from-json ｢
+$c-data := from-json q:to/END/;
+
+{
+  "exercise": "leap",
+  "version": "1.0.0",
+  "cases": [
+    {
+      "description": "year not divisible by 4: common year",
+      "property": "leapYear",
+      "input": 2015,
+      "expected": false
+    },
+    {
+      "description": "year divisible by 4, not divisible by 100: leap year",
+      "property": "leapYear",
+      "input": 2016,
+      "expected": true
+    },
     {
-      "exercise": "leap",
-      "version": "1.0.0",
-      "cases": [
-        {
-          "description": "year not divisible by 4: common year",
-          "property": "leapYear",
-          "input": 2015,
-          "expected": false
-        },
-        {
-          "description": "year divisible by 4, not divisible by 100: leap year",
-          "property": "leapYear",
-          "input": 2016,
-          "expected": true
-        },
-        {
-          "description": "year divisible by 100, not divisible by 400: common year",
-          "property": "leapYear",
-          "input": 2100,
-          "expected": false
-        },
-        {
-          "description": "year divisible by 400: leap year",
-          "property": "leapYear",
-          "input": 2000,
-          "expected": true
-        }
-      ]
+      "description": "year divisible by 100, not divisible by 400: common year",
+      "property": "leapYear",
+      "input": 2100,
+      "expected": false
+    },
+    {
+      "description": "year divisible by 400: leap year",
+      "property": "leapYear",
+      "input": 2000,
+      "expected": true
     }
-  ｣
+  ]
+}
+
+END
 }

data/tracks/perl6/exercises/phone-number/{Example.pm → Example.pm6}

@@ -1,6 +1,6 @@
-unit module Phone:ver<2>;
+unit module Phone:ver<3>;
 
 sub clean-number ($number is copy) is export {
-  $number ~~ /<:L>/ ?? return Nil !! $number ~~ s:g/<:!Nd>//;
+  $number ~~ s:g/<:!Nd>//;
   $number ~~ /^ 1? ( [ <[2..9]> <:Nd> ** 2 ] ** 2 <:Nd> ** 4 ) $/ ?? ~$0 !! Nil;
 }

data/tracks/perl6/exercises/phone-number/PhoneNumber.pm6

@@ -1,4 +1,4 @@
-unit module Phone:ver<2>;
+unit module Phone:ver<3>;
 
 sub clean-number ($number) is export {
 }

data/tracks/perl6/exercises/phone-number/example.yaml

@@ -1,6 +1,6 @@
 exercise: Phone
-version: 2
-plan: 15
+version: 3
+plan: 14
 imports: '&clean-number'
 tests: |
   for @($c-data<cases>[0]<cases>) {

data/tracks/perl6/exercises/phone-number/phone-number.t

@@ -5,9 +5,9 @@ use lib my $dir = $?FILE.IO.dirname;
 use JSON::Tiny;
 
 my $exercise = 'Phone';
-my $version = v2;
+my $version = v3;
 my $module = %*ENV<EXERCISM> ?? 'Example' !! $exercise;
-plan 15;
+plan 14;
 
 use-ok $module or bail-out;
 require ::($module);
@@ -41,7 +41,7 @@ $c-data := from-json q:to/END/;
 
 {
   "exercise": "phone-number",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "cases": [
     {
       "description": "Cleanup user-entered phone numbers",
@@ -111,12 +111,6 @@ $c-data := from-json q:to/END/;
           "phrase": "123-@:!-7890",
           "expected": null
         },
-        {
-          "description": "invalid with right number of digits but letters mixed in",
-          "property": "clean",
-          "phrase": "1a2b3c4d5e6f7g8h9i0j",
-          "expected": null
-        },
         {
           "description": "invalid if area code does not start with 2-9",
           "property": "clean",

data/tracks/python/.github/stale.yml

@@ -1,17 +1,17 @@
 # Number of days of inactivity before an issue becomes stale
-daysUntilStale: 21
+daysUntilStale: 60
 # Number of days of inactivity before a stale issue is closed
 daysUntilClose: 7
 # Issues with these labels will never be considered stale
 exemptLabels:
+  - discussion
   - pinned
-  - security
 # Label to use when marking an issue as stale
 staleLabel: on hiatus
 # Comment to post when marking an issue as stale. Set to `false` to disable
 markComment: >
-  This issue has been automatically marked as `on hiatus because it has not had
+  This issue has been automatically marked as `on hiatus` because it has not had
   recent activity. It will be closed if no further activity occurs. Thank you
   for your contributions.
 # Comment to post when closing a stale issue. Set to `false` to disable
-closeComment: false
+closeComment: false

data/tracks/python/config.json

@@ -416,6 +416,12 @@
       "topics": [
       ]
     },
+    {
+      "slug": "book-store",
+      "difficulty": 1,
+      "topics": [
+      ]
+    },
     {
       "slug": "linked-list",
       "difficulty": 1,
@@ -428,6 +434,12 @@
       "topics": [
       ]
     },
+    {
+      "slug": "variable-length-quantity",
+      "difficulty": 1,
+      "topics": [
+      ]
+    },
     {
       "slug": "all-your-base",
       "difficulty": 4,
@@ -463,6 +475,18 @@
         "strings",
         "searching"
       ]
+    },
+    {
+      "slug": "alphametics",
+      "difficulty": 6,
+      "topics": [
+      ]
+    },
+    {
+      "slug": "tournament",
+      "difficulty": 1,
+      "topics": [
+      ]
     }
   ],
   "deprecated": [

data/tracks/python/exercises/alphametics/alphametics.py

@@ -0,0 +1,2 @@
+def solve():
+    pass

data/tracks/python/exercises/alphametics/alphametics_test.py

@@ -0,0 +1,71 @@
+import unittest
+
+from alphametics import solve
+
+
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+
+class TestAlphametics(unittest.TestCase):
+    def test_puzzle_with_three_letters(self):
+        self.assertEqual(solve("I + BB == ILL"), {"I": 1, "B": 9, "L": 0})
+
+    def solution_must_have_unique_value_for_each_letter(self):
+        self.assertEqual(solve("A == B"), {})
+
+    def leading_zero_solution_is_invalid(self):
+        self.assertEqual(solve("ACA + DD == BD"), {})
+
+    def test_puzzle_with_four_letters(self):
+        self.assertEqual(
+            solve("AS + A == MOM"), {"A": 9, "S": 2, "M": 1, "O": 0})
+
+    def puzzle_with_six_letters(self):
+        self.assertEqual(
+            solve("NO + NO + TOO == LATE"),
+            {"N": 7,
+             "O": 4,
+             "T": 9,
+             "L": 1,
+             "A": 0,
+             "E": 2})
+
+    def test_puzzle_with_seven_letters(self):
+        self.assertEqual(
+            solve("HE + SEES + THE == LIGHT"),
+            {"E": 4,
+             "G": 2,
+             "H": 5,
+             "I": 0,
+             "L": 1,
+             "S": 9,
+             "T": 7})
+
+    def test_puzzle_with_eight_letters(self):
+        self.assertEqual(
+            solve("SEND + MORE == MONEY"),
+            {"S": 9,
+             "E": 5,
+             "N": 6,
+             "D": 7,
+             "M": 1,
+             "O": 0,
+             "R": 8,
+             "Y": 2})
+
+    def test_puzzle_with_ten_letters(self):
+        self.assertEqual(
+            solve("AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE"),
+            {"A": 5,
+             "D": 3,
+             "E": 4,
+             "F": 7,
+             "G": 8,
+             "N": 0,
+             "O": 2,
+             "R": 1,
+             "S": 6,
+             "T": 9})
+
+
+if __name__ == '__main__':
+    unittest.main()

data/tracks/python/exercises/alphametics/example.py

@@ -0,0 +1,29 @@
+from itertools import combinations, permutations
+
+
+def check_leading_zeros(*numbers):
+    return any(n[0] == '0' for n in numbers)
+
+
+def test_equation(puzzle, substitutions):
+    equation = ''.join(substitutions.get(char) or char for char in puzzle)
+    left, right = equation.split(' == ')
+    left_numbers = left.split(' + ')
+
+    if check_leading_zeros(right, *left_numbers):
+        return False
+
+    return sum(map(int, left_numbers)) == int(right)
+
+
+def solve(puzzle):
+    letters = set(char for char in puzzle if char.isupper())
+    numbers = map(str, range(10))
+
+    for c in combinations(numbers, len(letters)):
+        for p in permutations(c):
+            substitutions = dict(zip(letters, p))
+            if test_equation(puzzle, substitutions):
+                return {k: int(v) for k, v in substitutions.items()}
+
+    return {}  # no solution found

data/tracks/python/exercises/book-store/book_store.py

@@ -0,0 +1,2 @@
+def calculate_total():
+    pass

data/tracks/python/exercises/book-store/book_store_test.py

@@ -0,0 +1,72 @@
+import unittest
+
+from book_store import calculate_total
+
+
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+
+class BookStoreTests(unittest.TestCase):
+    def test_only_a_single_book(self):
+        self.assertAlmostEqual(calculate_total([1]), 8.00,
+                               places=2)
+
+    def test_two_of_the_same_book(self):
+        self.assertAlmostEqual(calculate_total([2, 2]), 16.00,
+                               places=2)
+
+    def test_empty_basket(self):
+        self.assertAlmostEqual(calculate_total([]), 0.00,
+                               places=2)
+
+    def test_two_different_books(self):
+        self.assertAlmostEqual(calculate_total([1, 2]), 15.20,
+                               places=2)
+
+    def test_three_different_books(self):
+        self.assertAlmostEqual(calculate_total([1, 2, 3]), 21.60,
+                               places=2)
+
+    def test_four_different_books(self):
+        self.assertAlmostEqual(calculate_total([1, 2, 3, 4]), 25.60,
+                               places=2)
+
+    def test_five_different_books(self):
+        self.assertAlmostEqual(
+            calculate_total([1, 2, 3, 4, 5]), 30.00,
+            places=2)
+
+    def test_two_groups_of_4_is_cheaper_than_group_of_5_plus_group_of_3(self):
+        self.assertAlmostEqual(
+            calculate_total([1, 1, 2, 2, 3, 3, 4, 5]), 51.20,
+            places=2)
+
+    def test_group_of_4_plus_group_of_2_is_cheaper_than_2_groups_of_3(self):
+        self.assertAlmostEqual(
+            calculate_total([1, 1, 2, 2, 3, 4]), 40.80,
+            places=2)
+
+    def test_two_each_of_first_4_books_and_1_copy_each_of_rest(self):
+        self.assertAlmostEqual(
+            calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5]), 55.60,
+            places=2)
+
+    def test_two_copies_of_each_book(self):
+        self.assertAlmostEqual(
+            calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5, 5]), 60.00,
+            places=2)
+
+    def test_three_copies_of_first_book_and_2_each_of_remaining(self):
+        self.assertAlmostEqual(
+            calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1]),
+            68.00,
+            places=2)
+
+    def test_three_each_of_first_2_books_and_2_each_of_remaining_books(self):
+        self.assertAlmostEqual(
+            calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1, 2]),
+            75.20,
+            places=2)
+
+
+if __name__ == '__main__':
+    unittest.main()

data/tracks/python/exercises/book-store/example.py

@@ -0,0 +1,29 @@
+BOOK_PRICE = 8
+
+
+def _group_price(size):
+    discounts = [0, .05, .1, .2, .25]
+    if not (0 < size <= 5):
+        raise ValueError('size must be in 1..' + len(discounts))
+    return 8 * size * (1 - discounts[size - 1])
+
+
+def calculate_total(books, price_so_far=0.):
+    if not books:
+        return price_so_far
+
+    groups = list(set(books))
+    min_price = float('inf')
+
+    for i in range(len(groups)):
+
+        remaining_books = books[:]
+
+        for v in groups[:i + 1]:
+            remaining_books.remove(v)
+
+        price = calculate_total(remaining_books,
+                                price_so_far + _group_price(i + 1))
+        min_price = min(min_price, price)
+
+    return min_price