Added July day 25 and 26 problem

Author: suriyakrishna

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

@@ -0,0 +1,58 @@
+package com.leetcode.scala.monthly2020.july
+
+import scala.annotation.tailrec
+
+/*
+* Given a non-negative integer num, repeatedly add all its digits until the result has only one digit.
+*
+* */
+
+/*
+* Input: 38
+  Output: 2
+  Explanation: The process is like: 3 + 8 = 11, 1 + 1 = 2.
+               Since 2 has only one digit, return it.
+*
+* Follow up:
+  Could you do it without any loop/recursion in O(1) runtime?
+*
+* */
+
+/*
+* Approach: Recursion/Iterative/Mathematical
+*
+*
+* Mathematical approach will be O(1) Time complexity -- Digital Root
+*
+* For complete explanation visit.
+* @link: https://leetcode.com/articles/add-digits/#
+*
+* */
+
+object AddDigits {
+
+  @tailrec
+  def addDigitsRec(num: Int): Int = {
+    if (num >= 0 && num <= 9) return num
+    var N = num
+    var sum = 0
+    do {
+      sum += N % 10
+      N /= 10
+    } while (N != 0)
+    return addDigitsRec(sum)
+  }
+
+  def main(args: Array[String]): Unit = {
+    val testCases = Array(0, 9, 1234, 27)
+    val actualResult = testCases.map(a => addDigits(a))
+    val expectedResult = Array(0, 9, 1, 9)
+    println(s"Result: ${actualResult.mkString(" ")}, ${actualResult sameElements expectedResult}")
+  }
+
+  def addDigits(num: Int): Int = {
+    if (num == 0) return 0
+    else if (num % 9 == 0) return 9
+    else return num % 9
+  }
+}

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

@@ -0,0 +1,59 @@
+package com.leetcode.scala.monthly2020.july
+
+/*
+* Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
+* (i.e.,  [0,1,2,4,5,6,7] might become  [4,5,6,7,0,1,2]).
+* Find the minimum element.
+* The array may contain duplicates.
+*
+* */
+
+/*
+* Approach: Linear/Binary Search
+*
+* Binary Search will the best approach.
+*
+*  */
+
+object FindMinimuminRotatedSortedArrayII {
+  def main(args: Array[String]): Unit = {
+    val nums = Array(4, 5, 6, 6, 1, 2)
+    val nums1 = Array(1, 2, 3, 4, 5)
+    var result = findMin(nums)
+    var result1 = findMin(nums1)
+    println(s"Result: ${result}, ${result == 1}")
+    println(s"Result: ${result1}, ${result1 == 1}")
+  }
+
+  //Binary Search
+  def findMin(nums: Array[Int]): Int = {
+    var from = 0
+    var to = nums.length - 1
+    while (from < to) {
+      val mid = from + (to - from) / 2
+      nums(mid) compareTo nums(to) match {
+        case -1 => to = mid
+        case 0 => to -= 1
+        case _ => from = mid + 1
+      }
+    }
+    nums(from)
+  }
+
+  //Linear Search
+  def findMinLinear(nums: Array[Int]): Int = {
+    if (nums.isEmpty) return 0
+    var min = nums.head
+    var result = nums.head
+    for (i <- 1 until nums.length) {
+      if (nums(i) >= result) {
+        result = nums(i)
+      } else {
+        return nums(i)
+      }
+      min = min min result
+    }
+    min
+  }
+
+}