trackler 2.0.0.1 → 2.0.0.2

data/tracks/ocaml/config.json

@@ -3,36 +3,6 @@
   "language": "OCaml",
   "repository": "https://github.com/exercism/xocaml",
   "active": true,
-  "problems": [
-    "hello-world",
-    "bob",
-    "difference-of-squares",
-    "list-ops",
-    "leap",
-    "word-count",
-    "anagram",
-    "beer-song",
-    "nucleotide-count",
-    "rna-transcription",
-    "raindrops",
-    "hamming",
-    "phone-number",
-    "grade-school",
-    "space-age",
-    "roman-numerals",
-    "custom-set",
-    "bowling",
-    "minesweeper",
-    "prime-factors",
-    "etl",
-    "hexadecimal",
-    "atbash-cipher",
-    "luhn",
-    "say",
-    "meetup",
-    "zipper",
-    "hangman"
-  ],
   "exercises": [
     {
       "slug": "hello-world",
@@ -40,138 +10,138 @@
       "topics": []
     },
     {
-      "slug": "bob",
+      "slug": "leap",
       "difficulty": 1,
       "topics": []
     },
     {
-      "slug": "difference-of-squares",
-      "difficulty": 1,
+      "slug": "hamming",
+      "difficulty": 2,
       "topics": []
     },
     {
-      "slug": "list-ops",
-      "difficulty": 1,
+      "slug": "raindrops",
+      "difficulty": 2,
       "topics": []
     },
     {
-      "slug": "leap",
-      "difficulty": 1,
+      "slug": "difference-of-squares",
+      "difficulty": 2,
       "topics": []
     },
     {
-      "slug": "word-count",
-      "difficulty": 1,
+      "slug": "rna-transcription",
+      "difficulty": 2,
       "topics": []
     },
     {
-      "slug": "anagram",
-      "difficulty": 1,
+      "slug": "nucleotide-count",
+      "difficulty": 2,
       "topics": []
     },
     {
-      "slug": "beer-song",
-      "difficulty": 1,
+      "slug": "etl",
+      "difficulty": 3,
       "topics": []
     },
     {
-      "slug": "nucleotide-count",
-      "difficulty": 1,
+      "slug": "grade-school",
+      "difficulty": 3,
       "topics": []
     },
     {
-      "slug": "rna-transcription",
-      "difficulty": 1,
+      "slug": "bob",
+      "difficulty": 3,
       "topics": []
     },
     {
-      "slug": "raindrops",
-      "difficulty": 1,
+      "slug": "hexadecimal",
+      "difficulty": 3,
       "topics": []
     },
     {
-      "slug": "hamming",
-      "difficulty": 1,
+      "slug": "anagram",
+      "difficulty": 3,
       "topics": []
     },
     {
-      "slug": "phone-number",
-      "difficulty": 1,
+      "slug": "space-age",
+      "difficulty": 3,
       "topics": []
     },
     {
-      "slug": "grade-school",
-      "difficulty": 1,
+      "slug": "bowling",
+      "difficulty": 4,
       "topics": []
     },
     {
-      "slug": "space-age",
-      "difficulty": 1,
+      "slug": "luhn",
+      "difficulty": 4,
       "topics": []
     },
     {
-      "slug": "roman-numerals",
-      "difficulty": 1,
+      "slug": "phone-number",
+      "difficulty": 4,
       "topics": []
     },
     {
-      "slug": "custom-set",
-      "difficulty": 1,
+      "slug": "word-count",
+      "difficulty": 4,
       "topics": []
     },
     {
-      "slug": "bowling",
-      "difficulty": 1,
+      "slug": "beer-song",
+      "difficulty": 4,
       "topics": []
     },
     {
-      "slug": "minesweeper",
-      "difficulty": 1,
+      "slug": "roman-numerals",
+      "difficulty": 5,
       "topics": []
     },
     {
       "slug": "prime-factors",
-      "difficulty": 1,
+      "difficulty": 5,
       "topics": []
     },
     {
-      "slug": "etl",
-      "difficulty": 1,
+      "slug": "say",
+      "difficulty": 5,
       "topics": []
     },
     {
-      "slug": "hexadecimal",
-      "difficulty": 1,
+      "slug": "list-ops",
+      "difficulty": 6,
       "topics": []
     },
     {
       "slug": "atbash-cipher",
-      "difficulty": 1,
+      "difficulty": 7,
       "topics": []
     },
     {
-      "slug": "luhn",
-      "difficulty": 1,
+      "slug": "minesweeper",
+      "difficulty": 7,
       "topics": []
     },
     {
-      "slug": "say",
-      "difficulty": 1,
+      "slug": "custom-set",
+      "difficulty": 8,
       "topics": []
     },
     {
       "slug": "meetup",
-      "difficulty": 1,
+      "difficulty": 9,
       "topics": ["Dates"]
     },
     {
       "slug": "zipper",
-      "difficulty": 1,
+      "difficulty": 10,
       "topics": []
     },
     {
       "slug": "hangman",
-      "difficulty": 1,
+      "difficulty": 10,
        "topics": []
     }
   ],

