trackler 2.2.1.2 → 2.2.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3460c4854b0b5a786a64101a2f58df547f5823f5
-  data.tar.gz: adf79c90fe9ab7f504196911f62c4590b8354881
+  metadata.gz: f2d3bdebe9f23b4e4bd76015bdf93718291556cd
+  data.tar.gz: 663c332d00958e9c5e98dbbf5a39b8b1860bea20
 SHA512:
-  metadata.gz: ab8eb54d3b072d1f3821f9e4ea3694499498bea1b8680639c0c3c01a1e2d4dfa24849f1aea7f695a22a5caf871c369cb9126e30fed1d50842ae95e840e850a81
-  data.tar.gz: 2717972c9833a923d7899e8a32f7573d9b6b311a355e14d15a6d55e4b34d4af3b65d78bfb51860cddabdd7d3f602674e5646bfd6312b8c4b3f9def3d0d38aa31
+  metadata.gz: 98a6ee04e6e779216a3d1edb522674cde1a6d6b537cbff42a48fd4ec09ea78fe155dbdb346dbea5f9e39caaa35300648ac851d0c193e940593c967f4ca2ec247
+  data.tar.gz: f19ff52e7647ce38e231d8145703fe95d51ca3c664bc82e562d1b54342cad092e3fe51eb81b50b2e5ea1c45c78f95de7f10c8feab32fe2e2047943fafe3aeb08

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.2"
+  VERSION = "2.2.1.3"
 end

data/tracks/go/config.json

@@ -377,9 +377,13 @@
       "slug": "sieve",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 1,
