trackler 2.0.0.1 → 2.0.0.2

data/tracks/pony/exercises/difference-of-squares/test.pony

@@ -10,22 +10,22 @@ actor Main is TestList
   fun tag tests(test: PonyTest) =>
     test(_TestSquares)
 
-class _TestSquares iso is UnitTest
+class iso _TestSquares is UnitTest
   """
   Test Difference of Squares package
   """
 
   fun name(): String => "difference-of-squares/Squares"
 
-  fun apply(h: TestHelper): TestResult =>
-    h.expect_eq[U32](225, Squares(5).square_of_sums())
-    h.expect_eq[U32](55, Squares(5).sum_of_squares())
-    h.expect_eq[U32](170, Squares(5).difference())
+  fun apply(h: TestHelper) =>
+    h.assert_eq[U32](225, Squares(5).square_of_sums())
+    h.assert_eq[U32](55, Squares(5).sum_of_squares())
+    h.assert_eq[U32](170, Squares(5).difference())
 
-    h.expect_eq[U32](3025, Squares(10).square_of_sums())
-    h.expect_eq[U32](385, Squares(10).sum_of_squares())
-    h.expect_eq[U32](2640, Squares(10).difference())
+    h.assert_eq[U32](3025, Squares(10).square_of_sums())
+    h.assert_eq[U32](385, Squares(10).sum_of_squares())
+    h.assert_eq[U32](2640, Squares(10).difference())
 
-    h.expect_eq[U32](25502500, Squares(100).square_of_sums())
-    h.expect_eq[U32](338350, Squares(100).sum_of_squares())
-    h.expect_eq[U32](25164150, Squares(100).difference())
+    h.assert_eq[U32](25502500, Squares(100).square_of_sums())
+    h.assert_eq[U32](338350, Squares(100).sum_of_squares())
+    h.assert_eq[U32](25164150, Squares(100).difference())

data/tracks/pony/exercises/hamming/example.pony

@@ -12,11 +12,11 @@ class Hamming
     compute_distance(strand1, strand2)
 
   fun compute_distance(strand1: String, strand2: String): U8 ? =>
-    let size: U64 = strand1.size()
+    let size: USize = strand1.size()
     var dist: U8 = U8(0)
-    var idx: I64 = 0
+    var idx: ISize = 0
 
-    while idx < size.i64() do
+    while idx < size.isize() do
       if (strand1.at_offset(idx).ne(strand2.at_offset(idx))) then
         dist = dist + 1
       end

data/tracks/pony/exercises/hamming/test.pony

@@ -11,30 +11,30 @@ actor Main is TestList
     test(_HammingDistanceTest)
     test(_HammingParamTest)
 
-class _HammingDistanceTest iso is UnitTest
+class iso _HammingDistanceTest is UnitTest
   """
   Test Hamming package returns the right distance
   """
   fun name(): String => "hamming/Hamming"
 
-  fun apply(h: TestHelper): TestResult ? =>
-    h.expect_eq[U8](0, Hamming("A", "A"))
-    h.expect_eq[U8](0, Hamming("GGACTGA", "GGACTGA"))
-    h.expect_eq[U8](1, Hamming("A", "G"))
-    h.expect_eq[U8](2, Hamming("AG", "CT"))
-    h.expect_eq[U8](1, Hamming("AT", "CT"))
-    h.expect_eq[U8](1, Hamming("GGACG", "GGTCG"))
-    h.expect_eq[U8](2, Hamming("ACCAGGG", "ACTATGG"))
-    h.expect_eq[U8](1, Hamming("AGG", "AGA"))
-    h.expect_eq[U8](4, Hamming("GATACA", "GCATAA"))
-    h.expect_eq[U8](9, Hamming("GGACGGATTCTG", "AGGACGGATTCT"))
+  fun apply(h: TestHelper): None ? =>
+    h.assert_eq[U8](0, Hamming("A", "A"))
+    h.assert_eq[U8](0, Hamming("GGACTGA", "GGACTGA"))
+    h.assert_eq[U8](1, Hamming("A", "G"))
+    h.assert_eq[U8](2, Hamming("AG", "CT"))
+    h.assert_eq[U8](1, Hamming("AT", "CT"))
+    h.assert_eq[U8](1, Hamming("GGACG", "GGTCG"))
+    h.assert_eq[U8](2, Hamming("ACCAGGG", "ACTATGG"))
+    h.assert_eq[U8](1, Hamming("AGG", "AGA"))
+    h.assert_eq[U8](4, Hamming("GATACA", "GCATAA"))
+    h.assert_eq[U8](9, Hamming("GGACGGATTCTG", "AGGACGGATTCT"))
 
