July challenges - Day 1 - 6

Author: suriyakrishna

src/main/scala/com/leetcode/scala/monthly2020/july/ArrangingCoins.scala

@@ -0,0 +1,66 @@
+package com.leetcode.scala.monthly2020.july
+
+/*
+* You have a total of n coins that you want to form in a staircase shape, where every k-th row must have exactly k coins.
+* Given n, find the total number of full staircase rows that can be formed.
+* n is a non-negative integer and fits within the range of a 32-bit signed integer.
+*
+* */
+
+/*
+* n = 5
+
+  The coins can form the following rows:
+  ¤
+  ¤ ¤
+  ¤ ¤
+
+  Because the 3rd row is incomplete, we return 2.
+*
+* n = 8
+
+  The coins can form the following rows:
+  ¤
+  ¤ ¤
+  ¤ ¤ ¤
+  ¤ ¤
+
+  Because the 4th row is incomplete, we return 3.
+*
+* */
+
+/*
+* Approach: Binary Search/Mathematical
+*
+*
+* Mathematical Approach:
+* @link: https://leetcode.com/articles/arranging-coins/#
+* Time Complexity: O(1)
+* Space Complexity: O(1)
+*
+* */
+
+
+object ArrangingCoins {
+
+  //Matematical Approach
+  def arrangeCoinsMath(n: Int): Int = {
+    return math.sqrt((2 * n.toLong + 0.25) - 0.5).toInt
+  }
+
+  def main(args: Array[String]): Unit = {
+    val n = 8
+    val result = arrangeCoins(n)
+    println(s"Result: ${result}, ${result == 3}")
+  }
+
+  def arrangeCoins(n: Int): Int = {
+    var current = n
+    var result = 0
+    while (current > 0 && current > result) {
+      result += 1
+      current -= result
+    }
+    return result
+  }
+}

src/main/scala/com/leetcode/scala/monthly2020/july/BinaryTreeLevelOrderTraversalII.scala

@@ -0,0 +1,75 @@
+package com.leetcode.scala.monthly2020.july
+
+import com.leetcode.scala.monthly2020.june.TreeNode
+
+import scala.collection.mutable
+
+
+/*
+* Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level by level from leaf to root).
+*
+* */
+
+/*
+*  For example:
+   Given binary tree [3,9,20,null,null,15,7],
+*
+*   3
+   / \
+  9  20
+    /  \
+   15   7
+*
+* return its bottom-up level order traversal as:
+* [
+  [15,7],
+  [9,20],
+  [3]
+  ]
+*
+* */
+
+/*
+* Approach: BFS - Breadth First Search
+*
+* 1. We have to Build Queue of Queue[TreeNode]
+* 2. We will instantiate the Queue with Queue[root node]
+* 3. We will dequeue the outer queue first and then we will have queue[TreeNode].
+* 4. For each Queue in the outer queue we are instantiating an empty queue to store all the child nodes and an empty list to store all the Integer values from the TreeNode.
+* 5. We will dequeue the inner queue and have to add the integer value to the list and we have to add the child node to the inner queue.
+* 6. Once the currentElement becomes empty we will check if the new Queue which we created is empty. If it's nonEmpty we will add it to the outer Queue and the list to the result. Iteration will continue until the outer queue nonEmpty.
+* 7. Finally we will return the result.
+*
+* */
+
+
+object BinaryTreeLevelOrderTraversalII {
+
+  def main(args: Array[String]): Unit = {
+    val tree: TreeNode = new TreeNode(3, new TreeNode(9, new TreeNode(10)), new TreeNode(20, new TreeNode(15), new TreeNode(7)))
+    println(tree)
+    println(levelOrderBottom(tree))
+  }
+
+  def levelOrderBottom(root: TreeNode): List[List[Int]] = {
+    var result: mutable.Stack[List[Int]] = mutable.Stack()
+    if (root == null) return List()
+    var queue: mutable.Queue[mutable.Queue[TreeNode]] = mutable.Queue()
+    queue.enqueue(mutable.Queue(root))
+    while (queue.nonEmpty) {
+      val currentElement = queue.dequeue()
+      var queue1: mutable.Queue[TreeNode] = mutable.Queue()
+      var list: List[Int] = List()
+      while (currentElement.nonEmpty) {
+        val currentTree = currentElement.dequeue()
+        val value = currentTree.value
+        if (currentTree.left != null) queue1.enqueue(currentTree.left)
+        if (currentTree.right != null) queue1.enqueue(currentTree.right)
+        list = list :+ value
+      }
+      result.push(list)
+      if (queue1.nonEmpty) queue.enqueue(queue1)
+    }
+    return result.toList
+  }
+}

