Added binary search problems

Author: Prashant Jain

src/in/knowledgegate/dsa/binarysearch/problems/FirstBadVersion.java

@@ -0,0 +1,75 @@
+package in.knowledgegate.dsa.binarysearch.problems;
+
+/**
+ * You are a product manager and currently leading
+ * a team to develop a new product. Unfortunately,
+ * the latest version of your product fails the
+ * quality check. Since each version is developed based
+ * on the previous version, all the versions after
+ * a bad version are also bad.
+ *
+ * Suppose you have n versions [1, 2, ..., n] and
+ * you want to find out the first bad one, which
+ * causes all the following ones to be bad.
+ *
+ * You are given an API bool isBadVersion(version)
+ * which returns whether version is bad. Implement
+ * a function to find the first bad version. You
+ * should minimize the number of calls to the API.
+ *
+ *
+ * Example 1:
+ * Input: n = 5, bad = 4
+ * Output: 4
+ * Explanation:
+ * call isBadVersion(3) -> false
+ * call isBadVersion(5) -> true
+ * call isBadVersion(4) -> true
+ * Then 4 is the first bad version.
+ *
+ * Example 2:
+ * Input: n = 1, bad = 1
+ * Output: 1
+ *
+ * Constraints:
+ * 1 <= bad <= n <= 231 - 1
+ */
+public class FirstBadVersion {
+    static int badVersion;
+    static int TOTAL_VERSION = 500;
+
+    public static void main(String[] args) {
+        FirstBadVersion versionChecker =
+            new FirstBadVersion();
+        badVersion = 412;
+        System.out.println("\nbad version is:"
+            + versionChecker.firstBadVersionLinearSearch(TOTAL_VERSION));
+        System.out.println("\nbad version is:"
+            + versionChecker.firstBadVersion(TOTAL_VERSION));
+    }
+
+    public int firstBadVersion(int n) {
+        int beg = 1, end = n;
+        while (beg <= end) {
+            int mid = (beg + end) / 2;
+            if (isBadVersion(mid)) {
+                end = mid - 1;
+            } else {
+                beg = mid + 1;
+            }
+        }
+        return end + 1;
+    }
+
+    public int firstBadVersionLinearSearch(int n) {
+        for (int i = 1; i < n; i++) {
+            if (isBadVersion(i)) return i;
+        }
+        return -1;
+    }
+
+    private boolean isBadVersion(int version) {
+        System.out.print(".");
+        return version - badVersion >= 0;
+    }
+}

src/in/knowledgegate/dsa/binarysearch/problems/GuessNumberHigherOrLower.java

@@ -0,0 +1,75 @@
+package in.knowledgegate.dsa.binarysearch.problems;
+
+/**
+ * We are playing the Guess Game. The game is as follows:
+ *
+ * I pick a number from 1 to n. You have to guess
+ * which number I picked.
+ *
+ * Every time you guess wrong, I will tell you
+ * whether the number I picked is higher or lower than
+ * your guess.
+ *
+ * You call a pre-defined API int guess(int num),
+ * which returns three possible results:
+ *
+ * -1: Your guess is higher than the number I picked (i.e. num > pick).
+ * 1: Your guess is lower than the number I picked (i.e. num < pick).
+ * 0: your guess is equal to the number I picked (i.e. num == pick).
+ * Return the number that I picked.
+ *
+ *
+ * Example 1:
+ * Input: n = 10, pick = 6
+ * Output: 6
+ *
+ * Example 2:
+ * Input: n = 1, pick = 1
+ * Output: 1
+ *
+ * Example 3:
+ * Input: n = 2, pick = 1
+ * Output: 1
+ *
+ * Constraints:
+ * 1 <= n <= 231 - 1
+ * 1 <= pick <= n
+ */
+public class GuessNumberHigherOrLower {
+    static int numberToGuess;
+
+    public static void main(String[] args) {
+        GuessNumberHigherOrLower guesser =
+            new GuessNumberHigherOrLower();
+        numberToGuess = 99;
+        System.out.println("\nnumber is:" + guesser.guessNumberNormalSearch(100));
+        System.out.println();
+        System.out.println("\nnumber is:" + guesser.guessNumber(100));
+    }
+
+    public int guessNumber(int n) {
+        int beg = 1, end = n;
+        while (beg <= end) {
+            int mid = (beg + end) / 2;
+            int res = guess(mid);
+            if (res == 0) return mid;
+            if (res == -1) end = mid -1;
+            else beg = mid + 1;
+        }
+        return -1;
+    }
+
+    public int guessNumberNormalSearch(int n) {
+        for (int i = 1; i <= n; i++) {
+            if (guess(i) == 0) return i;
+        }
+        return -1;
+    }
+
+    private int guess(int num) {
+        System.out.print(".");
+        if (num == numberToGuess) return 0;
+        else if (num < numberToGuess) return 1;
+        return -1;
+    }
+}

src/in/knowledgegate/dsa/binarysearch/problems/SearchIn2DMatrix.java