- class _HammingParamTest iso is UnitTest
+ class iso _HammingParamTest is UnitTest
   """
   Test Hamming package returns the right distance
   """
   fun name(): String => "hamming/Hamming"
 
-  fun apply(h: TestHelper): TestResult =>
-    h.expect_error(lambda()? => Hamming("GAT", "GA") end)
-    h.expect_error(lambda()? => Hamming("GA", "GAC") end)
+  fun apply(h: TestHelper) =>
+    h.assert_error(lambda()? => Hamming("GAT", "GA") end)
+    h.assert_error(lambda()? => Hamming("GA", "GAC") end)

data/tracks/pony/exercises/hello-world/test.pony

@@ -10,14 +10,15 @@ actor Main is TestList
   fun tag tests(test: PonyTest) =>
     test(_TestHelloWorld)
 
-class _TestHelloWorld iso is UnitTest
+class iso _TestHelloWorld is UnitTest
   """
   Test HelloWorld package
   """
   fun name(): String => "hello-world/HelloWorld"
 
-  fun apply(h: TestHelper): TestResult =>
+  fun apply(h: TestHelper) =>
     let hello: HelloWorld = HelloWorld.create()
 
-    h.expect_eq[String]("Hello, World!", hello.say_hello())
-    h.expect_eq[String]("Hello, Exercism!", hello.say_hello("Exercism"))
+    h.assert_eq[String]("Hello, World!", hello.say_hello())
+    h.assert_eq[String]("Hello, Exercism!", hello.say_hello("Exercism"))
+

data/tracks/pony/exercises/leap/test.pony

@@ -10,18 +10,18 @@ actor Main is TestList
   fun tag tests(test: PonyTest) =>
     test(_LeapTest)
 
-class _LeapTest iso is UnitTest
+class iso _LeapTest is UnitTest
   """
   Test Leap package
   """
   fun name(): String => "leap/Leap"
 
-  fun apply(h: TestHelper): TestResult =>
-    // Note -> Current master-branch simplifies these functions to 
+  fun apply(h: TestHelper) =>
+    // Note -> Current master-branch simplifies these functions to
     // assert_true/false, and removes expect
     // https://github.com/ponylang/ponyc/blob/master/packages/ponytest/helper.pony
-    h.expect_true(Leap(1996), "Testing a leap year")
-    h.expect_false(Leap(1997), "Testing an odd year")
-    h.expect_false(Leap(1998), "Testing a non-leap even year")
-    h.expect_false(Leap(1900), "Testing a century")
-    h.expect_true(Leap(2000), "Testing an exceptional century")
+    h.assert_true(Leap(1996), "Testing a leap year")
+    h.assert_false(Leap(1997), "Testing an odd year")
+    h.assert_false(Leap(1998), "Testing a non-leap even year")
+    h.assert_false(Leap(1900), "Testing a century")
+    h.assert_true(Leap(2000), "Testing an exceptional century")

data/tracks/python/config.json

@@ -411,6 +411,24 @@
       "difficulty": 1,
       "topics": [
       ]