+      "difficulty": 3,
       "topics": [
-
+        "Algorithms",
+        "Integers",
+        "Mathematics",
+        "Sorting",
+        "Control-flow (loops)"
       ]
     },
     {
@@ -387,9 +391,10 @@
       "slug": "palindrome-products",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 1,
+      "difficulty": 6,
       "topics": [
-
+        "Mathematics",
+        "Algorithms"
       ]
     },
     {
@@ -397,9 +402,11 @@
       "slug": "protein-translation",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 1,
+      "difficulty": 3,
       "topics": [
-
+        "Filtering",
+        "Maps",
+        "Sequences"
       ]
     },
     {
@@ -407,9 +414,12 @@
       "slug": "perfect-numbers",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 1,
+      "difficulty": 4,
       "topics": [
-
+        "Integers",
+        "Algorithms",
+        "Mathematics",
+        "Filtering"
       ]
     },
     {
@@ -417,9 +427,10 @@
       "slug": "bracket-push",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 1,
+      "difficulty": 7,
       "topics": [
-
+        "Parsing",
+        "Strings"
       ]
     },
     {
@@ -427,9 +438,11 @@
       "slug": "anagram",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 1,
+      "difficulty": 3,
       "topics": [
-
+        "Strings",
+        "Parsing",
+        "Filtering"
       ]
     },
     {
@@ -437,9 +450,10 @@
       "slug": "word-count",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 1,
+      "difficulty": 3,
       "topics": [
-
+        "Strings",
+        "Sorting"
       ]
     },
     {
@@ -447,9 +461,10 @@
       "slug": "allergies",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 1,
+      "difficulty": 4,
       "topics": [
-
+        "Enumeration",
+        "Bitwise operations"
       ]
     },
     {
@@ -457,9 +472,10 @@
       "slug": "rna-transcription",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 1,
+      "difficulty": 2,
       "topics": [
-
+          "Maps",
+          "Transforming"
       ]
     },
     {
@@ -467,9 +483,10 @@
       "slug": "roman-numerals",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 1,
+      "difficulty": 2,
       "topics": [
-
+        "Numbers",
+        "Transforming"
       ]
     },
     {
@@ -477,9 +494,12 @@
       "slug": "say",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 1,
+      "difficulty": 7,
       "topics": [
-
+        "Numbers",
+        "Strings",
+        "Transforming",
+        "Text Formatting"
       ]
     },
     {
@@ -487,9 +507,10 @@
       "slug": "circular-buffer",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 1,
+      "difficulty": 5,
       "topics": [
-
+        "Queues",
+        "Structs"
       ]
     },
     {

data/tracks/haskell/config/maintainers.json

@@ -3,12 +3,7 @@
     {
       "github_username": "etrepum",
       "show_on_website": false,
-      "alumnus": true,
-      "name": null,
-      "bio": null,
-      "link_text": null,
-      "link_url": null,
-      "avatar_url": null
+      "alumnus": true
     },
     {
       "github_username": "petertseng",
@@ -23,19 +18,14 @@
     {
       "github_username": "abo64",
       "show_on_website": false,
-      "alumnus": false,
-      "name": null,
-      "bio": null,
-      "link_text": null,
-      "link_url": null,
-      "avatar_url": null
+      "alumnus": true
     },
     {
       "github_username": "rbasso",
-      "show_on_website": false,
+      "show_on_website": true,
       "alumnus": false,
       "name": null,
-      "bio": null,
+      "bio": "In a world plagued by mutability, where side-effects scorch the land, a hobbyist programmer joins a fellowship of coders to save The Source.",
       "link_text": null,
       "link_url": null,
       "avatar_url": null

data/tracks/python/config.json

@@ -789,6 +789,18 @@
         "pattern matching"
       ]
     },
+    {
+      "uuid": "889df88a-767d-490f-92c4-552d8ec9de34",
+      "slug": "change",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 4,
+      "topics": [
+        "Control-flow (loops)",
+        "Arrays",
+        "Algorithms"
+      ]
+    },
     {
       "uuid": "e7351e8e-d3ff-4621-b818-cd55cf05bffd",
       "slug": "accumulate",

data/tracks/python/exercises/change/change.py

@@ -0,0 +1,2 @@
+def find_minimum_coins(total_change, coins):
+    pass

data/tracks/python/exercises/change/change_test.py

@@ -0,0 +1,43 @@
+import unittest
+
+from change import find_minimum_coins
+
+
+class ChangeTest(unittest.TestCase):
+    def test_single_coin_change(self):
+        self.assertEqual(find_minimum_coins(25, [1, 5, 10, 25, 100]), [25])
+
+    def test_multiple_coin_change(self):
+        self.assertEqual(find_minimum_coins(15, [1, 5, 10, 25, 100]), [5, 10])
+
+    def test_change_with_Lilliputian_Coins(self):
+        self.assertEqual(find_minimum_coins(23, [1, 4, 15, 20, 50]),
+                         [4, 4, 15])
+
+    def test_change_with_Lower_Elbonia_Coins(self):
+        self.assertEqual(find_minimum_coins(63, [1, 5, 10, 21, 25]),
+                         [21, 21, 21])
+
+    def test_large_target_values(self):
+        self.assertEqual(find_minimum_coins(21, [2, 5, 10, 20, 50]),
+                         [2, 2, 2, 5, 10])
+
+    def test_possible_change_without_unit_coins_available(self):
+        self.assertEqual(find_minimum_coins(21, [2, 5, 10, 20, 50]),
+                         [2, 2, 2, 5, 10])
+
+    def test_no_coins_make_0_change(self):
+        self.assertEqual(find_minimum_coins(0, [1, 5, 10, 21, 25]), [])
+
+    def test_error_testing_for_change_smaller_than_smallest_coin(self):
+        self.assertEqual(find_minimum_coins(3, [5, 10]), -1)
+
+    def test_error_if_no_combination_can_add_up_to_target(self):
+        self.assertEqual(find_minimum_coins(94, [5, 10]), -1)
+
+    def test_cannot_find_negative_change_values(self):
+        self.assertEqual(find_minimum_coins(-5, [1, 2, 5]), -1)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,25 @@
+def find_minimum_coins(total_change, coins):
+    if total_change < 0:
+        return -1
+    min_coins_required = [1e9] * (total_change + 1)
+    last_coin = [0]*(total_change + 1)
+    min_coins_required[0] = 0
+    last_coin[0] = -1
+    for change in range(1, total_change + 1):
+        final_result = min_coins_required[change]
+        for coin in coins:
+            if coin <= change:
+                result = min_coins_required[change - coin] + 1
+                if result < final_result:
+                    final_result = result
+                    last_coin[change] = change - coin
+        min_coins_required[change] = final_result
+    if min_coins_required[total_change] == 1e9:
+        return -1
+    else:
+        last_coin_value = total_change
+        array = []
+        while(last_coin[last_coin_value] != -1):
+            array.append(last_coin_value-last_coin[last_coin_value])
+            last_coin_value = last_coin[last_coin_value]
+        return array

data/tracks/scala/config.json

@@ -1,7 +1,5 @@
 {
-  "slug": "scala",
   "language": "Scala",
-  "repository": "https://github.com/exercism/scala",
   "active": true,
   "exercises": [
     {

data/tracks/scala/exercises/largest-series-product/example.scala

@@ -1,14 +1,21 @@
 object Series {
-  private def digits(s: String): List[Int] = s.map(c => c.asDigit).toList
+  private def digits(s: String): List[Int] = s.filter(_.isDigit).map(_.asDigit).toList
 
-  private def slices(n: Int, s: String): List[List[Int]] = {
-    assert(n >= 0, "slice length must be non-negative")
-    digits(s).tails.filter(xs => xs.length >= n).map(xs => xs.take(n)).toList
-  }
+  private def slices(n: Int, digits: List[Int]): List[List[Int]] =
+    digits.tails.filter(xs => xs.length >= n).map(_.take(n)).toList
 
   def largestProduct(n: Int, s: String): Option[Int] =
-    slices(n, s) match {
-      case Nil => None
-      case xs => Some(xs.map(slice => slice.foldLeft(1)(_ * _)).max)
+    if (n < 0)
+      None
+    else {
+      val ds = digits(s)
+      if (ds.length < s.length)
+        None
+      else {
+        slices(n, ds) match {
+          case Nil => None
+          case xs => Some(xs.map(_.product).max)
+        }
+      }
     }
 }

data/tracks/scala/exercises/largest-series-product/src/test/scala/SeriesTest.scala

@@ -1,30 +1,79 @@
-import org.scalatest.{Matchers, FlatSpec}
+import org.scalatest.{Matchers, FunSuite}
 
-class SeriesTest extends FlatSpec with Matchers {
-  it should "find largestProduct" in {
-    Series.largestProduct(2, "0123456789") should equal(Some(72))
-    Series.largestProduct(2, "19") should equal(Some(9))
-    Series.largestProduct(2, "576802143") should equal(Some(48))
-    Series.largestProduct(3, "0123456789") should equal(Some(504))
-    Series.largestProduct(3, "1027839564") should equal(Some(270))
+/** @version 1.0.0 */
+class LargestSeriesProductTest extends FunSuite with Matchers {
+
+  test("finds the largest product if span equals length") {
+    Series.largestProduct(2, "29") should be (Some(18))
+  }
+
+  test("can find the largest product of 2 with numbers in order") {
+    pending
+    Series.largestProduct(2, "0123456789") should be (Some(72))
+  }
+
+  test("can find the largest product of 2") {
+    pending
+    Series.largestProduct(2, "576802143") should be (Some(48))
+  }
+
+  test("can find the largest product of 3 with numbers in order") {
+    pending
+    Series.largestProduct(3, "0123456789") should be (Some(504))
+  }
+
+  test("can find the largest product of 3") {
+    pending
+    Series.largestProduct(3, "1027839564") should be (Some(270))
+  }
+
+  test("can find the largest product of 5 with numbers in order") {
+    pending
+    Series.largestProduct(5, "0123456789") should be (Some(15120))
+  }
+
+  test("can get the largest product of a big number") {
+    pending
+    Series.largestProduct(6, "73167176531330624919225119674426574742355349194934") should be (Some(23520))
+  }
+
+  test("reports zero if the only digits are zero") {
+    pending
+    Series.largestProduct(2, "0000") should be (Some(0))
+  }
+
+  test("reports zero if all spans include zero") {
+    pending
+    Series.largestProduct(3, "99099") should be (Some(0))
+  }
+
+  test("rejects span longer than string length") {
+    pending
+    Series.largestProduct(4, "123") should be (None)
   }
 
-  it should "find largestProduct in long strings" in {
+  test("reports 1 for empty string and empty product (0 span)") {
     pending
-    Series.largestProduct(6,
-      "73167176531330624919225119674426574742355349194934") should equal(Some(23520))
-    Series.largestProduct(6,
-      "52677741234314237566414902593461595376319419139427") should equal(Some(28350))
+    Series.largestProduct(0, "") should be (Some(1))
   }
 
-  it should "find largestProduct boundary conditions" in {
+  test("reports 1 for nonempty string and empty product (0 span)") {
     pending
-    Series.largestProduct(0, "") should equal(Some(1))
-    Series.largestProduct(0, "123") should equal(Some(1))
-    Series.largestProduct(1, "") should equal(None)
-    Series.largestProduct(4, "123") should equal(None)
-    Series.largestProduct(2, "00") should equal(Some(0))
-    Series.largestProduct(3, "99099") should equal(Some(0))
+    Series.largestProduct(0, "123") should be (Some(1))
   }
-}
 
+  test("rejects empty string and nonzero span") {
+    pending
+    Series.largestProduct(1, "") should be (None)
+  }
+
+  test("rejects invalid character in digits") {
+    pending
+    Series.largestProduct(2, "1234a5") should be (None)
+  }
+
+  test("rejects negative span") {
+    pending
+    Series.largestProduct(-1, "12345") should be (None)
+  }
+}

data/tracks/scala/exercises/prime-factors/example.scala

@@ -2,7 +2,7 @@ import scala.annotation.tailrec
 
 // Algorithm from - http://fldit-www.cs.uni-dortmund.de/~peter/PS07/HR.pdf
 object PrimeFactors {
-  def forNumber(n: Long): List[Long] = {
+  def factors(n: Long): List[Long] = {
     assert(n >= 1, "Argument must be positive")
 
     @tailrec

data/tracks/scala/exercises/prime-factors/src/test/scala/PrimefactorsTest.scala

@@ -1,58 +1,39 @@
-import org.scalatest.{FlatSpec, Matchers}
+import org.scalatest.{Matchers, FunSuite}
 
-class PrimeFactorsTest extends FlatSpec with Matchers {
-  it should "calc empty list" in {
-    PrimeFactors.forNumber(1) should be (List())
-  }
-
-  it should "calc prime factors of 2" in {
-    pending
-    PrimeFactors.forNumber(2) should be (List(2))
-  }
-
-  it should "calc prime factors of 3" in {
-    pending
-    PrimeFactors.forNumber(3) should be (List(3))
-  }
-
-  it should "calc prime factors of 4" in {
-    pending
-    PrimeFactors.forNumber(4) should be (List(2, 2))
-  }
+/** @version 1.0.0 */
+class PrimeFactorsTest extends FunSuite with Matchers {
 
-  it should "calc prime factors of 6" in {
-    pending
-    PrimeFactors.forNumber(6) should be (List(2, 3))
+  test("no factors") {
+    PrimeFactors.factors(1) should be (List())
   }
 
-  it should "calc prime factors of 8" in {
+  test("prime number") {
     pending
-    PrimeFactors.forNumber(8) should be (List(2, 2, 2))
+    PrimeFactors.factors(2) should be (List(2))
   }
 
-  it should "calc prime factors of 9" in {
+  test("square of a prime") {
     pending
-    PrimeFactors.forNumber(9) should be (List(3, 3))
+    PrimeFactors.factors(9) should be (List(3, 3))
   }
 
-  it should "calc prime factors of 27" in {
+  test("cube of a prime") {
     pending
-    PrimeFactors.forNumber(27) should be (List(3, 3, 3))
+    PrimeFactors.factors(8) should be (List(2, 2, 2))
   }
 
-  it should "calc prime factors of 625" in {
+  test("product of primes and non-primes") {
     pending
-    PrimeFactors.forNumber(625) should be (List(5, 5, 5, 5))
+    PrimeFactors.factors(12) should be (List(2, 2, 3))
   }
 
-  it should "calc prime factors of 901255" in {
+  test("product of primes") {
     pending
-    PrimeFactors.forNumber(901255) should be (List(5, 17, 23, 461))
+    PrimeFactors.factors(901255) should be (List(5, 17, 23, 461))
   }
 
-  it should "calc prime factors of 93819012551" in {
+  test("factors include a large prime") {
     pending
-    PrimeFactors.forNumber(Long.MaxValue) should be (List(7, 7, 73, 127, 337, 92737, 649657))
+    PrimeFactors.factors(93819012551l) should be (List(11, 9539, 894119))
   }
-}
-
+}

data/tracks/scala/testgen/src/main/scala/PrimeFactorsTestGenerator.scala

@@ -0,0 +1,55 @@
+import java.io.File
+
+import testgen.TestSuiteBuilder.{toString, _}
+import testgen.{CanonicalDataParser, TestCaseData, TestSuiteBuilder}
+
+object PrimeFactorsTestGenerator {
+  def main(args: Array[String]): Unit = {
+    val file = new File("src/main/resources/prime-factors.json")
+
+    val code = TestSuiteBuilder.build(file, fromLabeledTest("input"))
+    println(s"-------------")
+    println(code)
+    println(s"-------------")
+  }
+
+  private def fromLabeledTest(argNames: String*): ToTestCaseData =
+    withLabeledTest { sut =>
+      labeledTest =>
+        val sutFunction = labeledTest.property
+        val args = sutArgs(labeledTest.result, argNames: _*)
+        val sutCall = s"$sut.$sutFunction($args)"
+        val expected = toString(labeledTest.expected)
+
+        TestCaseData(labeledTest.description, sutCall, expected)
+    }
+
+  def sutArgs(parseResult: CanonicalDataParser.ParseResult, argNames: String*): String =
+    argNames map (name => toString(parseResult(name))) mkString ", "
+
+  def toString(expected: CanonicalDataParser.Expected): String = {
+    expected match {
+      case Left(error) => throw new IllegalStateException("Unexpected Left")
+      case Right(exp) => s"${toString(exp)}"
+    }
+  }
+
+  private def toString(any: Any): String = {
+    def quote(str: String): String =
+      if ("\"\n" exists (str.contains(_:Char))) "\"\"\"" else "\""
+
+    System.out.println(any.getClass)
+
+    any match {
+      case list: List[_] =>
+        val vals = list.map(s => toString(s)).mkString(", ")
+        s"List($vals)"
+      case str: String =>
+        val quot = quote(str)
+        s"$quot$str$quot"
+      case dbl: Double =>
+        dbl.asInstanceOf[Long].toString + "l"
+      case _ => any.toString
+    }
+  }
+}

data/tracks/scala/testgen/src/main/scala/SeriesTestGenerator.scala

@@ -0,0 +1,44 @@
+import java.io.File
+
+import testgen.TestSuiteBuilder._
+import testgen._
+
+object SeriesTestGenerator {
+  def main(args: Array[String]): Unit = {
+    val file = new File("src/main/resources/largest-series-product.json")
+
+    def toExpected(any: Any): String = {
+      any match {
+        case -1 => "None"
+        case i: Int => s"Some($i)"
+        case s: String =>
+          val quot = quote(s)
+          s"$quot$s$quot"
+        case _ => throw new IllegalStateException("Invalid expected val -" + any)
+      }
+    }
+
+    def toString(expected: CanonicalDataParser.Expected): String = {
+        expected match {
+          case Left(error) => s"None"
+          case Right(exp) => toExpected(exp)
+        }
+    }
+
+    def fromLabeledTest(argNames: String*): ToTestCaseData =
+      withLabeledTest { sut =>
+        labeledTest =>
+          val args = sutArgs(labeledTest.result, argNames: _*)
+          val property = labeledTest.property
+          val sutCall =
+            s"""Series.$property($args)"""
+          val expected = toString(labeledTest.expected)
+          TestCaseData(labeledTest.description, sutCall, expected)
+      }
+
+    val code = TestSuiteBuilder.build(file, fromLabeledTest("span", "digits"))
+    println(s"-------------")
+    println(code)
+    println(s"-------------")
+  }
+}

data/tracks/scala/testgen/src/main/scala/testgen/TestSuiteBuilder.scala

@@ -70,7 +70,7 @@ object TestSuiteBuilder {
   }
 
   def sutName(exerciseName: String) =
-    (exerciseName split ("-") map (_.capitalize) mkString)
+    exerciseName split "-" map (_.capitalize) mkString
   def testSuiteName(exerciseName: String): String =
     sutName(exerciseName) + "Test"
 
@@ -86,10 +86,10 @@ object TestSuiteBuilder {
   private def toString(expected: CanonicalDataParser.Expected): String =
       expected.fold(error => s"Left(${toString(error)})", toString)
 
-  def toString(any: Any): String = {
-    def quote(str: String): String =
-      if ("\"\n" exists (str.contains(_:Char))) "\"\"\"" else "\""
+  def quote(str: String): String =
+    if ("\"\n" exists (str.contains(_:Char))) "\"\"\"" else "\""
 
+  def toString(any: Any): String = {
     any match {
       case list: List[_] =>
         val vals = list.map(s => toString(s)).mkString(", ")
@@ -97,6 +97,8 @@ object TestSuiteBuilder {
       case str: String =>
         val quot = quote(str)
         s"$quot$str$quot"
+      case lstr: Long =>
+        lstr.toString + "l"
       case _ => any.toString
     }
   }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.2.1.2
+  version: 2.2.1.3
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-25 00:00:00.000000000 Z
+date: 2017-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -8753,6 +8753,9 @@ files:
 - tracks/python/exercises/bracket-push/bracket_push.py
 - tracks/python/exercises/bracket-push/bracket_push_test.py
 - tracks/python/exercises/bracket-push/example.py
+- tracks/python/exercises/change/change.py
+- tracks/python/exercises/change/change_test.py
+- tracks/python/exercises/change/example.py
 - tracks/python/exercises/circular-buffer/README.md
 - tracks/python/exercises/circular-buffer/circular_buffer.py
 - tracks/python/exercises/circular-buffer/circular_buffer_test.py
@@ -10620,11 +10623,13 @@ files:
 - tracks/scala/testgen/src/main/scala/PangramsTestGenerator.scala
 - tracks/scala/testgen/src/main/scala/PerfectNumbersTestGenerator.scala
 - tracks/scala/testgen/src/main/scala/PhoneNumberTestGenerator.scala
+- tracks/scala/testgen/src/main/scala/PrimeFactorsTestGenerator.scala
 - tracks/scala/testgen/src/main/scala/RailFenceCipherTestGenerator.scala
 - tracks/scala/testgen/src/main/scala/RaindropsTestGenerator.scala
 - tracks/scala/testgen/src/main/scala/RnaTranscriptionTestGenerator.scala
 - tracks/scala/testgen/src/main/scala/ScrabbleScoreTestGenerator.scala
 - tracks/scala/testgen/src/main/scala/SecretHandshakeTestGenerator.scala
+- tracks/scala/testgen/src/main/scala/SeriesTestGenerator.scala
 - tracks/scala/testgen/src/main/scala/SieveTestGenerator.scala
 - tracks/scala/testgen/src/main/scala/SpiralMatrixTestGenerator.scala
 - tracks/scala/testgen/src/main/scala/SumOfMultiplesTestGenerator.scala