trackler 2.2.1.53 → 2.2.1.54

data/tracks/javascript/exercises/zipper/zipper.spec.js

@@ -0,0 +1,77 @@
+var Zipper = require('./zipper');
+
+// Tests adapted from `problem-specifications/zipper/canonical-data.json` @ v1.0.0
+
+function bt(value, left, right) {
+  return {
+    value: value,
+    left: left,
+    right: right
+  };
+}
+
+function leaf(value) {
+  return bt(value, null, null);
+}
+
+describe('Zipper', function () {
+  var t1 = bt(1, bt(2, null, leaf(3)), leaf(4));
+  var t2 = bt(1, bt(5, null, leaf(3)), leaf(4));
+  var t3 = bt(1, bt(2, leaf(5), leaf(3)), leaf(4));
+  var t4 = bt(1, leaf(2), leaf(4));
+  var t5 = bt(1, bt(2, null, leaf(3)), bt(6, leaf(7), leaf(8)));
+  var t6 = bt(1, bt(2, null, leaf(5)), leaf(4));
+  var zipper;
+
+  beforeEach(function () {
+    zipper = Zipper.fromTree(t1);
+  });
+
+  it('data is retained', function () {
+    expect(zipper.toTree(t1)).toEqual(t1);
+  });
+
+  xit('left, right and value', function () {
+    expect(zipper.left().right().value()).toEqual(3);
+  });
+
+  xit('dead end', function () {
+    expect(zipper.left().left()).toBe(null);
+  });
+
+  xit('tree from deep focus', function () {
+    expect(zipper.left().right().toTree()).toEqual(t1);
+  });
+
+  xit('traversing up from top', function () {
+    expect(zipper.up()).toEqual(null);
+  });
+
+  xit('left, right and up', function () {
+    expect(zipper.left().up().right().up().left().right().value()).toEqual(3);
+  });
+
+  xit('setValue', function () {
+    expect(zipper.left().setValue(5).toTree()).toEqual(t2);
+  });
+
+  xit('setValue after traversing up', function () {
+    expect(zipper.left().right().up().setValue(5).toTree()).toEqual(t2);
+  });
+
+  xit('setLeft with leaf', function () {
+    expect(zipper.left().setLeft(leaf(5)).toTree()).toEqual(t3);
+  });
+
+  xit('setRight with null', function () {
+    expect(zipper.left().setRight(null).toTree()).toEqual(t4);
+  });
+
+  xit('setRight with subtree', function () {
+    expect(zipper.setRight(bt(6, leaf(7), leaf(8))).toTree()).toEqual(t5);
+  });
+
+  xit('setValue on deep focus', function () {
+    expect(zipper.left().right().setValue(5).toTree()).toEqual(t6);
+  });
+});

data/tracks/julia/config.json

@@ -308,6 +308,18 @@
         "regular_expressions"
       ]
     },