+    },
+    {
+      "slug": "list-ops",
+      "difficulty": 1,
+      "topics": [
+      ]
+    },
+    {
+      "slug": "linked-list",
+      "difficulty": 1,
+      "topics": [
+      ]
+    },
+    {
+      "slug": "diamond",
+      "difficulty": 1,
+      "topics": [
+      ]
     }
   ],
   "deprecated": [

data/tracks/python/exercises/diamond/diamond_test.py

@@ -0,0 +1,33 @@
+import unittest
+
+from diamond import make_diamond
+
+
+class DiamondTests(unittest.TestCase):
+
+    def test_letter_A(self):
+        self.assertMultiLineEqual('A\n', make_diamond('A'))
+
+    def test_letter_C(self):
+        result = ['  A  ',
+                  ' B B ',
+                  'C   C',
+                  ' B B ',
+                  '  A  ']
+        self.assertMultiLineEqual('\n'.join(result) + '\n', make_diamond('C'))
+
+    def test_letter_E(self):
+        result = ['    A    ',
+                  '   B B   ',
+                  '  C   C  ',
+                  ' D     D ',
+                  'E       E',
+                  ' D     D ',
+                  '  C   C  ',
+                  '   B B   ',
+                  '    A    ']
+        self.assertMultiLineEqual('\n'.join(result) + '\n', make_diamond('E'))
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,15 @@
+def make_diamond(letter):
+    rows = ord(letter) - 64
+    cols = rows * 2 - 1
+    half = make_half(rows, cols)
+    return ''.join(half + half[-2::-1])
+
+
+def make_half(rows, cols):
+    diamond_half = []
+    for x in range(rows):
+        row = [' '] * cols
+        row[rows - 1 - x] = chr(x + 65)
+        row[rows - 1 + x] = chr(x + 65)
+        diamond_half.append(''.join(row) + '\n')
+    return diamond_half

data/tracks/python/exercises/linked-list/example.py

@@ -0,0 +1,47 @@
+class Node(object):
+    def __init__(self, value, next=None, prev=None):
+        self.value = value
+        self.next = next
+        self.prev = prev
+
+
+class LinkedList(object):
+    def __init__(self):
+        self.head = None
+        self.tail = None
+
+    def push(self, value):
+        new_node = Node(value)
+        if not self.head:
+            self.head = self.tail = new_node
+        else:
+            new_node.prev = self.tail
+            self.tail.next = new_node
+            self.tail = new_node
+
+    def pop(self):
+        node = self.tail
+        if node is None or node.prev is None:
+            self.head = self.tail = None
+        else:
+            self.tail = self.tail.prev
+            self.tail.next = None
+        return node.value
+
+    def shift(self):
+        node = self.head
+        if node is None or node.next is None:
+            self.head = self.tail = None
+        else:
+            self.head = self.head.next
+            self.head.prev = None
+        return node.value
+
+    def unshift(self, value):
+        new_node = Node(value)
+        if not self.head:
+            self.head = self.tail = new_node
+        else:
+            new_node.next = self.head
+            self.head.prev = new_node
+            self.head = new_node

data/tracks/python/exercises/linked-list/linked_list.py

@@ -0,0 +1,13 @@
+# Skeleton file for the Python "linked-list" exercise.
+
+
+class Node(object):
+    def __init__(self, value, next=None, prev=None):
+        self.value = value
+        self.next = next
+        self.prev = prev
+
+
+class LinkedList(object):
+    def __init__(self):
+        pass  # Complete the Deque class ...

data/tracks/python/exercises/linked-list/linked_list_test.py

@@ -0,0 +1,49 @@
+import unittest
+
+from linked_list import LinkedList
+
+
+class LinkedListTests(unittest.TestCase):
+
+    def setUp(self):
+        self.list = LinkedList()
+
+    def test_push_pop(self):
+        self.list.push(10)
+        self.list.push(20)
+        self.assertEqual(20, self.list.pop())
+        self.assertEqual(10, self.list.pop())
+
+    def test_push_shift(self):
+        self.list.push(10)
+        self.list.push(20)
+        self.assertEqual(10, self.list.shift())
+        self.assertEqual(20, self.list.shift())
+
+    def test_unshift_shift(self):
+        self.list.unshift(10)
+        self.list.unshift(20)
+        self.assertEqual(20, self.list.shift())
+        self.assertEqual(10, self.list.shift())
+
+    def test_unshift_pop(self):
+        self.list.unshift(10)
+        self.list.unshift(20)
+        self.assertEqual(10, self.list.pop())
+        self.assertEqual(20, self.list.pop())
+
+    def test_all(self):
+        self.list.push(10)
+        self.list.push(20)
+        self.assertEqual(20, self.list.pop())
+        self.list.push(30)
+        self.assertEqual(10, self.list.shift())
+        self.list.unshift(40)
+        self.list.push(50)
+        self.assertEqual(40, self.list.shift())
+        self.assertEqual(50, self.list.pop())
+        self.assertEqual(30, self.list.shift())
+
+
+if __name__ == '__main__':
+    unittest.main()

data/tracks/python/exercises/list-ops/example.py

@@ -0,0 +1,55 @@
+def map_clone(function, xs):
+    return (function(elem) for elem in xs)
+
+
+def length(xs):
+    return sum(1 for x in xs)
+
+
+def filter_clone(function, xs):
+    return (x for x in xs if function(x))
+
+
+def reverse(xs):
+    if not xs:
+        return []
+    else:
+        return xs[::-1]
+
+
+def append(xs, y):
+    xs[len(xs):] = [y]
+    return xs
+
+
+def foldl(function, xs, acc):
+    if(len(xs) == 0):
+        return acc
+    else:
+        return foldl(function, xs[1:], function(acc, xs[0]))
+
+
+def foldr(function, xs, acc):
+    if(len(xs) == 0):
+        return acc
+    else:
+        return function(xs[0], foldr(function, xs[1:], acc))
+
+
+def flat(xs):
+    out = []
+    for item in xs:
+        if isinstance(item, (list, tuple)):
+            out.extend(flat(item))
+        else:
+            out.append(item)
+    return out
+
+
+def concat(xs, ys):
+    if not ys:
+        return xs
+    else:
+        for item in ys:
+            xs.append(item)
+        return xs

data/tracks/python/exercises/list-ops/list_ops.py

@@ -0,0 +1,38 @@
+# Please, do not use the built-in python functions like map, reduce, len, etc.
+# that solve the same problems and try to solve it yourself instead.
+
+
+def map_clone(function, xs):
+    return xs
+
+
+def length(xs):
+    return xs
+
+
+def filter_clone(function, xs):
+    return xs
+
+
+def reverse(xs):
+    return xs
+
+
+def append(xs, y):
+    return xs
+
+
+def foldl(function, xs, acc):
+    return xs
+
+
+def foldr(function, xs, acc):
+    return xs
+
+
+def flat(xs):
+    return xs
+
+
+def concat(xs, ys):
+    return xs

data/tracks/python/exercises/list-ops/list_ops_test.py

@@ -0,0 +1,136 @@
+import unittest
+import operator
+
+import list_ops
+
+
+class ListOpsTest(unittest.TestCase):
+
+    # tests for map
+    def test_map_square(self):
+        self.assertEqual(
+            (1, 4, 9, 16, 25, 36, 49, 64, 81, 100),
+            tuple(list_ops.map_clone(
+                lambda x: x**2, (1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
+            )
+        )
+
+    def test_map_cube(self):
+        self.assertEqual(
+            (-1, 8, -27, 64, -125, 216, -343, 512, -729, 1000),
+            tuple(list_ops.map_clone(
+                lambda x: x**3, (-1, 2, -3, 4, -5, 6, -7, 8, -9, 10))
+            )
+        )
+
+    def test_map_absolute(self):
+        self.assertEqual(
+            (1, 2, 3, 4, 5, 6, 7, 8, 9, 10),
+            tuple(list_ops.map_clone(
+                lambda x: abs(x), (-1, 2, -3, 4, -5, 6, -7, 8, -9, 10))
+            )
+        )
+
+    def test_map_empty(self):
+        self.assertEqual([], list(list_ops.map_clone(operator.index, [])))
+
+    # tests for length
+    def test_pos_leng(self):
+        self.assertEqual(10, list_ops.length((-1, 2, -3, 4, -5, 6, -7, 8, -9, 10)))
+
+    def test_empty_len(self):
+        self.assertEqual(0, list_ops.length([]))
+
+    # tests for filter
+    def test_filter_odd(self):
+        self.assertEqual(
+            (1, 3, 5),
+            tuple(list_ops.filter_clone(lambda x: x % 2 != 0, [1, 2, 3, 4, 5, 6]))
+        )
+
+    def test_filter_even(self):
+        self.assertEqual(
+            (2, 4, 6),
+            tuple(list_ops.filter_clone(lambda x: x % 2 == 0, [1, 2, 3, 4, 5, 6]))
+        )
+
+    # tests for reverse
+    def test_reverse_small(self):
+        self.assertEqual([1, 2, 3], list_ops.reverse([3, 2, 1]))
+
+    def test_reverse_mixed_types(self):
+        self.assertEqual(
+            (1, "cat", 4.0, "xyz"),
+            list_ops.reverse(("xyz", 4.0, "cat", 1))
+        )
+
+    def test_reverse_empty(self):
+        self.assertEqual([], list_ops.reverse(()))
+
+    # tests for append
+    def test_append_tuple(self):
+        self.assertEqual(
+            ["10", "python", "hello"],
+            list_ops.append(["10", "python"], "hello")
+        )
+
+    def test_append_range(self):
+        self.assertEqual([100, range(1000)], list_ops.append([100], range(1000)))
+
+    def test_append_to_empty(self):
+        self.assertEqual([42], list_ops.append([], 42))
+
+    # tests for foldl
+    def test_foldl_sum(self):
+        self.assertEqual(21, list_ops.foldl(operator.add, [1, 2, 3, 4, 5, 6], 0))
+
+    def test_foldl_product(self):
+        self.assertEqual(720, list_ops.foldl(operator.mul, [1, 2, 3, 4, 5, 6], 1))
+
+    def test_foldl_div(self):
+        self.assertEqual(0, list_ops.foldl(operator.floordiv, [1, 2, 3, 4, 5, 6], 1))
+
+    def test_foldl_sub(self):
+        self.assertEqual(-15, list_ops.foldl(operator.sub, [1, 2, 3, 4, 5], 0))
+
+    # tests for foldr
+    def test_foldr_sub(self):
+        self.assertEqual(3, list_ops.foldr(operator.sub, [1, 2, 3, 4, 5], 0))
+
+    def test_foldr_add_str(self):
+        self.assertEqual(
+            "exercism!",
+            list_ops.foldr(operator.add, ["e", "x", "e", "r", "c", "i", "s", "m"], "!"))
+
+    # tests for flatten
+    def test_flatten_nested(self):
+        self.assertEqual([1, 2, 3, 4], list_ops.flat([[[1, 2], [3]], [[4]]]))
+
+    def test_flatten_once(self):
+        self.assertEqual(["x", "y", "z"], list_ops.flat([["x", "y", "z"]]))
+
+    def test_flatten_empty(self):
+        self.assertEqual([], list_ops.flat([]))
+
+    # tests for concat
+    def test_concat_two(self):
+        self.assertEqual(
+            [1, 3, 5, 8, 9, 4, 5, 6],
+            list_ops.concat([1, 3, 5, 8], [9, 4, 5, 6])
+        )
+
+    def test_concat_nothing(self):
+        self.assertEqual(
+            ["orange", "apple", "banana"],
+            list_ops.concat(['orange', 'apple', 'banana'], None)
+        )
+
+    def test_concat_empty(self):
+        self.assertEqual(
+            [],
+            list_ops.concat([], [])
+        )
+
+
+if __name__ == '__main__':
+    unittest.main()

data/tracks/ruby/bin/generate

@@ -1,10 +1,29 @@
 #!/usr/bin/env ruby
 
+require_relative '../lib/helper'
+require 'generator'
+
+def available_generators
+  cases = File.join( __dir__, '../lib/*_cases.rb')
+  Dir[cases].map {|filename| /([^\/]*)_cases\.rb$/.match(filename).captures}
+end
+
+def usage
+  "Usage: #{$PROGRAM_NAME} exercise_generator\n\n" +
+  "Available exercise generators:\n" +
+  available_generators.sort.join(' ')
+end
+
 exercise = ARGV[0]
+
+unless exercise
+  STDERR.puts "Exercise name required!\n"
+  puts usage
+  exit
+end
+
 cases = "#{exercise.tr('-','_')}_cases"
 
-require_relative '../lib/helper'
-require 'generator'
 begin
   require "#{cases}"
 rescue LoadError
@@ -14,3 +33,4 @@ end
 
 klass = Object.const_get(cases.split('_').map(&:capitalize).join)
 Generator.new(exercise, klass).generate
+