data/tracks/perl5/README.md

@@ -2,6 +2,10 @@
 
 Exercism exercises in Perl 5
 
+## Dependencies
+
+The tests depend on the JSON.pm module.
+
 ## Testing the Tests
 
 When the tests are run they expect a module with some real name (e.g. Anagram.pm)
@@ -12,23 +16,26 @@ If they are called /*example.*/i they won't be copied to the users. (which is a
 
 So the sample solutions are all called Example.pm.
 
-Each test file will look for the appropriate module name, but if the test are run as
+### Testing All the Exercises
 
-   EXERCISM=1 perl file.t
+Run the full tests with
 
-then they will expect a file called Example.pm
+    perl testall.pl
 
-## Contributing Guide
+### Testing a Single Exercise
 
-Please see the [contributing guide](https://github.com/exercism/x-api/blob/master/CONTRIBUTING.md#the-exercise-data)
+Each test file will look for the appropriate module name, but if the test are run as
 
-## License
+    EXERCISM=1 perl file.t
 
-The MIT License (MIT)
+then they will expect a file called Example.pm
 
-Copyright (c) 2014 Katrina Owen, _@kytrinyx.com
+## Contributing Guide
+
+Please see the [contributing guide](https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md)
 
 ### Perl 5 icon
+
 The onion is the logo of the Perl Foundation.
 It is trademarked, and we have adapted it--changing the color--with their permission.
 The Perl Foundation does not support or endorse Exercism.

data/tracks/perl5/testall.pl

@@ -9,10 +9,10 @@ close $dh;
 $ENV{EXERCISM} = 1;
 foreach my $d (@dirs) {
 	say $d;
-    chdir $d;
-    opendir my $dh, '.' or die;
-    my ($test) = grep { /\.t$/ } readdir $dh;
-    close $dh;
+	chdir $d;
+	opendir my $dh, '.' or die;
+	my ($test) = grep { /\.t$/ } readdir $dh;
+	close $dh;
 	system "prove $test";
-    chdir '..';
+	chdir '..';
 }

data/tracks/php/config.json

@@ -3,39 +3,6 @@
   "language": "PHP",
   "repository": "https://github.com/exercism/xphp",
   "active": true,
-  "problems": [
-    "hello-world",
-    "hamming",
-    "gigasecond",
-    "bob",
-    "pangram",
-    "rna-transcription",
-    "raindrops",
-    "isogram",
-    "difference-of-squares",
-    "largest-series-product",
-    "roman-numerals",
-    "pig-latin",
-    "robot-name",
-    "leap",
-    "word-count",
-    "anagram",
-    "trinary",
-    "bowling",
-    "clock",
-    "wordy",
-    "connect",
-    "minesweeper",
-    "change",
-    "phone-number",
-    "beer-song",
-    "atbash-cipher",
-    "binary",
-    "braket-push",
-    "accumulate",
-    "variable-length-quantity",
-    "acronym"
-  ],
   "deprecated": [
 
   ],
@@ -201,6 +168,31 @@
     "slug": "acronym",
     "difficulty": 1,
     "topics": []
+  },
+  {
+    "slug": "nucleotide-count",
+    "difficulty": 1,
+    "topics": []
+  },
+  {
+    "slug": "triangle",
+    "difficulty": 1,
+    "topics": []
+  },
+  {
+    "slug": "etl",
+    "difficulty": 1,
+    "topics": []
+  },
+  {
+    "slug": "space-age",
+    "difficulty": 1,
+    "topics": []
+  },
+  {
+    "slug": "allergies",
+    "difficulty": 3,
+    "topics": []
   }
