Merge 5ed1a48 into d46455c

Author: bearmug

.travis.yml

@@ -1,4 +1,5 @@
 language: java
+sudo: true
 
 jdk:
   - oraclejdk8
@@ -10,10 +11,10 @@ cache:
 
 env:
   global:
-    - GRADLE_OPTS="-Xms128m"
+    - GRADLE_OPTS="-Xms256m"
 
 install: echo "skip 'gradle assemble' step"
-script: gradle build --continue
+script: ./gradlew checkScoverage --continue --info
 
 after_success:
-  - gradle checkScoverage coveralls
+  - ./gradlew coveralls

gradle/wrapper/gradle-wrapper.properties

@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.12-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-3.4.1-bin.zip

src/main/scala/org/bearmug/algo/course02/week03/Median.scala

@@ -0,0 +1,40 @@
+package org.bearmug.algo.course02.week03
+
+import scala.collection.immutable.{SortedSet, TreeSet}
+
+/**
+  * Created by pavel on 3/12/17.
+  */
+class Median private(lHeap: SortedSet[Int], rHeap: SortedSet[Int]) {
+
+  type H = SortedSet[Int]
+
+  def +(e: Int): Median = {
+
+    def balance(l: H, r: H): (H, H) = (l.size, r.size) match {
+      case (lS, rS) if lS < rS => (l + r.head, r.tail)
+      case (lS, rS) if lS > rS + 1 => (l.tail, r + l.head)
+      case (_, _) => (l, r)
+    }
+
+    // use currying for explicit branching
+    def add(e: Int)(f: (H, H) => (H, H)): (H, H) =
+      (lHeap.headOption, rHeap.headOption) match {
+      case (None, _) => f(lHeap + e, rHeap)
+      case (Some(lHead), _) if e <= lHead => f(lHeap + e, rHeap)
+      case (_, _) => f(lHeap, rHeap + e)
+    }
+
+    Median(add(e)(balance))
+  }
+
+  def calc: Int = lHeap.headOption match {
+    case Some(m) => m
+    case _ => Int.MaxValue
+  }
+}
+
+object Median {
+  def apply(): Median = new Median(TreeSet.empty(Ordering.Int.reverse), TreeSet.empty(Ordering.Int))
+  private def apply(lr: (SortedSet[Int], SortedSet[Int])) = new Median(lr._1, lr._2)
+}

src/test/scala/org/bearmug/algo/course02/week03/MedianSuite.scala

@@ -0,0 +1,55 @@
+package org.bearmug.algo.course02.week03
+
+import org.junit.runner.RunWith
+import org.scalatest.FunSuite
+import org.scalatest.junit.JUnitRunner
+
+import scala.io.Source
+import scala.util.Random
+
+@RunWith(classOf[JUnitRunner])
+class MedianSuite extends FunSuite {
+
+  test("calc works for empty data") {
+    assert(Median().calc == Int.MaxValue)
+  }
+
+  test("calc works for single element") {
+    assert((Median() + 1).calc == 1)
+  }
+
+  test("calc works for two elements") {
+    assert((Median() + 1 + 3).calc == 1)
+    assert((Median() + 5 + 3).calc == 3)
+  }
+
+  test("calc works for two same elements") {
+    assert((Median() + 1 + 1).calc == 1)
+    assert((Median() + 4 + 1 + 3 + 3).calc == 3)
+  }
+
+  test("calc works for three elements") {
+    assert((Median() + 1 + 3 + 2).calc == 2)
+    assert((Median() + 3 + 2 + 1).calc == 2)
+    assert((Median() + 2 + 3 + 1).calc == 2)
+  }
+
+  test("calc works for four elements") {
+    assert((Median() + 1 + 3 + 2 + 4).calc == 2)
+    assert((Median() + 5 + 3 + 4 + 2).calc == 3)
+  }
+
+  test("calc works for five elements") {
+    assert((Median() + 1 + 3 + 2 + 4 + 5).calc == 3)
+    assert((Median() + 5 + 3 + 4 + 2 + 1).calc == 3)
+  }
+
+  test("calc works for even elements") {
+    for (i <- 2 to 1000){
+      val data: Vector[Int] = Seq.fill(i)(Random.nextInt(100000)).toSet.toVector
+      assert(data.sorted.apply((data.length - 1)/2) == data.foldLeft(Median())((m, i) => m + i).calc,
+        s", \nlength: $i," +
+          s"\ninput: $data")
+    }
+  }
+}