trackler 2.0.0.8 → 2.0.0.9

data/tracks/php/exercises/markdown/example.php

@@ -0,0 +1,85 @@
+<?php
+
+function parseMarkdown($markdown)
+{
+    $lines = explode("\n", $markdown);
+
+    $isInList = false;
+
+    foreach ($lines as &$line) {
+        if (preg_match('/^######(.*)/', $line, $matches)) {
+            $line = "<h6>" . trim($matches[1]) . "</h6>";
+        } elseif (preg_match('/^##(.*)/', $line, $matches)) {
+            $line = "<h2>" . trim($matches[1]) . "</h2>";
+        } elseif (preg_match('/^#(.*)/', $line, $matches)) {
+            $line = "<h1>" . trim($matches[1]) . "</h1>";
+        }
+
+        if (preg_match('/\*(.*)/', $line, $matches)) {
+            if (!$isInList) {
+                $isInList = true;
+                $isBold = false;
+                $isItalic = false;
+                if (preg_match('/(.*)__(.*)__(.*)/', $matches[1], $matches2)) {
+                    $matches[1] = $matches2[1] . '<em>' . $matches2[2] . '</em>' . $matches2[3];
+                    $isBold = true;
+                }
+
+                if (preg_match('/(.*)_(.*)_(.*)/', $matches[1], $matches3)) {
+                    $matches[1] = $matches3[1] . '<i>' . $matches3[2] . '</i>' . $matches3[3];
+                    $isItalic = true;
+                }
+
+                if ($isItalic || $isBold) {
+                    $line = "<ul><li>" . trim($matches[1]) . "</li>";
+                } else {
+                    $line = "<ul><li><p>" . trim($matches[1]) . "</p></li>";
+                }
+
+            } else {
+                $isBold = false;
+                $isItalic = false;
+                if (preg_match('/(.*)__(.*)__(.*)/', $matches[1], $matches2)) {
+                    $matches[1] = $matches2[1] . '<em>' . $matches2[2] . '</em>' . $matches2[3];
+                    $isBold = true;
+                }
+
+                if (preg_match('/(.*)_(.*)_(.*)/', $matches[1], $matches3)) {
+                    $matches[1] = $matches3[1] . '<i>' . $matches3[2] . '</i>' . $matches3[3];
+                    $isItalic = true;
+                }
+
+                if ($isItalic || $isBold) {
+                    $line = "<li>" . trim($matches[1]) . "</li>";
+                } else {
+                    $line = "<li><p>" . trim($matches[1]) . "</p></li>";
+                }
+            }
+        } else {
+            if ($isInList) {
+                $line = "</ul>" . $line;
+                $isInList = false;
+            }
+        }
+
+        if (!preg_match('/<h|<ul|<p|<li/', $line)) {
+            $line = "<p>$line</p>";
+        }
+
+        if (preg_match('/(.*)__(.*)__(.*)/', $line, $matches)) {
+            $line = $matches[1] . '<em>' . $matches[2] . '</em>' . $matches[3];
+        }
+
+        if (preg_match('/(.*)_(.*)_(.*)/', $line, $matches)) {
+            $line = $matches[1] . '<i>' . $matches[2] . '</i>' . $matches[3];
+        }
+    }
+
+    $html = join($lines);
+
+    if ($isInList) {
+        $html .= '</ul>';
+    }
+
+    return $html;
+}

data/tracks/php/exercises/markdown/markdown.php

