Day 18 - 22 Except Longest Duplicate Substring and Dungeon Game

Author: suriyakrishna

src/main/scala/com/kishan/scala/leetcode/juneChallenges/HIndex2.scala

@@ -0,0 +1,57 @@
+package com.kishan.scala.leetcode.juneChallenges
+
+import scala.util.control.Breaks
+
+/*
+* Given an array of citations sorted in ascending order (each citation is a non-negative integer) of a researcher, write a function to compute the researcher's h-index.
+  According to the definition of h-index on Wikipedia: "A scientist has index h if h of his/her N papers have
+  at least h citations each, and the other N − h papers have no more than h citations each."
+*
+* */
+
+/*
+* Input: citations = [0,1,3,5,6]
+  Output: 3
+  Explanation: [0,1,3,5,6] means the researcher has 5 papers in total and each of them had
+               received 0, 1, 3, 5, 6 citations respectively.
+               Since the researcher has 3 papers with at least 3 citations each and the remaining
+               two with no more than 3 citations each, her h-index is 3.
+*
+* */
+
+/*
+* Approach:
+* 1. We have to iterate through the list in reverse order [If list is not sorted we have to sort the list in ascending order first].
+* 2. Will check if the current element is greater than or equal to count. If not we will continue the iteration.
+* 3. If not we have to break the loop and return the result.
+*
+* */
+
+
+object HIndex2 {
+
+  def main(args: Array[String]): Unit = {
+    val citations = Array(0, 1, 3, 5, 6)
+    val result = hIndex(citations)
+    println(s"Result: ${result}, ${result == 3}")
+  }
+
+  def hIndex(citations: Array[Int]): Int = {
+    val length = citations.length
+    var result = 0
+    var tail = length - 1
+    val breaks = new Breaks
+    breaks.breakable {
+      while (tail >= 0) {
+        var count = length - tail
+        if (citations(tail) >= count) {
+          result = count
+          tail -= 1
+        } else {
+          breaks.break()
+        }
+      }
+    }
+    return result
+  }
+}

src/main/scala/com/kishan/scala/leetcode/juneChallenges/PermutationSequence.scala

@@ -0,0 +1,56 @@
+package com.kishan.scala.leetcode.juneChallenges
+
+/*
+* The set [1,2,3,...,n] contains a total of n! unique permutations.
+  By listing and labeling all of the permutations in order, we get the following sequence for n = 3:
+
+    "123"
+    "132"
+    "213"
+    "231"
+    "312"
+    "321"
+
+  Given n and k, return the kth permutation sequence.
+* Note:
+*   Given n will be between 1 and 9 inclusive.
+*   Given k will be between 1 and n! inclusive.
+* */
+
+
+/*
+* Input: n = 3, k = 3
+  Output: "213"
+*
+* Input: n = 4, k = 9
+  Output: "2314"
+* */
+
+
+/*
+* Approach - 1: [This method will be slow because we are calculating all the possible permutations]
+* 1. First we are creating a Range out of n.
+* 2. We use permutations method under Range object to get the permutations.
+* 3. We are dropping all the element upto k-1.
+* 4. Take next element from the Range.
+* 5. Convert list of integers to string using mkString method.
+* 6. return the string.
+*
+* */
+
+
+object PermutationSequence {
+
+  def main(args: Array[String]): Unit = {
+    val result = getPermutation(3, 3)
+    println(s"Result: ${result}, ${result == "213"}")
+    val result1 = getPermutation(4, 4)
+    println(s"Result: ${result1}, ${result1 == "1342"}")
+  }
+
+  def getPermutation(n: Int, k: Int): String = {
+    if (n < 0 || n > 9) return ""
+    var result = ""
+    Range(1, n + 1).permutations.drop(k - 1).next().mkString
+  }
+}

src/main/scala/com/kishan/scala/leetcode/juneChallenges/SingleNumber2.scala