src/main/scala/com/leetcode/scala/monthly2020/july/HammingDistance.scala

@@ -0,0 +1,50 @@
+package com.leetcode.scala.monthly2020.july
+
+/*
+* The Hamming distance between two integers is the number of positions at which the corresponding bits are different.
+* Given two integers x and y, calculate the Hamming distance.
+*
+* */
+
+/*
+* Input: x = 1, y = 4
+* Output: 2
+
+  Explanation:
+  1   (0 0 0 1)
+  4   (0 1 0 0)
+         ↑   ↑
+
+  The above arrows point to positions where the corresponding bits are different.
+*
+*  */
+
+/*
+* Approach: Bit Manuplation
+*
+* 1 ^ 4 will give 0101
+* we can count 1's from the binary number to get the bit count.
+*
+*  */
+
+
+object HammingDistance {
+
+  //Using In-built Functions
+  def hammingDistanceInBuilts(x: Int, y: Int): Int = {
+    Integer.bitCount(x ^ y)
+  }
+
+  def main(args: Array[String]): Unit = {
+    val x = 1
+    val y = 4
+    val result = hammingDistance(x, y)
+    println(s"Result: ${result}, ${result == 2}")
+  }
+
+  //Counting from the binary string
+  def hammingDistance(x: Int, y: Int): Int = {
+    (x ^ y).toBinaryString.count(a => a == '1')
+  }
+
+}

src/main/scala/com/leetcode/scala/monthly2020/july/PlusOne.scala

@@ -0,0 +1,66 @@
+package com.leetcode.scala.monthly2020.july
+
+/*
+* Given a non-empty array of digits representing a non-negative integer, plus one to the integer.
+* The digits are stored such that the most significant digit is at the head of the list, and each element in the array contain a single digit.
+* You may assume the integer does not contain any leading zero, except the number 0 itself.
+*
+* */
+
+/*
+* Input: [1,2,3]
+  Output: [1,2,4]
+  Explanation: The array represents the integer 123.
+*
+* Input: [4,3,2,1]
+  Output: [4,3,2,2]
+  Explanation: The array represents the integer 4321.
+*
+* */
+
+/*
+* Approach: Brute-Force
+* Time Complexity: O(n), Best Case: O(1), If the last digit is less than 9
+*
+* 1. First we will check if the last digit value is less than 9. If yes we will add 1 to the last digit and we will return the result.
+* 2. If last digit is 9 then we have to iterate through the array in reverse order and we have to check if the current element is less than 9 if yes we will add 1 and we will return the result.
+  * else: we need to change the current element to 0 and we have to add 1 to next element.
+  * if the first element of the array is 9 then we have to concat a new Array(1) ++ (0,0) eg: Input == [9,9]
+*
+* */
+
+object PlusOne {
+  def main(args: Array[String]): Unit = {
+    val nums = Array(8, 9)
+    val nums1 = Array(9, 9)
+    val result = plusOne(nums)
+    val result1 = plusOne(nums1)
+    println(s"Result: [${result.mkString(", ")}], ${result.mkString(",") == "9,0"}")
+    println(s"Result: [${result1.mkString(", ")}], ${result1.mkString(",") == "1,0,0"}")
+  }
+
+  def plusOne(digits: Array[Int]): Array[Int] = {
+    if (digits.isEmpty) return digits
+    var result = Array(digits: _*)
+    if (result.last < 9) {
+      result(result.length - 1) += 1
+    } else {
+      var i = result.length - 1
+      while (i >= 0) {
+        if (i != 0 && result(i) == 9) {
+          result(i) = 0
+        } else if (result.length != 1 && result(i) != 9) {
+          result(i) += 1
+          return result
+        }
+        if (i == 0 && digits(0) == 9) {
+          result(0) = 0
+          result = Array(1) ++ result
+        }
+        i -= 1
+      }
+
+    }
+    return result
+  }
+}