@@ -0,0 +1,82 @@
+<?php
+
+function parseMarkdown($markdown)
+{
+    $lines = explode("\n", $markdown);
+
+    $isInList = false;
+
+    foreach ($lines as &$line) {
+        if (preg_match('/^######(.*)/', $line, $matches)) {
+            $line = "<h6>" . trim($matches[1]) . "</h6>";
+        } elseif (preg_match('/^##(.*)/', $line, $matches)) {
+            $line = "<h2>" . trim($matches[1]) . "</h2>";
+        } elseif (preg_match('/^#(.*)/', $line, $matches)) {
+            $line = "<h1>" . trim($matches[1]) . "</h1>";
+        }
+
+        if (preg_match('/\*(.*)/', $line, $matches)) {
+            if (!$isInList) {
+                $isInList = true;
+                $isBold = false;
+                $isItalic = false;
+                if (preg_match('/(.*)__(.*)__(.*)/', $matches[1], $matches2)) {
+                    $matches[1] = $matches2[1] . '<em>' . $matches2[2] . '</em>' . $matches2[3];
+                    $isBold = true;
+                }
+
+                if (preg_match('/(.*)_(.*)_(.*)/', $matches[1], $matches3)) {
+                    $matches[1] = $matches3[1] . '<i>' . $matches3[2] . '</i>' . $matches3[3];
+                    $isItalic = true;
+                }
+
+                if ($isItalic || $isBold) {
+                    $line = "<ul><li>" . trim($matches[1]) . "</li>";
+                } else {
+                    $line = "<ul><li><p>" . trim($matches[1]) . "</p></li>";
+                }
+
+            } else {
+                $isBold = false;
+                $isItalic = false;
+                if (preg_match('/(.*)__(.*)__(.*)/', $matches[1], $matches2)) {
+                    $matches[1] = $matches2[1] . '<em>' . $matches2[2] . '</em>' . $matches2[3];
+                    $isBold = true;
+                }
+
+                if (preg_match('/(.*)_(.*)_(.*)/', $matches[1], $matches3)) {
+                    $matches[1] = $matches3[1] . '<i>' . $matches3[2] . '</i>' . $matches3[3];
+                    $isItalic = true;
+                }
+
+                if ($isItalic || $isBold) {
+                    $line = "<li>" . trim($matches[1]) . "</li>";
+                } else {
+                    $line = "<li><p>" . trim($matches[1]) . "</p></li>";
+                }
+            }
+        } else {
+            if ($isInList) {
+                $line = "</ul>" . $line;
+                $isInList = false;
+            }
+        }
+
+        if (!preg_match('/<h|<ul|<p|<li/', $line)) {
+            $line = "<p>$line</p>";
+        }
+
+        if (preg_match('/(.*)__(.*)__(.*)/', $line, $matches)) {
+            $line = $matches[1] . '<em>' . $matches[2] . '</em>' . $matches[3];
+        }
+
+        if (preg_match('/(.*)_(.*)_(.*)/', $line, $matches)) {
+            $line = $matches[1] . '<i>' . $matches[2] . '</i>' . $matches[3];
+        }
+    }
+    $html = join($lines);
+    if ($isInList) {
+        $html .= '</ul>';
+    }
+    return $html;
+}

data/tracks/php/exercises/markdown/markdown_test.php

@@ -0,0 +1,57 @@
+<?php
+
+require 'markdown.php';
+
+class MarkdownTest extends \PHPUnit_Framework_TestCase
+{
+    public function testParsingParagraph()
+    {
+        $this->assertEquals('<p>This will be a paragraph</p>', parseMarkdown('This will be a paragraph'));
+    }
+
+    public function testParsingItalics()
+    {
+        $this->assertEquals('<p><i>This will be italic</i></p>', parseMarkdown('_This will be italic_'));
+    }
+
+    public function testParsingBoldText()
+    {
+        $this->assertEquals('<p><em>This will be bold</em></p>', parseMarkdown('__This will be bold__'));
+    }
+
+    public function testMixedNormalItalicsAndBoldText()
+    {
+        $this->assertEquals('<p>This will <i>be</i> <em>mixed</em></p>', parseMarkdown('This will _be_ __mixed__'));
+    }
+
+    public function testWithH1Headerlevel()
+    {
+        $this->assertEquals('<h1>This will be an h1</h1>', parseMarkdown('# This will be an h1'));
+    }
+
+    public function testWithH2Headerlevel()
+    {
+        $this->assertEquals('<h2>This will be an h2</h2>', parseMarkdown('## This will be an h2'));
+    }
+
+    public function testWithH6Headerlevel()
+    {
+        $this->assertEquals('<h6>This will be an h6</h6>', parseMarkdown('###### This will be an h6'));
+    }
+
+    public function testUnorderedLists()
+    {
+        $this->assertEquals(
+            '<ul><li><p>Item 1</p></li><li><p>Item 2</p></li></ul>',
+            parseMarkdown("* Item 1\n* Item 2")
+        );
+    }
+
+    public function testWithALittleBitOfEverything()
+    {
+        $this->assertEquals(
+            '<h1>Header!</h1><ul><li><em>Bold Item</em></li><li><i>Italic Item</i></li></ul>',
+            parseMarkdown("# Header!\n* __Bold Item__\n* _Italic Item_")
+        );
+    }
+}

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