@@ -0,0 +1,82 @@
+package com.kishan.scala.leetcode.juneChallenges
+
+import scala.collection.mutable
+
+/* Given a non-empty array of integers, every element appears three times except for one,
+   which appears exactly once. Find that single one.
+*
+* */
+
+/*
+* Note:
+  Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?
+* */
+
+/*
+* Input: [2,2,3,2]
+  Output: 3
+*
+* Input: [0,1,0,1,0,1,99]
+  Output: 99
+* */
+
+/*
+* Approach: Bit Manupulation Using XOR
+*
+* 0 ^ 2 = 2
+* 2 ^ 2 = 0
+*
+* 1. Declaring 3 variables ones,two and threes.
+* 2. Iterating through the array.
+*
+* Iteration:
+*
+* 1 -> (2,0,0)
+* 2 -> (0,2,0)
+* 3 -> (1,0,2)
+* 4 -> (3,0,0)
+*
+*
+* */
+
+
+object SingleNumber2 {
+  def main(args: Array[String]): Unit = {
+    val nums = Array(2, 2, 3, 2)
+    val nums1 = Array(0, 1, 0, 1, 0, 1, 95)
+    println(singleNumberBestApproach(nums))
+  }
+
+  //Using Bit Manupulation
+  def singleNumberBestApproach(nums: Array[Int]): Int = {
+    var ones = 0
+    var twos = 0
+    var threes = 0
+    for (num <- nums) {
+      twos |= ones & num
+      ones ^= num
+      threes = ones & twos
+      ones &= ~threes
+      twos &= ~threes
+    }
+    ones
+  }
+
+  //Using HashMap - Extra *Memory
+  def singleNumber(nums: Array[Int]): Int = {
+    var map: mutable.HashMap[Int, Int] = mutable.HashMap()
+    for (num <- nums) {
+      if (map.contains(num)) {
+        val sum = map(num) + 1
+        map += (num -> sum)
+      } else {
+        map += (num -> 1)
+      }
+    }
+    for (item <- map) {
+      if (item._2 == 1) return item._1
+    }
+    return -1
+  }
+
+}

src/main/scala/com/kishan/scala/leetcode/juneChallenges/SurroundedRegions.scala