src/main/scala/com/leetcode/scala/monthly2020/july/PrisonCellsAfterNDays.scala

@@ -0,0 +1,88 @@
+package com.leetcode.scala.monthly2020.july
+
+import scala.collection.mutable
+
+/*
+* There are 8 prison cells in a row, and each cell is either occupied or vacant.
+* Each day, whether the cell is occupied or vacant changes according to the following rules:
+  * If a cell has two adjacent neighbors that are both occupied or both vacant, then the cell becomes occupied.
+  * Otherwise, it becomes vacant.
+* (Note that because the prison is a row, the first and the last cells in the row can't have two adjacent neighbors.)
+*
+* We describe the current state of the prison in the following way: cells[i] == 1 if the i-th cell is occupied, else cells[i] == 0.
+* Given the initial state of the prison, return the state of the prison after N days (and N such changes described above.)
+*
+* */
+
+/*
+* Input: cells = [0,1,0,1,1,0,0,1], N = 7
+  Output: [0,0,1,1,0,0,0,0]
+  Explanation:
+  The following table summarizes the state of the prison on each day:
+  Day 0: [0, 1, 0, 1, 1, 0, 0, 1]
+  Day 1: [0, 1, 1, 0, 0, 0, 0, 0]
+  Day 2: [0, 0, 0, 0, 1, 1, 1, 0]
+  Day 3: [0, 1, 1, 0, 0, 1, 0, 0]
+  Day 4: [0, 0, 0, 0, 0, 1, 0, 0]
+  Day 5: [0, 1, 1, 1, 0, 1, 0, 0]
+  Day 6: [0, 0, 1, 0, 1, 1, 0, 0]
+  Day 7: [0, 0, 1, 1, 0, 0, 0, 0]
+*
+* Input: cells = [1,0,0,1,0,0,1,0], N = 1000000000
+  Output: [0,0,1,1,1,1,1,0]
+*
+* Note:
+  * cells.length == 8
+  * cells[i] is in {0, 1}
+  * 1 <= N <= 10^9
+*
+* */
+
+
+/*
+* Approach: Memoization
+*
+* We can implement this program using brute force but when ever the input increase it will take too much time to compute the result.
+* Inorder to overcome the above issue we need to store the result in the map and when ever we see the same key/cycle in the map
+* we will get the n value for the key and we need to compute and modify the n.
+*
+*
+* */
+
+object PrisonCellsAfterNDays {
+  def main(args: Array[String]): Unit = {
+    val input = Array(1, 0, 0, 1, 0, 0, 1, 0)
+    val n = 1000000000
+    val result = prisonAfterNDays(input, n)
+    println(s"Result: [${result.mkString(", ")}], ${result.mkString(",") == "0,0,1,1,1,1,1,0"}")
+  }
+
+  def prisonAfterNDays(cells: Array[Int], N: Int): Array[Int] = {
+    var n: Int = N
+    var map: mutable.HashMap[String, Int] = mutable.HashMap()
+    var currDay: Array[Int] = Array(cells: _*)
+    while (n > 0) {
+      var modified: Array[Int] = Array(currDay: _*)
+      map += (currDay.mkString -> n)
+      for (i <- cells.indices) {
+        if ((i == 0 || i == cells.length - 1) && currDay(i) != 0) {
+          modified(i) = 0
+        } else if (i >= 1 && i <= cells.length - 2) {
+          val prev = currDay(i - 1)
+          val next = currDay(i + 1)
+          if (prev == next) {
+            modified(i) = 1
+          } else {
+            modified(i) = 0
+          }
+        }
+      }
+      currDay = Array(modified: _*)
+      n -= 1
+      if (map.contains(currDay.mkString)) {
+        n = n % (map(currDay.mkString) - n)
+      }
+    }
+    return currDay
+  }
+}