@@ -1,2 +1,5 @@
 def distance(s1, s2):
+    if len(s1) != len(s2):
+        raise ValueError("Sequences not of equal length.")
+
     return sum(a != b for a, b in zip(s1, s2))

data/tracks/python/exercises/hamming/hamming_test.py

@@ -5,26 +5,52 @@ import hamming
 
 class HammingTest(unittest.TestCase):
 
-    def test_no_difference_between_identical_strands(self):
-        self.assertEqual(0, hamming.distance('A', 'A'))
+    def test_identical_strands(self):
+        self.assertEqual(0, hamming.distance("A", "A"))
 
-    def test_complete_hamming_distance_of_for_single_nucleotide_strand(self):
-        self.assertEqual(1, hamming.distance('A', 'G'))
+    def test_long_identical_strands(self):
+        self.assertEqual(0, hamming.distance("GGACTGA", "GGACTGA"))
 
-    def test_complete_hamming_distance_of_for_small_strand(self):
-        self.assertEqual(2, hamming.distance('AG', 'CT'))
+    def test_complete_distance_in_single_nucleotide_strands(self):
+        self.assertEqual(1, hamming.distance("A", "G"))
 
-    def test_small_hamming_distance(self):
-        self.assertEqual(1, hamming.distance('AT', 'CT'))
+    def test_complete_distance_in_small_strands(self):
+        self.assertEqual(2, hamming.distance("AG", "CT"))
 
-    def test_small_hamming_distance_in_longer_strand(self):
-        self.assertEqual(1, hamming.distance('GGACG', 'GGTCG'))
+    def test_small_distance_in_small_strands(self):
+        self.assertEqual(1, hamming.distance("AT", "CT"))
 
-    def test_large_hamming_distance(self):
-        self.assertEqual(4, hamming.distance('GATACA', 'GCATAA'))
+    def test_small_distance(self):
+        self.assertEqual(1, hamming.distance("GGACG", "GGTCG"))
 
-    def test_hamming_distance_in_very_long_strand(self):
-        self.assertEqual(9, hamming.distance('GGACGGATTCTG', 'AGGACGGATTCT'))
+    def test_small_distance_in_long_strands(self):
+        self.assertEqual(2, hamming.distance("ACCAGGG", "ACTATGG"))
+
+    def test_non_unique_character_in_first_strand(self):
+        self.assertEqual(1, hamming.distance("AGA", "AGG"))
+
+    def test_non_unique_character_in_second_strand(self):
+        self.assertEqual(1, hamming.distance("AGG", "AGA"))
+
+    def test_same_nucleotides_in_different_positions(self):
+        self.assertEqual(2, hamming.distance("TAG", "GAT"))
+
+    def test_large_distance(self):
+        self.assertEqual(4, hamming.distance("GATACA", "GCATAA"))
+
+    def test_large_distance_in_off_by_one_strand(self):
+        self.assertEqual(9, hamming.distance("GGACGGATTCTG", "AGGACGGATTCT"))
+
+    def test_empty_strands(self):
+        self.assertEqual(0, hamming.distance("", ""))
+
+    def test_disallow_first_strand_longer(self):
+        with self.assertRaises(ValueError):
+            hamming.distance("AATG", "AAA")
+
+    def test_disallow_second_strand_longer(self):
+        with self.assertRaises(ValueError):
+            hamming.distance("ATA", "AGTG")
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/rna-transcription/example.py

@@ -6,8 +6,13 @@ else:
     maketrans = str.maketrans
 
 