@@ -0,0 +1,58 @@
+package in.knowledgegate.dsa.binarysearch.problems;
+
+/**
+ * Write an efficient algorithm that searches for
+ * a value target in an m x n integer matrix.
+ * This matrix has the following properties:
+ *
+ * Integers in each row are sorted from left to right.
+ * The first integer of each row is greater than
+ * the last integer of the previous row.
+ *
+ * Example 1:
+ * Input: matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]],
+ * target = 3
+ * Output: true
+ *
+ * Example 2:
+ * Input: matrix = [[1,3,5,7],[10,11,16,20],
+ * [23,30,34,60]], target = 13
+ * Output: false
+ *
+ * Constraints:
+ * m == matrix.length
+ * n == matrix[i].length
+ * 1 <= m, n <= 100
+ * -104 <= matrix[i][j], target <= 104
+ */
+public class SearchIn2DMatrix {
+    public static void main(String[] args) {
+        SearchIn2DMatrix search =
+            new SearchIn2DMatrix();
+        int[][] nums = new int[][]{{1,3,5,7},
+            {10,11,16,20},{23,30,34,60}};
+        System.out.println("Element status: "
+            + search.searchMatrix(nums, 24));
+    }
+
+    public boolean searchMatrix(int[][] matrix, int target) {
+        if (matrix == null || matrix.length == 0) return false;
+        int m = matrix.length;
+        int n = matrix[0].length;
+        int tot = m * n;
+        int beg = 0;
+        int end = tot - 1;
+        while (beg <= end) {
+            int mid = (beg + end) / 2;
+            int i = mid / n;
+            int j = mid % n;
+            if (matrix[i][j] == target)
+                return true;
+            else if (matrix[i][j] < target)
+                beg = mid + 1;
+            else
+                end = mid - 1;
+        }
+        return false;
+    }
+}

src/in/knowledgegate/dsa/binarysearch/problems/SearchInRotatedSortedArray.java

@@ -0,0 +1,79 @@
+package in.knowledgegate.dsa.binarysearch.problems;
+
+/**
+ * There is an integer array nums sorted in ascending
+ * order (with distinct values).
+ *
+ * Prior to being passed to your function, nums is
+ * possibly rotated at an unknown pivot index
+ * k (1 <= k < nums.length) such that the resulting
+ * array is [nums[k], nums[k+1], ..., nums[n-1],
+ * nums[0], nums[1], ..., nums[k-1]] (0-indexed).
+ * For example, [0,1,2,4,5,6,7] might be rotated
+ * at pivot index 3 and become [4,5,6,7,0,1,2].
+ *
+ * Given the array nums after the possible rotation
+ * and an integer target, return the index of
+ * target if it is in nums, or -1 if it is not in
+ * nums.
+ *
+ * You must write an algorithm with O(log n) runtime
+ * complexity.
+ *
+ *
+ * Example 1:     0,1,2,3,4,5,6
+ * Input: nums = [4,5,6,7,0,1,2], target = 0
+ * Output: 4
+ *
+ * Example 2:
+ * Input: nums = [4,5,6,7,0,1,2], target = 3
+ * Output: -1
+ *
+ * Example 3:
+ * Input: nums = [1], target = 0
+ * Output: -1
+ *
+ *
+ * Constraints:
+ * 1 <= nums.length <= 5000
+ * -104 <= nums[i] <= 104
+ * All values of nums are unique.
+ * nums is an ascending array that is possibly rotated.
+ * -104 <= target <= 104
+ */
+public class SearchInRotatedSortedArray {
+    public static void main(String[] args) {
+        SearchInRotatedSortedArray search =
+            new SearchInRotatedSortedArray();
+        int[] nums = new int[]{4,5,6,7,0,1,2};
+        System.out.println("Found at:"
+            + search.search(nums, 3));
+    }
+
+    int search(int[] nums, int target) {
+        int beg = 0, end = nums.length - 1;
+        while (beg <= end) {
+            int mid = (beg + end) / 2;
+            if (nums[mid] > nums[end])
+                beg = mid + 1;
+            else
+                end = mid - 1;
+        }
+        int shift = end + 1;
+
+        beg = 0;
+        end = nums.length - 1;
+        while(beg <= end) {
+            int mid = (beg + end) / 2;
+            int realMid =
+                (mid + shift) % nums.length;
+            if (nums[realMid] == target)
+                return realMid;
+            else if (nums[realMid] < target)
+                beg = mid + 1;
+            else
+                end = mid - 1;
+        }
+        return -1;
+    }
+}

src/in/knowledgegate/dsa/binarysearch/problems/SingleElementInASortedArray.java

@@ -0,0 +1,48 @@
+package in.knowledgegate.dsa.binarysearch.problems;
+
+/**
+ * You are given a sorted array consisting of only
+ * integers where every element appears exactly
+ * twice, except for one element which appears exactly once.
+ *
+ * Return the single element that appears only once.
+ * Your solution must run in O(log n) time and O(1) space.
+ *
+ * Example 1:
+ * Input: nums = [1,1,2,3,3,4,4,8,8]
+ * Output: 2
+ *
+ * Example 2:     0,1,2,3,4 ,5 ,6
+ * Input: nums = [3,3,7,7,10,11,11]
+ * Output: 10
+ *
+ * Constraints:
+ * 1 <= nums.length <= 105
+ * 0 <= nums[i] <= 105
+ */
+public class SingleElementInASortedArray {
+    public static void main(String[] args) {
+        SingleElementInASortedArray finder =
+            new SingleElementInASortedArray();
+        int[] nums = new int[]{3,3,7,7,10,11,11};
+        System.out.println("Duplicate is:"
+            + finder.singleNonDuplicate(nums));
+    }
+
+    public int singleNonDuplicate(int[] nums) {
+        int left = 0, right = nums.length - 1;
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+            if ((mid % 2 == 0 && nums[mid] == nums[mid+1]) ||
+            (mid % 2 == 1 && nums[mid] == nums[mid -1])) {
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        return nums[left];
+    }
+}
+
+
+