collect bfs, binary-search, max-depth, permutations, qsort, and two sum code

Author: chlin501

bfs/b.scala

@@ -0,0 +1,35 @@
+import scala.collection.immutable.Queue
+
+/**
+ * https://stackoverflow.com/questions/41347337/how-to-implement-breadth-first-search-in-scala-with-fp
+ */
+object b {
+
+  case class Node(value: Int, children: List[Node] = List.empty[Node])
+
+  def main(args: Array[String]) {
+    val root = Node(
+      value = 3,
+      children = List(
+        Node(value = 4, children = List(Node(value = 5))), 
+        Node(value = 6), 
+        Node(value = 8)
+      )
+    )      
+    val result = bfs(root, { (node: Node) =>
+      Queue.empty[Node] ++ node.children
+    }).find(_.value==5) 
+    println(result)
+  }
+
+  def bfs[Node](node: Node, f: Node => Queue[Node]): Stream[Node] = {
+    def _bfs(queue: Queue[Node]): Stream[Node] = queue match {
+      case q if q.isEmpty => Stream.Empty
+      case _ =>
+        val (head, rest) = queue.dequeue
+        head #:: _bfs(rest ++ f(head))
+    }
+    node #:: _bfs(Queue.empty[Node] ++ f(node))
+  }
+
+}

binary-search/b.scala

@@ -0,0 +1,22 @@
+object b {
+
+  def main(args: Array[String]): Unit = {
+    println(search(List(1, 2, 3, 4, 5), 6))
+  }
+
+  def search(list: List[Int], target: Int) = {
+    def _s(start: Int, end: Int): Int = {
+      if(start > end) -1 else {
+        val mid = start + (end - start)/ 2 
+        list(mid) match {
+          case m if m == target => mid 
+          case m if m <= target => _s(mid+1, end)
+          case m if target < m =>  _s(start, mid-1)
+        }
+      }
+    }
+    _s(0, list.length - 1)
+  }
+
+
+}

max-depth/m.scala

@@ -0,0 +1,23 @@
+//https://stackoverflow.com/questions/45678000/maximum-depth-of-binary-tree-in-scala
+object m {
+
+  sealed trait Node
+  case object Empty extends Node
+  case class Leaf(value: Int, left: Node = Empty, right: Node = Empty) extends Node
+
+  def main(args: Array[String]) {
+    val root = Leaf(
+      value = 3,
+      left = Leaf(value = 5, right = Leaf(value = 6)),
+      right = Leaf(value = 8, left = Leaf(value = 10, right = Leaf(value = 11)))
+    )
+    println(depth(root))
+  }
+
+  def depth(node: Node): Int = node match {
+    case Empty => 0
+    case Leaf(value, left, right) => 
+      Math.max(depth(left), depth(right)) + 1
+  }
+
+}

permutations/p.scala

@@ -0,0 +1,16 @@
+object p {
+
+  def main(args: Array[String]): Unit = {
+    println(permutations(List(1, 2, 3)))
+  }
+
+  def permutations(ls: List[Int]): List[List[Int]] = ls match {
+    case Nil => List(List())
+    case _ => for {
+      e <- ls
+      r <- permutations(ls diff List(e))
+    } yield e :: r
+  }
+
+
+}

quick-sort/q.scala

@@ -0,0 +1,14 @@
+object q {
+
+  def main(args: Array[String]) {
+    println(sort(List(9, 2, 4, 1, 3)))
+  }
+
+  def sort(list: List[Int]): List[Int] = list match {
+    case Nil => Nil
+    case head :: tail => 
+      val (low, hight) = tail.partition(_<head)
+      sort(low) ::: head :: sort(hight)
+  }
+
+}

two-sum/ts.scala

@@ -0,0 +1,11 @@
+object ts {
+
+  def main(args: Array[String]): Unit = {
+    println(s(List(1, 2, 3, 4, 5), 8))
+
+  }
+
+  def s(list: List[Int], target: Int) = 
+    list.combinations(2).find(_.sum==target)
+
+}