-DNA_TO_RNA = maketrans('AGCT', 'UCGA')
+DNA_CHARS = 'AGCT'
+DNA_TO_RNA = maketrans(DNA_CHARS, 'UCGA')
 
 
 def to_rna(dna_strand):
+    valid_chars = set(DNA_CHARS)
+    if any(char not in valid_chars for char in dna_strand):
+        return ''
+
     return dna_strand.translate(DNA_TO_RNA)

data/tracks/python/exercises/rna-transcription/rna_transcription_test.py

@@ -20,6 +20,15 @@ class DNATests(unittest.TestCase):
     def test_transcribes_all_occurences(self):
         self.assertMultiLineEqual('UGCACCAGAAUU', to_rna('ACGTGGTCTTAA'))
 
+    def test_correctly_handles_single_invalid_input(self):
+        self.assertEqual('', to_rna('U'))
+
+    def test_correctly_handles_completely_invalid_input(self):
+        self.assertMultiLineEqual('', to_rna('XXX'))
+
+    def test_correctly_handles_partially_invalid_input(self):
+        self.assertMultiLineEqual('', to_rna('ACGTXXXCTTAA'))
+
 
 if __name__ == '__main__':
     unittest.main()

data/tracks/ruby/config.json

@@ -502,6 +502,12 @@
       "difficulty": 1,
       "topics": [
       ]