-]
+  ]
 }

data/tracks/php/docs/ABOUT.md

@@ -0,0 +1,15 @@
+PHP is a server-side language suited towards web development. The acronym is recursive, standing for *PHP: Hypertext Preprocessor*. 
+
+Considerably more versatile than CGI scripting, PHP is often used to add interactivity to plain HTML and bolster web frameworks.
+
+The language can be employed on any operating system. PHP is supported by most common web servers and is often handled through an interpreter module. This combines static web code with dynamic inclusions. 
+
+PHP isn't just a web server framework. It's also useful for command-line scripting (headless parsing) and developing GUIs. 
+
+You should learn PHP because:
+
+* it's an Open Source language
+* it's well-documented and supported
+* it's compatible with most common web servers
+* it's easy to pick up and start learning
+* it's highly scalable and extensible

data/tracks/php/exercises/allergies/allergies_test.php

@@ -0,0 +1,121 @@
+<?php
+
+require "allergies.php";
+
+class AllergiesTest extends \PHPUnit_Framework_TestCase
+{
+
+    /**
+     * @dataProvider provideListOfAllergen
+     */
+    public function testNoAllergiesMeansNotAllergicToAnything($allergen)
+    {
+        $allergies = new Allergies(0);
+
+        $this->assertFalse($allergies->isAllergicTo($allergen));
+    }
+
+    /**
+     * @dataProvider provideListOfAllergen
+     */
+    public function testAllergiesToOneAllergen($allergicTo)
+    {
+        $this->markTestSkipped();
+        $allergies = new Allergies($allergicTo->getScore());
+
+        $this->assertTrue($allergies->isAllergicTo($allergicTo));
+        $otherAllergen = array_filter(Allergen::allergenList(), function ($allergen) use ($allergicTo) {
+            return $allergen != $allergicTo;
+        });
+        $self = $this;
+        array_map(function ($allergen) use ($allergies, $self) {
+            $self->assertFalse($allergies->isAllergicTo($allergen));
+        }, $otherAllergen);
+    }
+
+    public function provideListOfAllergen()
+    {
+        return [
+            [new Allergen(Allergen::CATS), 'Only allergic to cats'],
+            [new Allergen(Allergen::CHOCOLATE), 'Only allergic to chocolate'],
+            [new Allergen(Allergen::EGGS), 'Only allergic to eggs'],
+            [new Allergen(Allergen::PEANUTS), 'Only allergic to peanuts'],
+            [new Allergen(Allergen::POLLEN), 'Only allergic to pollen'],
+            [new Allergen(Allergen::SHELLFISH), 'Only allergic to shellfish'],
+            [new Allergen(Allergen::STRAWBERRIES), 'Only allergic to strawberries'],
+            [new Allergen(Allergen::TOMATOES), 'Only allergic to tomatoes'],
+        ];
+    }
+
+    public function testAllergicToEggsInAdditionToOtherStuff()
+    {
+        $this->markTestSkipped();
+        $allergies = new Allergies(5);
+
+        $this->assertTrue($allergies->isAllergicTo(new Allergen(Allergen::EGGS)));
+    }
+
+
+    public function testIsAllergicToLotsOfStuffs()
+    {
+        $this->markTestSkipped();
+        $allergies = new Allergies(248);
+
+        $this->assertEquals([
+            new Allergen(Allergen::CATS),
+            new Allergen(Allergen::CHOCOLATE),
+            new Allergen(Allergen::POLLEN),
+            new Allergen(Allergen::STRAWBERRIES),
+            new Allergen(Allergen::TOMATOES),
+        ], $allergies->getList(), "\$canonicalize = true", $delta = 0.0, $maxDepth = 10, $canonicalize = true);
+    }
+
+    public function testIsAllergicToEggsAndPeanuts()
+    {
+        $this->markTestSkipped();
+        $allergies = new Allergies(3);
+
+        $this->assertEquals([
+            new Allergen(Allergen::EGGS),
+            new Allergen(Allergen::PEANUTS),
+        ], $allergies->getList(), "\$canonicalize = true", $delta = 0.0, $maxDepth = 10, $canonicalize = true);
+    }
+
+    public function testIsAllergicToEgssAndShellfish()
+    {
+        $this->markTestSkipped();
+        $allergies = new Allergies(5);
+
+        $this->assertEquals([
+            new Allergen(Allergen::EGGS),
+            new Allergen(Allergen::SHELLFISH),
+        ], $allergies->getList(), "\$canonicalize = true", $delta = 0.0, $maxDepth = 10, $canonicalize = true);
+    }
+
+    public function testIgnoreNonAllergenScorePart()
+    {
+        $this->markTestSkipped();
+        $allergies = new Allergies(509);
+
+        $this->assertEquals([
+            new Allergen(Allergen::CATS),
+            new Allergen(Allergen::CHOCOLATE),
+            new Allergen(Allergen::EGGS),
+            new Allergen(Allergen::POLLEN),
+            new Allergen(Allergen::SHELLFISH),
+            new Allergen(Allergen::STRAWBERRIES),
+            new Allergen(Allergen::TOMATOES),
+        ], $allergies->getList(), "\$canonicalize = true", $delta = 0.0, $maxDepth = 10, $canonicalize = true);
+    }
+
+    /**
+     * @dataProvider provideListOfAllergen
+     */
+    public function testIsAllergicToEverything($allergen)
+    {
+        $this->markTestSkipped();
+        $allergies = new Allergies(255);
+
+        $this->assertTrue($allergies->isAllergicTo($allergen));
+    }
+}

