trackler 2.2.1.20 → 2.2.1.21

data/tracks/rust/exercises/accumulate/README.md

@@ -25,9 +25,6 @@ Keep your hands off that collect/map/fmap/whatchamacallit functionality
 provided by your standard library!
 Solve this one yourself using other basic tools instead.
 
-Lisp specific: it's perfectly fine to use `MAPCAR` or the equivalent,
-as this is idiomatic Lisp, not a library function.
-
 ## Hints
 
 We are dealing with two types of situations.  One is a function pointer and

data/tracks/rust/exercises/beer-song/src/lib.rs

@@ -0,0 +1,7 @@
+pub fn verse(n: i32) -> String {
+
+}
+
+pub fn sing(start: i32, end: i32) -> String {
+
+}

data/tracks/rust/exercises/bob/src/lib.rs

@@ -0,0 +1,3 @@
+pub fn reply(message: &str) -> &str {
+
+}

data/tracks/rust/exercises/bowling/example.rs

@@ -104,7 +104,7 @@ impl BowlingGame {
                 return Err("Game Finished. No more rolls.");
             }
 
-            for mut frame in self.frames.iter_mut() {
+            for frame in self.frames.iter_mut() {
                 frame.add_roll(pins)
             }
 

data/tracks/rust/exercises/difference-of-squares/src/lib.rs

@@ -0,0 +1,11 @@
+pub fn square_of_sum(n: usize) -> usize {
+
+}
+
+pub fn sum_of_squares(n: usize) -> usize {
+
+}
+
+pub fn difference(n: usize) -> usize {
+
+}

data/tracks/rust/exercises/grade-school/example.rs

@@ -10,7 +10,7 @@ impl School {
     }
 
     pub fn add(&mut self, grade: u32, student: &str) {
-        let mut entry = self.grades.entry(grade).or_insert(Vec::new());
+        let entry = self.grades.entry(grade).or_insert(Vec::new());
         entry.push(student.to_string());
         entry.sort();
     }

data/tracks/rust/exercises/leap/src/lib.rs

@@ -0,0 +1,3 @@
+pub fn is_leap_year(year: i32) -> bool {
+
+}

data/tracks/rust/exercises/proverb/src/lib.rs

@@ -0,0 +1,3 @@
+pub fn build_proverb(list: Vec<&str>) -> String {
+
+}

data/tracks/rust/exercises/raindrops/src/lib.rs

@@ -0,0 +1,3 @@
+pub fn raindrops(n: usize) -> String {
+
+}

data/tracks/rust/exercises/sum-of-multiples/src/lib.rs

@@ -0,0 +1,3 @@
+pub fn sum_of_multiples(limit: u32, factors: &[u32]) -> u32 {
+
+}

data/tracks/scala/exercises/space-age/example.scala

@@ -1,24 +1,30 @@
-case class SpaceAge(val seconds: Long) {
-  lazy val onEarth: Double = round(earthYears)
-  lazy val onMercury: Double = round(mercuryYears)
-  lazy val onVenus: Double = round(venusYears)
-  lazy val onMars: Double = round(marsYears)
-  lazy val onJupiter: Double = round(jupiterYears)
-  lazy val onSaturn: Double = round(saturnYears)
-  lazy val onUranus: Double = round(uranusYears)
-  lazy val onNeptune: Double = round(neptuneYears)
+object SpaceAge {
+  private val daysToEarthAge = 365.25
+  private val daysToMercuryAge = 87.969
+  private val daysToVenusAge = 224.701
+  private val daysToMarsAge = 686.971
+  private val daysToJupiterAge = 4332.59
+  private val daysToSaturnAge = 10759.22
+  private val daysToUranusAge = 30799.095
+  private val daysToNeptuneAge = 60190.03
 
-  private val minutes = seconds.toDouble / 60
-  private val hours = minutes / 60
-  private val days = hours / 24
-  private val earthYears = days / 365.25
-  private val mercuryYears = days / 87.969
-  private val venusYears = days / 224.701
-  private val marsYears = days / 686.971
-  private val jupiterYears = days / 4332.59
-  private val saturnYears = days / 10759.22
-  private val uranusYears = days / 30799.095
-  private val neptuneYears = days / 60190.03
+  private def toEarthDays(seconds: Double): Double = {
+    val minutes = seconds.toDouble / 60
+    val hours = minutes / 60
+    hours / 24
+  }
+
+  private def toPlanetAge(daysToPlanetAge: Double, seconds: Double): Double =
+    round(toEarthDays(seconds) / daysToPlanetAge)
 
   private def round(value: Double): Double = (value * 100).round / 100.0
+
+  def onEarth(seconds: Double): Double = toPlanetAge(daysToEarthAge, seconds)
+  def onMercury(seconds: Double): Double = toPlanetAge(daysToMercuryAge, seconds)
+  def onVenus(seconds: Double): Double = toPlanetAge(daysToVenusAge, seconds)
+  def onMars(seconds: Double): Double = toPlanetAge(daysToMarsAge, seconds)
+  def onJupiter(seconds: Double): Double = toPlanetAge(daysToJupiterAge, seconds)
+  def onSaturn(seconds: Double): Double = toPlanetAge(daysToSaturnAge, seconds)
+  def onUranus(seconds: Double): Double = toPlanetAge(daysToUranusAge, seconds)
+  def onNeptune(seconds: Double): Double = toPlanetAge(daysToNeptuneAge, seconds)
 }

data/tracks/scala/exercises/space-age/src/test/scala/SpaceAgeTest.scala

@@ -1,63 +1,44 @@
-import org.scalatest._
+import org.scalatest.{Matchers, FunSuite}
 
+/** @version 1.0.0 */
 class SpaceAgeTest extends FunSuite with Matchers {
-  test ("age in seconds") {
-    val age = SpaceAge(1000000)
-    age.seconds should be (1000000)
-  }
 
-  test ("age in earth years") {
-    pending
-    val age = SpaceAge(1000000000)
-    age.onEarth should be (31.69)
+  test("age on Earth") {
+    SpaceAge.onEarth(1000000000) should be (31.69)
   }
 
-  test ("age in mercury years") {
+  test("age on Mercury") {
     pending
-    val age = SpaceAge(2134835688)
-    age.onEarth should be (67.65)
-    age.onMercury should be (280.88)
+    SpaceAge.onMercury(2134835688) should be (280.88)
   }
 
-  test ("age in venus years") {
+  test("age on Venus") {
     pending
-    val age = SpaceAge(189839836)
-    age.onEarth should be (6.02)
-    age.onVenus should be (9.78)
+    SpaceAge.onVenus(189839836) should be (9.78)
   }
 
-  test ("age on mars") {
+  test("age on Mars") {
     pending
-    val age = SpaceAge(2329871239L)
-    age.onEarth should be (73.83)
-    age.onMars should be (39.25)
+    SpaceAge.onMars(2.329871239E9) should be (39.25)
   }
 
-  test ("age on jupiter") {
+  test("age on Jupiter") {
     pending
-    val age = SpaceAge(901876382)
-    age.onEarth should be (28.58)
-    age.onJupiter should be (2.41)
+    SpaceAge.onJupiter(901876382) should be (2.41)
   }
 
-  test ("age on saturn") {
+  test("age on Saturn") {
     pending
-    val age = SpaceAge(3000000000L)
-    age.onEarth should be (95.06)
-    age.onSaturn should be (3.23)
+    SpaceAge.onSaturn(3.0E9) should be (3.23)
   }
 
-  test ("age on uranus") {
+  test("age on Uranus") {
     pending
-    val age = SpaceAge(3210123456L)
-    age.onEarth should be (101.72)
-    age.onUranus should be (1.21)
+    SpaceAge.onUranus(3.210123456E9) should be (1.21)
   }
 
-  test ("age on neptune") {
+  test("age on Neptune") {
     pending
-    val age = SpaceAge(8210123456L)
-    age.onEarth should be (260.16)
-    age.onNeptune should be (1.58)
+    SpaceAge.onNeptune(8.210123456E9) should be (1.58)
   }
-}
+}

data/tracks/scala/exercises/sublist/src/test/scala/SublistTest.scala

@@ -1,97 +1,89 @@
-import org.scalatest.{FunSuite, Matchers}
+import org.scalatest.{Matchers, FunSuite}
 
+/** @version 1.0.0 */
 class SublistTest extends FunSuite with Matchers {
+
   test("empty lists") {
     Sublist.sublist(List(), List()) should be (Sublist.Equal)
   }
 
-  test("empty is a sublist of anything") {
+  test("empty list within non empty list") {
     pending
-    Sublist.sublist(List(), List('a', 's', 'd', 'f')) should be (Sublist.Sublist)
+    Sublist.sublist(List(), List(1, 2, 3)) should be (Sublist.Sublist)
   }
 
-  test("anything is a superlist of empty") {
+  test("non empty list contains empty list") {
     pending
-    Sublist.sublist(List('a', 's', 'd', 'f'), List()) should be (Sublist.Superlist)
+    Sublist.sublist(List(1, 2, 3), List()) should be (Sublist.Superlist)
   }
 
-  test("List(1) is not List(2)") {
+  test("list equals itself") {
     pending
-    Sublist.sublist(List(1), List(2)) should be (Sublist.Unequal)
+    Sublist.sublist(List(1, 2, 3), List(1, 2, 3)) should be (Sublist.Equal)
   }
 
-  test("compare larger equal lists") {
-    pending
-    val xs = List.fill(1000)("x")
-    Sublist.sublist(xs, xs) should be (Sublist.Equal)
-  }
-
-  test("sublist at start") {
+  test("different lists") {
     pending
-    Sublist.sublist(List(1, 2, 3), List(1, 2, 3, 4, 5)) should be (Sublist.Sublist)
+    Sublist.sublist(List(1, 2, 3), List(2, 3, 4)) should be (Sublist.Unequal)
   }
 
-  test("sublist in middle") {
+  test("false start") {
     pending
-    Sublist.sublist(List(4, 3, 2), List(5, 4, 3, 2, 1)) should be (Sublist.Sublist)
+    Sublist.sublist(List(1, 2, 5), List(0, 1, 2, 3, 1, 2, 5, 6)) should be (Sublist.Sublist)
   }
 
-  test("sublist at end") {
+  test("consecutive") {
     pending
-    Sublist.sublist(List(3, 4, 5), List(1, 2, 3, 4, 5)) should be (Sublist.Sublist)
+    Sublist.sublist(List(1, 1, 2), List(0, 1, 1, 1, 2, 1, 2)) should be (Sublist.Sublist)
   }
 
-  test("partially matching sublist at start") {
+  test("sublist at start") {
     pending
-    Sublist.sublist(List(1, 1, 2), List(1, 1, 1, 2)) should be (Sublist.Sublist)
+    Sublist.sublist(List(0, 1, 2), List(0, 1, 2, 3, 4, 5)) should be (Sublist.Sublist)
   }
 
-  test("sublist early in huge list") {
+  test("sublist in middle") {
     pending
-    val xs = List.range(1, 1000000)
-    Sublist.sublist(List(3, 4, 5), xs) should be (Sublist.Sublist)
+    Sublist.sublist(List(2, 3, 4), List(0, 1, 2, 3, 4, 5)) should be (Sublist.Sublist)
   }
 
-  test("huge sublist not in huge list") {
+  test("sublist at end") {
     pending
-    val l1 = List.range(10, 1000001)
-    val l2 = List.range(1, 1000000)
-    Sublist.sublist(l1, l2) should be (Sublist.Unequal)
+    Sublist.sublist(List(3, 4, 5), List(0, 1, 2, 3, 4, 5)) should be (Sublist.Sublist)
   }
 
-  test("superlist at start") {
+  test("at start of superlist") {
     pending
-    Sublist.sublist(List(1, 2, 3, 4, 5), List(1, 2, 3)) should be (Sublist.Superlist)
+    Sublist.sublist(List(0, 1, 2, 3, 4, 5), List(0, 1, 2)) should be (Sublist.Superlist)
   }
 
-  test("superlist in middle") {
+  test("in middle of superlist") {
     pending
-    Sublist.sublist(List(5, 4, 3, 2, 1), List(4, 3, 2)) should be (Sublist.Superlist)
+    Sublist.sublist(List(0, 1, 2, 3, 4, 5), List(2, 3)) should be (Sublist.Superlist)
   }
 
-  test("superlist at end") {
+  test("at end of superlist") {
     pending
-    Sublist.sublist(List(1, 2, 3, 4, 5), List(3, 4, 5)) should be (Sublist.Superlist)
+    Sublist.sublist(List(0, 1, 2, 3, 4, 5), List(3, 4, 5)) should be (Sublist.Superlist)
   }
 
-  test("partially matching superlist at start") {
+  test("first list missing element from second list") {
     pending
-    Sublist.sublist(List(1, 1, 1, 2), List(1, 1, 2)) should be (Sublist.Superlist)
+    Sublist.sublist(List(1, 3), List(1, 2, 3)) should be (Sublist.Unequal)
   }
 
-  test("superlist early in huge list") {
+  test("second list missing element from first list") {
     pending
-    val l1 = List.range(1, 1000000)
-    Sublist.sublist(l1, List(3, 4, 5)) should be (Sublist.Superlist)
+    Sublist.sublist(List(1, 2, 3), List(1, 3)) should be (Sublist.Unequal)
   }
 
-  test("recurring values sublist") {
+  test("order matters to a list") {
     pending
-    Sublist.sublist(List(1, 2, 1, 2, 3), List(1, 2, 3, 1, 2, 1, 2, 3, 2, 1)) should be (Sublist.Sublist)
+    Sublist.sublist(List(1, 2, 3), List(3, 2, 1)) should be (Sublist.Unequal)
   }
 
-  test("recurring values unequal") {
+  test("same digits but different numbers") {
     pending
-    Sublist.sublist(List(1, 2, 1, 2, 3), List(1, 2, 3, 1, 2, 3, 2, 3, 2, 1)) should be (Sublist.Unequal)
+    Sublist.sublist(List(1, 0, 1), List(10, 1)) should be (Sublist.Unequal)
   }
-}
+}

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

@@ -0,0 +1,39 @@
+import java.io.File
+
+import testgen.TestSuiteBuilder._
+import testgen._
+
+object SpaceAgeTestGenerator {
+  def main(args: Array[String]): Unit = {
+    val file = new File("src/main/resources/space-age.json")
+
+    def toString(expected: CanonicalDataParser.Expected): String = {
+      expected match {
+        case Left(_) => throw new IllegalStateException()
+        case Right(n)  => s"$n"
+      }
+    }
+
+    def sutArgs(parseResult: CanonicalDataParser.ParseResult, argNames: String*): String =
+      argNames map (name => TestSuiteBuilder.toString(parseResult(name))) mkString ", "
+
+    def functionName(parseResult: CanonicalDataParser.ParseResult): String =
+      "on" + parseResult("planet").toString
+
+    def fromLabeledTest(argNames: String*): ToTestCaseData =
+      withLabeledTest { sut =>
+        labeledTest =>
+          val args = sutArgs(labeledTest.result, argNames: _*)
+          val property = labeledTest.property
+          val sutCall =
+            s"""$sut.${functionName(labeledTest.result)}($args)"""
+          val expected = toString(labeledTest.expected)
+          TestCaseData(labeledTest.description, sutCall, expected)
+      }
+
+    val code = TestSuiteBuilder.build(file, fromLabeledTest("seconds"))
+    println(s"-------------")
+    println(code)
+    println(s"-------------")
+  }
+}

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

@@ -0,0 +1,38 @@
+import java.io.File
+
+import testgen.TestSuiteBuilder._
+import testgen._
+
+object SublistTestGenerator {
+  def main(args: Array[String]): Unit = {
+    val file = new File("src/main/resources/sublist.json")
+
+    def toString(expected: CanonicalDataParser.Expected): String = {
+      expected match {
+        case Right("equal") => s"Sublist.Equal"
+        case Right("sublist") => s"Sublist.Sublist"
+        case Right("superlist") => s"Sublist.Superlist"
+        case Right("unequal") => s"Sublist.Unequal"
+        case _ => throw new IllegalStateException()
+      }
+    }
+
+    def fromLabeledTest(argNames: String*): ToTestCaseData =
+      withLabeledTest { sut =>
+        labeledTest =>
+          val args = sutArgs(labeledTest.result, argNames: _*)
+          val property = labeledTest.property
+          val sutCall =
+            s"$sut.$property($args)"
+          val expected = toString(labeledTest.expected)
+          TestCaseData(labeledTest.description, sutCall, expected)
+      }
+
+    val code =
+      TestSuiteBuilder.build(file, fromLabeledTest("listOne", "listTwo"))
+
+    println(s"-------------")
+    println(code)
+    println(s"-------------")
+  }
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.2.1.20
+  version: 2.2.1.21
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-29 00:00:00.000000000 Z
+date: 2017-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -1871,6 +1871,10 @@ files:
 - tracks/csharp/exercises/collatz-conjecture/CollatzConjectureTest.cs
 - tracks/csharp/exercises/collatz-conjecture/Example.cs
 - tracks/csharp/exercises/collatz-conjecture/README.md
+- tracks/csharp/exercises/complex-numbers/ComplexNumbers.cs
+- tracks/csharp/exercises/complex-numbers/ComplexNumbers.csproj
+- tracks/csharp/exercises/complex-numbers/ComplexNumbersTest.cs
+- tracks/csharp/exercises/complex-numbers/Example.cs
 - tracks/csharp/exercises/connect/Connect.cs
 - tracks/csharp/exercises/connect/Connect.csproj
 - tracks/csharp/exercises/connect/ConnectTest.cs
@@ -2359,10 +2363,12 @@ files:
 - tracks/csharp/generators/Exercises/BookStore.cs
 - tracks/csharp/generators/Exercises/BracketPush.cs
 - tracks/csharp/generators/Exercises/CollatzConjecture.cs
+- tracks/csharp/generators/Exercises/ComplexNumbers.cs
 - tracks/csharp/generators/Exercises/ConvertExtensions.cs
 - tracks/csharp/generators/Exercises/CryptoSquare.cs
 - tracks/csharp/generators/Exercises/FoodChain.cs
 - tracks/csharp/generators/Exercises/Gigasecond.cs
+- tracks/csharp/generators/Exercises/Grains.cs
 - tracks/csharp/generators/Exercises/Hamming.cs
 - tracks/csharp/generators/Exercises/HelloWorld.cs
 - tracks/csharp/generators/Exercises/House.cs
@@ -11126,7 +11132,7 @@ files:
 - tracks/scala/exercises/space-age/README.md
 - tracks/scala/exercises/space-age/build.sbt
 - tracks/scala/exercises/space-age/example.scala
-- tracks/scala/exercises/space-age/src/main/scala/SpaceAge.scala
+- tracks/scala/exercises/space-age/src/main/scala/.keep
 - tracks/scala/exercises/space-age/src/test/scala/SpaceAgeTest.scala
 - tracks/scala/exercises/spiral-matrix/README.md
 - tracks/scala/exercises/spiral-matrix/build.sbt
@@ -11236,7 +11242,9 @@ files:
 - 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/SpaceAgeTestGenerator.scala
 - tracks/scala/testgen/src/main/scala/SpiralMatrixTestGenerator.scala
+- tracks/scala/testgen/src/main/scala/SublistTestGenerator.scala
 - tracks/scala/testgen/src/main/scala/SumOfMultiplesTestGenerator.scala
 - tracks/scala/testgen/src/main/scala/TestBuilder.scala
 - tracks/scala/testgen/src/main/scala/TriangleTestGenerator.scala