+    },
+    {
+      "slug": "dominoes",
+      "difficulty": 1,
+      "topics": [
+      ]
     }
   ],
   "deprecated": [

data/tracks/ruby/exercises/dominoes/.version

@@ -0,0 +1 @@
+1

data/tracks/ruby/exercises/dominoes/dominoes_test.rb

@@ -0,0 +1,149 @@
+#!/usr/bin/env ruby
+gem 'minitest', '>= 5.0.0'
+require 'minitest/autorun'
+require_relative 'dominoes'
+
+# Test data version: 82eb00d
+class DominoesTest < Minitest::Test
+  def test_empty_input_empty_output
+    # skip
+    input_dominoes = []
+    output_chain = Dominoes.chain(input_dominoes)
+    assert_correct_chain(input_dominoes, output_chain)
+  end
+
+  def test_singleton_input_singleton_output
+    skip
+    input_dominoes = [[1, 1]]
+    output_chain = Dominoes.chain(input_dominoes)
+    assert_correct_chain(input_dominoes, output_chain)
+  end
+
+  def test_singleton_that_can_not_be_chained
+    skip
+    input_dominoes = [[1, 2]]
+    output_chain = Dominoes.chain(input_dominoes)
+    refute_correct_chain(input_dominoes, output_chain)
+  end
+
+  def test_three_elements
+    skip
+    input_dominoes = [[1, 2], [3, 1], [2, 3]]
+    output_chain = Dominoes.chain(input_dominoes)
+    assert_correct_chain(input_dominoes, output_chain)
+  end
+
+  def test_can_reverse_dominoes
+    skip
+    input_dominoes = [[1, 2], [1, 3], [2, 3]]
+    output_chain = Dominoes.chain(input_dominoes)
+    assert_correct_chain(input_dominoes, output_chain)
+  end
+
+  def test_can_not_be_chained
+    skip
+    input_dominoes = [[1, 2], [4, 1], [2, 3]]
+    output_chain = Dominoes.chain(input_dominoes)
+    refute_correct_chain(input_dominoes, output_chain)
+  end
+
+  def test_disconnected_simple
+    skip
+    input_dominoes = [[1, 1], [2, 2]]
+    output_chain = Dominoes.chain(input_dominoes)
+    refute_correct_chain(input_dominoes, output_chain)
+  end
+
+  def test_disconnected_double_loop
+    skip
+    input_dominoes = [[1, 2], [2, 1], [3, 4], [4, 3]]
+    output_chain = Dominoes.chain(input_dominoes)
+    refute_correct_chain(input_dominoes, output_chain)
+  end
+
+  def test_disconnected_single_isolated
+    skip
+    input_dominoes = [[1, 2], [2, 3], [3, 1], [4, 4]]
+    output_chain = Dominoes.chain(input_dominoes)
+    refute_correct_chain(input_dominoes, output_chain)
+  end
+
+  def test_need_backtrack
+    skip
+    input_dominoes = [[1, 2], [2, 3], [3, 1], [2, 4], [2, 4]]
+    output_chain = Dominoes.chain(input_dominoes)
+    assert_correct_chain(input_dominoes, output_chain)
+  end
+
+  def test_separate_loops
+    skip
+    input_dominoes = [[1, 2], [2, 3], [3, 1], [1, 1], [2, 2], [3, 3]]
+    output_chain = Dominoes.chain(input_dominoes)
+    assert_correct_chain(input_dominoes, output_chain)
+  end
+
+  def test_ten_elements
+    skip
+    input_dominoes = [[1, 2], [5, 3], [3, 1], [1, 2], [2, 4], [1, 6], [2, 3], [3, 4], [5, 6]]
+    output_chain = Dominoes.chain(input_dominoes)
+    assert_correct_chain(input_dominoes, output_chain)
+  end
+
+  # Problems in exercism evolve over time, as we find better ways to ask
+  # questions.
+  # The version number refers to the version of the problem you solved,
+  # not your solution.
+  #
+  # Define a constant named VERSION inside of the top level BookKeeping
+  # module, which may be placed near the end of your file.
+  #
+  # In your file, it will look like this:
+  #
+  # module BookKeeping
+  #   VERSION = 1 # Where the version number matches the one in the test.
+  # end
+  #
+  # If you are curious, read more about constants on RubyDoc:
+  # http://ruby-doc.org/docs/ruby-doc-bundle/UsersGuide/rg/constants.html
+  def test_bookkeeping
+    skip
+    assert_equal 1, BookKeeping::VERSION
+  end
+
+  # It's infeasible to use example-based tests for this exercise,
+  # because the list of acceptable answers for a given input can be quite large.
+  # Instead, we verify certain properties of a correct chain.
+
+  def assert_correct_chain(input_dominoes, output_chain)
+    refute_nil output_chain, "There should be a chain for #{input_dominoes}"
+    assert_same_dominoes(input_dominoes, output_chain)
+    return if output_chain.empty?
+    assert_consecutive_dominoes_match(output_chain)
+    assert_dominoes_at_end_match(output_chain)
+  end
+
+  def assert_same_dominoes(input_dominoes, output_chain)
+    input_normal = input_dominoes.map(&:sort).sort
+    output_normal = output_chain.map(&:sort).sort
+    assert_equal input_normal, output_normal,
+      'Dominoes used in the output must be the same as the ones given in the input'
+  end
+
+  def assert_consecutive_dominoes_match(chain)
+    chain.each_cons(2).with_index { |(d1, d2), i|
+      assert_equal d1.last, d2.first,
+        "In chain #{chain}, right end of domino #{i} (#{d1}) and left end of domino #{i + 1} (#{d2}) must match"
+    }
+  end
+
+  def assert_dominoes_at_end_match(chain)
+    first_domino = chain.first
+    last_domino = chain.last
+    assert_equal first_domino.first, last_domino.last,
+      "In chain #{chain}, left end of first domino (#{first_domino}) and right end of last domino (#{last_domino}) must match"
+  end
+
+  def refute_correct_chain(input_dominoes, output_chain)
+    assert_nil output_chain, "There should be no chain for #{input_dominoes}"
+  end
+end

data/tracks/ruby/exercises/dominoes/example.rb

@@ -0,0 +1,37 @@
+module Dominoes
+  def self.chain(dominoes)
+    return dominoes if dominoes.empty?
+
+    first = dominoes.first
+
+    subchain = try_subchain(dominoes.drop(1), *first)
+    subchain && [first] + subchain
+  end
+
+  def self.try_subchain(dominoes, chain_left, chain_right)
+    return chain_left == chain_right ? [] : nil if dominoes.empty?
+
+    dominoes.each_with_index { |domino, i|
+      other_dominoes = dominoes.take(i) + dominoes.drop(i + 1)
+      # Try adding the domino either flipped or unflipped.
+      [domino, domino.reverse].each { |candidate|
+        domino_left, domino_right = candidate
+        if domino_left == chain_right
+          if (subchain = try_subchain(other_dominoes, chain_left, domino_right))
+            return [candidate] + subchain
+          end
+        end
+      }
+    }
+
+    # Found no suitable chain.
+    # Note that for "no chain" we have to use nil instead of [].
+    # This is because [] is the valid answer for `Dominoes.chain([])`.
+    # If we used [] for "no chain", then the meaning of [] is ambiguous.
+    nil
+  end
+end
+
+module BookKeeping
+  VERSION = 1
+end

data/tracks/ruby/exercises/dominoes/example.tt

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+gem 'minitest', '>= 5.0.0'
+require 'minitest/autorun'
+require_relative 'dominoes'
+
+# Test data version: <%= sha1 %>
+class DominoesTest < Minitest::Test
+<% test_cases.each do |test_case| %>
+  def <%= test_case.test_name %>
+    <%= test_case.skipped %>
+    <%= test_case.workload %>
+  end
+
+<% end %>
+<%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>
+  def test_bookkeeping
+    skip
+    assert_equal <%= version.next %>, BookKeeping::VERSION
+  end
+
+  # It's infeasible to use example-based tests for this exercise,
+  # because the list of acceptable answers for a given input can be quite large.
+  # Instead, we verify certain properties of a correct chain.
+
+  def assert_correct_chain(input_dominoes, output_chain)
+    refute_nil output_chain, "There should be a chain for #{input_dominoes}"
+    assert_same_dominoes(input_dominoes, output_chain)
+    return if output_chain.empty?
+    assert_consecutive_dominoes_match(output_chain)
+    assert_dominoes_at_end_match(output_chain)
+  end
+
+  def assert_same_dominoes(input_dominoes, output_chain)
+    input_normal = input_dominoes.map(&:sort).sort
+    output_normal = output_chain.map(&:sort).sort
+    assert_equal input_normal, output_normal,
+      'Dominoes used in the output must be the same as the ones given in the input'
+  end
+
+  def assert_consecutive_dominoes_match(chain)
+    chain.each_cons(2).with_index { |(d1, d2), i|
+      assert_equal d1.last, d2.first,
+        "In chain #{chain}, right end of domino #{i} (#{d1}) and left end of domino #{i + 1} (#{d2}) must match"
+    }
+  end
+
+  def assert_dominoes_at_end_match(chain)
+    first_domino = chain.first
+    last_domino = chain.last
+    assert_equal first_domino.first, last_domino.last,
+      "In chain #{chain}, left end of first domino (#{first_domino}) and right end of last domino (#{last_domino}) must match"
+  end
+
+  def refute_correct_chain(input_dominoes, output_chain)
+    assert_nil output_chain, "There should be no chain for #{input_dominoes}"
+  end
+end

data/tracks/ruby/exercises/pangram/.version

@@ -1 +1 @@
-2
+3

data/tracks/ruby/exercises/pangram/example.rb

@@ -1,9 +1,9 @@
 module BookKeeping
-  VERSION = 2
+  VERSION = 3
 end
 
 class Pangram
-  def self.is_pangram?(str)
+  def self.pangram?(str)
     downcased_str = str.downcase
     ('a'..'z').all? { |letter| downcased_str.include?(letter) }
   end

data/tracks/ruby/exercises/pangram/example.tt

@@ -4,16 +4,14 @@ gem 'minitest', '>= 5.0.0'
 require 'minitest/autorun'
 require_relative 'pangram'
 
-# Test data version:
-# <%= sha1 %>
+# Test data version: # <%= sha1 %>
 class PangramTest < Minitest::Test<% test_cases.each do |test_case| %>
-  def <%= test_case.name %><% if test_case.skipped? %>
-    skip<% end %>
-    str = '<%= test_case.input %>'<% if test_case.expected %>
-    assert<% else %>
-    refute<% end %> <%= test_case.do %>
+  def <%= test_case.name %>
+    <%= test_case.skipped? %>
+    <%= test_case.workload %>
   end
 <% end %>
+
 <%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>
   def test_bookkeeping
     skip