data/tracks/php/exercises/allergies/example.php

@@ -0,0 +1,64 @@
+<?php
+
+class Allergies
+{
+    private $score;
+
+    public function __construct($score)
+    {
+        $this->score = $score;
+    }
+
+    public function getList()
+    {
+        $score = $this->score;
+        return array_filter(Allergen::allergenList(), function ($allergen) use ($score) {
+            return $this->isAllergicTo($allergen);
+        });
+    }
+
+    public function isAllergicTo(Allergen $allergen)
+    {
+        return ($this->score & $allergen->getScore()) == $allergen->getScore();
+    }
+}
+
+
+class Allergen
+{
+
+    const EGGS = 1;
+    const PEANUTS = 2;
+    const SHELLFISH = 4;
+    const STRAWBERRIES = 8;
+    const TOMATOES = 16;
+    const CHOCOLATE = 32;
+    const POLLEN = 64;
+    const CATS = 128;
+
+    private $score;
+
+    public function __construct($score)
+    {
+        $this->score = $score;
+    }
+
+    public function getScore()
+    {
+        return $this->score;
+    }
+
+    public static function allergenList()
+    {
+        return [
+            new Allergen(Allergen::CATS),
+            new Allergen(Allergen::CHOCOLATE),
+            new Allergen(Allergen::EGGS),
+            new Allergen(Allergen::PEANUTS),
+            new Allergen(Allergen::POLLEN),
+            new Allergen(Allergen::SHELLFISH),
+            new Allergen(Allergen::STRAWBERRIES),
+            new Allergen(Allergen::TOMATOES),
+        ];
+    }
+}

data/tracks/php/exercises/etl/etl_test.php