+    {
+      "uuid": "7ea2903f-049b-ed80-3f87-73945ebf3d4577b715e",
+      "slug": "triangle",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+		"conditionals",
+		"functional abstraction",
+		"mathematics"
+      ]
+    },
     {
       "uuid": "e5a6d640-cd76-4453-8247-fd34ffed4fe5",
       "slug": "transpose",

data/tracks/julia/exercises/triangle/README.md

@@ -0,0 +1,30 @@
+# Triangle
+
+Determine if a triangle is equilateral, isosceles, or scalene.
+
+An _equilateral_ triangle has all three sides the same length.
+
+An _isosceles_ triangle has at least two sides the same length. (It is sometimes
+specified as having exactly two sides the same length, but for the purposes of
+this exercise we'll say at least two.)
+
+A _scalene_ triangle has all sides of different lengths.
+
+## Note
+
+For a shape to be a triangle at all, all sides have to be of length > 0, and
+the sum of the lengths of any two sides must be greater than or equal to the
+length of the third side. See [Triangle Inequality](https://en.wikipedia.org/wiki/Triangle_inequality).
+
+## Dig Deeper
+
+The case where the sum of the lengths of two sides _equals_ that of the
+third is known as a _degenerate_ triangle - it has zero area and looks like
+a single line. Feel free to add your own code/tests to check for degenerate triangles.
+## Source
+
+The Ruby Koans triangle project, parts 1 & 2 [http://rubykoans.com](http://rubykoans.com)
+
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/julia/exercises/triangle/example.jl

@@ -0,0 +1,25 @@
+# This problem gives practice on reusing procedures by extracting them as functions.
+
+function is_equilateral(sides)
+    sides = sort(sides)
+    return verify_triangle(sides) && verify_equilateral(sides)
+end
+
+function is_isosceles(sides)
+    sides = sort(sides)
+    return verify_triangle(sides) && verify_isosceles(sides)
+end
+
+function is_scalene(sides)
+    sides = sort(sides)
+    return verify_triangle(sides) && verify_scalene(sides)
+end
+
+
+verify_equilateral(sorted) = (sorted[1] == sorted[3])
+
+verify_isosceles(sorted) = (sorted[1] == sorted[2] || sorted[2] == sorted[3])
+
+verify_scalene(sorted) = !verify_isosceles(sorted)
+
+verify_triangle(sorted) = (sorted[3] < sorted[1] + sorted[2])

data/tracks/julia/exercises/triangle/runtests.jl

@@ -0,0 +1,64 @@
+using Base.Test
+
+include("triangle.jl")
+
+@testset "check equilateral triangles" begin
+    @testset "true if all sides are equal" begin
+        @test is_equilateral([2, 2, 2]) == true
+        @test is_equilateral([0.5, 0.5, 0.5]) == true
+    end
+
+    @testset "false if any side is unequal" begin
+        @test is_equilateral([2, 3, 2]) == false
+    end
+
+    @testset "false if no sides are equal" begin
+        @test is_equilateral([5, 4, 6]) == false
+    end
+
+    @testset "false if invalid triangle" begin
+        @test is_equilateral([0, 0, 0]) == false
+    end
+end
+
+@testset "check isosceles triangles" begin
+    @testset "true if at least 2 sides are equal" begin
+        @test is_isosceles([3, 4, 4]) == true
+        @test is_isosceles([4, 3, 4]) == true
+        @test is_isosceles([4, 4, 3]) == true
+        @test is_isosceles([4, 4, 4]) == true
+        @test is_isosceles([0.4, 0.5, 0.5]) == true
+        @test is_isosceles([0.5, 0.4, 0.5]) == true
+        @test is_isosceles([0.5, 0.5, 0.4]) == true
+    end
+
+    @testset "false if no sides are equal" begin
+        @test is_isosceles([2, 3, 4]) == false
+    end
+
+    @testset "false if invalid triangle" begin
+        @test is_isosceles([1, 1, 3]) == false
+    end
+end
+
+
+@testset "check scalene triangles" begin
+    @testset "true if no sides are equal" begin
+        @test is_scalene([5, 4, 6]) == true
+        @test is_scalene([0.5, 0.4, 0.6]) == true
+    end
+
+    @testset "false if at least 2 sides are equal" begin
+        @test is_scalene([3, 4, 4]) == false
+        @test is_scalene([4, 3, 4]) == false
+        @test is_scalene([4, 4, 3]) == false
+        @test is_scalene([4, 4, 4]) == false
+        @test is_scalene([0.4, 0.5, 0.5]) == false
+        @test is_scalene([0.5, 0.4, 0.5]) == false
+        @test is_scalene([0.5, 0.5, 0.4]) == false
+    end
+
+    @testset "false if invalid triangle" begin
+        @test is_scalene([7, 3, 2]) == false
+    end
+end

data/tracks/julia/exercises/triangle/triangle.jl

@@ -0,0 +1,8 @@
+function is_equilateral(sides)
+end
+
+function is_isosceles(sides)
+end
+
+function is_scalene(sides)
+end

data/tracks/kotlin/exercises/leap/.meta/version

@@ -1 +1 @@
-1.1.0
+1.2.0

data/tracks/kotlin/exercises/leap/src/test/kotlin/LeapTest.kt

@@ -13,7 +13,7 @@ class LeapTest {
     @Ignore
     @Test
     fun yearDivisibleBy4NotDivisibleBy100() {
-        assertTrue(Year(2020).isLeap)
+        assertTrue(Year(1996).isLeap)
     }
 
     @Ignore

data/tracks/kotlin/scripts/canonical_data_check.sh

@@ -106,7 +106,7 @@ do
 
 done
 
-if [ $update_needed_count -eq 1 ]
+if [ $update_needed_count -eq 0 ]
 then
     echo "All exercises are up to date!"
 fi

data/tracks/perl6/bin/README.md

@@ -38,7 +38,4 @@ example: |
   }
 ```
 
-You must have `Template::Mustache` and `YAMLish` to run `exercise-gen.pl6`.
-
-Note (2017-05-22): [YAMLish](http://modules.perl6.org/dist/YAMLish)
-is not yet feature complete, so some valid YAML files may not parse.
+You must have `Template::Mustache` and `YAML::Parser::LibYAML` to run `exercise-gen.pl6`.

data/tracks/perl6/bin/exercise-gen.pl6

@@ -1,7 +1,7 @@
 #!/usr/bin/env perl6
 use v6;
 use Template::Mustache;
-use YAMLish;
+use YAML::Parser::LibYAML;
 
 my $base-dir = $?FILE.IO.resolve.parent.parent;
 my @exercises;
@@ -33,14 +33,13 @@ for @exercises -> $exercise {
     push @dir-not-found, $exercise;
     next;
   }
-  if (my $yaml = $exercise-dir.child('example.yaml')) !~~ :f {
+  if (my $yaml-file = $exercise-dir.child('example.yaml')) !~~ :f {
     push @yaml-not-found, $exercise;
     next;
   };
   print "Generating $exercise... ";
 
-  my %data = load-yaml $yaml.slurp;
-  $_=.chomp when Str for @(%data.values);
+  my %data = yaml-parse $yaml-file.absolute;
 
   my $cdata = $base-dir.child("problem-specifications/exercises/$exercise/canonical-data.json");
   if $cdata ~~ :f {%data<cdata><json> = $cdata.slurp}

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

@@ -2,7 +2,7 @@ exercise: Accumulate
 version: 1
 plan: 7
 imports: '&accumulate'
-tests: |
+tests: |-
   is-deeply accumulate([ ], sub {}),
             [ ],
             'test empty';
@@ -23,7 +23,7 @@ tests: |
             'reverse strings';
 
 unit: module
-example: |
+example: |-
   sub accumulate (@list, $function) is export {
     my @accumulated;
     for @list -> $element {

data/tracks/perl6/exercises/all-your-base/example.yaml

@@ -2,8 +2,8 @@ exercise: AllYourBase
 version: 2
 plan: 23
 imports: '&convert-base'
-tests: |
-  
+tests: |-
+
   for @($c-data<cases>) -> $case {
     if $case<expected> ~~ Array:D { test }
     else {
@@ -17,33 +17,33 @@ tests: |
         flunk "$_; not tested" if %*ENV<EXERCISM>; # To ensure that no canonical-data cases are missed.
       }
     }
-  
+
     sub test (Array:D $expected = $case<expected>) {
       is-deeply call-convert-base, $expected, $case<description>
     }
-  
+
     sub call-convert-base { convert-base(|$case<input_base input_digits output_base>) }
   }
 
 unit: module
-example: |
+example: |-
   class X::AllYourBase::InvalidBase is Exception {
     has $.payload;
     method message {"$!payload is not a valid base."}
   }
-  
+
   class X::AllYourBase::InvalidDigit is Exception {
     has %.payload;
     method message {"%!payload<digit> is not a valid digit for base %!payload<base>."}
   }
-  
+
   sub convert-base (Int:D $input-base, @input-digits, Int:D $output-base --> Array:D) is export {
     for $input-base, $output-base {
       X::AllYourBase::InvalidBase.new(payload => $_).throw if $_ < 2;
     }
     from-decimal($output-base, (to-decimal $input-base, @input-digits));
   }
-  
+
   sub to-decimal ($input-base, @input-digits) {
     return [].Slip if !@input-digits;
     my $elems = @input-digits.elems;
@@ -60,7 +60,7 @@ example: |
     }
     return $dec;
   }
-  
+
   sub from-decimal ($output-base, $dec) {
     my @output-digits;
     my $num = $dec;

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

@@ -2,27 +2,27 @@ exercise: Allergies
 version: 2
 plan: 4
 imports: '&allergic-to &list-allergies'
-tests: |
+tests: |-
   for $c-data<cases>.values -> %case-set {
-  
+
     subtest 'allergic-to' => {
       plan 7;
       for %case-set<cases>.values -> %case {
         is allergic-to(%case<score>, .<substance>), .<result>, %case<description> ~ ': ' ~ .<substance> for %case<expected>.values;
       }
     } when %case-set<description> ~~ 'allergicTo';
-  
+
     subtest 'list-allergies' => {
       plan 9;
       for %case-set<cases>.values {
         cmp-ok list-allergies(.<score>), '~~', .<expected>.Set, .<description>;
       }
     } when %case-set<description> ~~ 'list';
-  
+
   }
 
 unit: module
-example: |
+example: |-
   our @allergens = <
       eggs
       peanuts
@@ -33,11 +33,11 @@ example: |
       pollen
       cats
   >;
-  
+
   sub allergic-to($code,$substance) is export {
       return so $code +& ( 2 ** @allergens.first({ $_ eq $substance},:k) )
   }
-  
+
   sub list-allergies($code) is export {
       return grep { allergic-to($code,$_) }, @allergens;
   }

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

@@ -2,11 +2,11 @@ exercise: Anagram
 version: 1
 plan: 18
 imports: '&match-anagrams'
-tests: |
+tests: |-
   is match-anagrams(|.<subject candidates>), |.<expected description> for @($c-data<cases>);
 
 unit: module
-example: |
+example: |-
   sub match-anagrams ($word, @words) is export {
     my @results;
     my $canonical = canonize($word);
@@ -19,7 +19,7 @@ example: |
     }
     @results;
   }
-  
+
   sub canonize ($str) {
     (($str.lc.split('')).sort).join('');
   }

data/tracks/perl6/exercises/atbash-cipher/example.yaml

@@ -2,7 +2,7 @@ exercise: AtbashCipher
 version: 1
 plan: 4
 imports: '&encode &decode'
-tests: |
+tests: |-
   for @($c-data<cases>) {
     my $test = .<description> ~~ 'encode' ?? 'encode' !! 'decode';
     subtest $test => {
@@ -13,13 +13,13 @@ tests: |
   }
 
 unit: module
-example: |
+example: |-
   sub encode($input) is export {
       decode($input.lc.trans( ['a'..'z', 0..9] => '', :complement ) )
           .comb(5)
           .join: ' ';
   }
-  
+
   sub decode (Str $input) is export {
       return $input
               .lc