@@ -0,0 +1,118 @@
+package com.kishan.scala.leetcode.juneChallenges
+
+import scala.collection.mutable
+
+/*
+* Given a 2D board containing 'X' and 'O' (the letter O), capture all regions surrounded by 'X'.
+  A region is captured by flipping all 'O's into 'X's in that surrounded region.
+*
+* */
+
+/*
+* Before:
+* X X X X
+  X O O X
+  X X O X
+  X O X X
+*
+* After:
+* X X X X
+  X X X X
+  X X X X
+  X O X X
+*
+* Surrounded regions shouldn’t be on the border, which means that any 'O' on the border of the board are not flipped to 'X'.
+* Any 'O' that is not on the border and it is not connected to an 'O' on the border will be flipped to 'X'.
+* Two cells are connected if they are adjacent cells connected horizontally or vertically.
+*  */
+
+/*
+* Approach: Breadth First Search or Depth First Search.
+*
+* 1. We have to go through the border of the board and check if we have any O's then we have to replace that O's with new character '*' also we have see if that 'O' has adjacent 'O' and we have to replace them with '*'.
+* 2. After replacing all the O's in the border and their adjacent O's connected to the border. Once again we have to go through the each element of the array and we have replace the remaining O's with 'X' and '*' with 'O'.
+*
+* */
+
+
+object SurroundedRegions {
+  def main(args: Array[String]): Unit = {
+    //    var board = Array(Array('x', 'x', 'x', 'x'), Array('x', 'o', 'o', 'x'), Array('x', 'x', 'o', 'x'), Array('x', 'o', 'x', 'x'))
+    //    var board = Array(Array('o', 'x', 'x', 'o', 'x'), Array('x', 'o', 'o', 'x', 'o'), Array('x', 'o', 'x', 'o', 'x'), Array('o', 'x', 'o', 'o', 'o'), Array('x', 'x', 'o', 'x', 'o'))
+    var board = Array(Array('x', 'o', 'x', 'o', 'x', 'o'), Array('o', 'x', 'o', 'x', 'o', 'x'), Array('x', 'o', 'x', 'o', 'x', 'o'), Array('o', 'x', 'o', 'x', 'o', 'x'))
+    //        var board = Array(Array('x', 'o', 'x'), Array('x', 'o', 'x'), Array('x', 'o', 'x'))
+    println("BEFORE")
+    board.foreach(a => println(a.mkString))
+    solve(board)
+    println("AFTER")
+    board.foreach(a => println(a.mkString))
+  }
+
+  def solve(board: Array[Array[Char]]): Unit = {
+    if (board.length == 0 || board(0).length == 0) return
+    val rowLength = board.length
+    val columnLength = board(0).length
+    for (i <- board.indices) {
+      if (board(i)(0).toUpper == 'O') depthFirstSearch(i, 0, board)
+      if (board(i)(columnLength - 1).toUpper == 'O') depthFirstSearch(i, columnLength - 1, board)
+    }
+
+    for (j <- board(0).indices) {
+      if (board(0)(j).toUpper == 'O') depthFirstSearch(0, j, board)
+      if (board(rowLength - 1)(j).toUpper == 'O') depthFirstSearch(rowLength - 1, j, board)
+    }
+
+    for (i <- board.indices) {
+      for (j <- board(0).indices) {
+        if (board(i)(j).toUpper == 'O') {
+          board(i)(j) = 'X'
+        } else if (board(i)(j) == '*') {
+          board(i)(j) = 'O'
+        }
+      }
+    }
+  }
+
+  def depthFirstSearch(i: Int, j: Int, board: Array[Array[Char]]): Unit = {
+    if (i < 0 || i > board.length - 1 || j < 0 || j > board(i).length - 1) return
+    if (board(i)(j).toUpper == 'O') board(i)(j) = '*'
+    if (i > 0 && board(i - 1)(j).toUpper == 'O') depthFirstSearch(i - 1, j, board)
+    if (i < board.length - 1 && board(i + 1)(j).toUpper == 'O') depthFirstSearch(i + 1, j, board)
+    if (j > 0 && board(i)(j - 1).toUpper == 'O') depthFirstSearch(i, j - 1, board)
+    if (j < board(0).length - 1 && board(i)(j + 1).toUpper == 'O') depthFirstSearch(i, j + 1, board)
+  }
+
+
+  def solveBFS(board: Array[Array[Char]]): Unit = {
+    if (board.length == 0 || board(0).length == 0) return
+    var queue: mutable.Queue[(Int, Int)] = mutable.Queue()
+    for (i <- board.indices) {
+      if (board(i)(0) == 'O') BFS(i, 0, board)
+      if (board(i)(board(0).length - 1) == 'O') BFS(i, board(0).length - 1, board)
+    }
+
+    for (j <- board(0).indices) {
+      if (board(0)(j) == 'O') BFS(0, j, board)
+      if (board(board.length - 1)(j) == 'O') BFS(board.length - 1, j, board)
+    }
+
+    for (i <- board.indices) {
+      for (j <- board(0).indices) {
+        if (board(i)(j) == '*') board(i)(j) = 'O' else if (board(i)(j) == 'O') board(i)(j) = 'X'
+      }
+    }
+
+    def BFS(i: Int, j: Int, array: Array[Array[Char]]): Unit = {
+      if (i < 0 || i > array.length - 1 || j < 0 || j > array(0).length - 1) return
+      if (array(i)(j) == 'O') queue.enqueue((i, j))
+      while (queue.nonEmpty) {
+        val position = queue.dequeue()
+        array(position._1)(position._2) = '*'
+        if (position._1 > 0 && array(position._1 - 1)(position._2) == 'O' && !queue.contains((position._1 - 1, position._2))) queue.enqueue((position._1 - 1, position._2))
+        if (position._1 < array.length - 1 && array(position._1 + 1)(position._2) == 'O' && !queue.contains((position._1 + 1, position._2))) queue.enqueue((position._1 + 1, position._2))
+        if (position._2 > 0 && array(position._1)(position._2 - 1) == 'O' && !queue.contains((position._1, position._2 - 1))) queue.enqueue((position._1, position._2 - 1))
+        if (position._2 < array(0).length - 1 && array(position._1)(position._2 + 1) == 'O' && !queue.contains((position._1, position._2 + 1))) queue.enqueue((position._1, position._2 + 1))
+      }
+    }
+  }
+}