@@ -0,0 +1,52 @@
+<?php
+
+require "etl.php";
+
+class TransformTest extends PHPUnit_Framework_TestCase
+{
+    public function testTransformOneValue()
+    {
+        $old         = [ '1' => ['A'] ];
+        $expected    = [ 'a' => 1 ];
+        $this->assertEquals($expected, transform($old));
+    }
+
+    public function testTransformMoreValues()
+    {
+        $this->markTestSkipped();
+        $old         = [ '1' => str_split('AEIOU') ];
+        $expected    = [ 'a' => 1, 'e' => 1, 'i' => 1, 'o' => 1, 'u' => 1 ];
+        $this->assertEquals($expected, transform($old));
+    }
+
+    public function testTransformMoreKeys()
+    {
+        $this->markTestSkipped();
+        $old         = [ '1' => str_split('AE'), '2' => str_split('DG') ];
+        $expected    = [ 'a' => 1, 'e' => 1, 'd' => 2, 'g' => 2 ];
+        $this->assertEquals($expected, transform($old));
+    }
+
+    public function testTransformFullDataset()
+    {
+        $this->markTestSkipped();
+        $old = [
+            '1' => str_split('AEIOULNRST'),
+            '2' => str_split('DG'),
+            '3' => str_split('BCMP'),
+            '4' => str_split('FHVWY'),
+            '5' => str_split('K'),
+            '8' => str_split('JX'),
+            '10' => str_split('QZ')
+        ];
+        $expected = [
+            'a' => 1, 'b' => 3, 'c' => 3, 'd' => 2, 'e' => 1,
+            'f' => 4, 'g' => 2, 'h' => 4, 'i' => 1, 'j' => 8,
+            'k' => 5, 'l' => 1, 'm' => 3, 'n' => 1, 'o' => 1,
+            'p' => 3, 'q' => 10, 'r' => 1, 's' => 1, 't' => 1,
+            'u' => 1, 'v' => 4, 'w' => 4, 'x' => 8, 'y' => 4,
+            'z' => 10
+        ];
+        $this->assertEquals($expected, transform($old));
+    }
+}

data/tracks/php/exercises/etl/example.php

@@ -0,0 +1,12 @@
+<?php
+
+function transform($old)
+{
+    $new = [];
+    foreach ($old as $points => $letters) {
+        foreach ($letters as $letter) {
+            $new[strtolower($letter)] = $points;
+        }
+    }
+    return $new;
+}

data/tracks/php/exercises/nucleotide-count/example.php

@@ -0,0 +1,25 @@
+<?php
+
+
+function nucleotideCount($dna)
+{
+    $nucleotides = [];
+    if (strlen($dna) > 0) {
+        $nucleotides = str_split($dna);
+    }
+    $count = array_reduce($nucleotides, function ($count, $nucleotide) {
+        if (! in_array(strtolower($nucleotide), ['a', 'c', 'g', 't'])) {
+            throw new InvalidArgumentException(sprintf('The nucleotide %s does not exist in DNA', $nucleotide));
+        }
+        $count[strtolower($nucleotide)]++;
+
+        return $count;
+    }, [
+        'a' => 0,
+        'c' => 0,
+        't' => 0,
+        'g' => 0,
+    ]);
+
+    return $count;
+}

data/tracks/php/exercises/nucleotide-count/nucleotide-count_test.php

@@ -0,0 +1,36 @@
+<?php
+
+require "nucleotide-count.php";
+
+class NucleotideCountTest extends \PHPUnit_Framework_TestCase
+{
+    public function testEmptyDNASequence()
+    {
+        $this->assertSame([
+            'a' => 0,
+            'c' => 0,
+            't' => 0,
+            'g' => 0,
+        ], nucleotideCount(''));
+    }
+
+    public function testRepetitiveDNASequence()
+    {
+        $this->assertSame([
+            'a' => 9,
+            'c' => 0,
+            't' => 0,
+            'g' => 0,
+        ], nucleotideCount('AAAAAAAAA'));
+    }
+
+    public function testDNASequence()
+    {
+        $this->assertSame([
+            'a' => 20,
+            'c' => 12,
+            't' => 21,
+            'g' => 17,
+        ], nucleotideCount('AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC'));
+    }
+}