binary search questions: done

Author: rampatra

src/main/java/com/leetcode/arrays/binarysearch/SearchInsertPosition.java

@@ -0,0 +1,63 @@
+package com.leetcode.arrays.binarysearch;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Level: Easy
+ * Link: https://leetcode.com/problems/search-insert-position/
+ * Description:
+ * Given a sorted array and a target value, return the index if the target is found. If not, return the index where it
+ * would be if it were inserted in order.
+ * <p>
+ * You may assume no duplicates in the array.
+ * <p>
+ * Example 1:
+ * Input: [1,3,5,6], 5
+ * Output: 2
+ * <p>
+ * Example 2:
+ * Input: [1,3,5,6], 2
+ * Output: 1
+ * <p>
+ * Example 3:
+ * Input: [1,3,5,6], 7
+ * Output: 4
+ * <p>
+ * Example 4:
+ * Input: [1,3,5,6], 0
+ * Output: 0
+ *
+ * Similar question: {@link SmallestLetterGreaterThanTarget}.
+ *
+ * @author rampatra
+ * @since 2019-08-19
+ */
+public class SearchInsertPosition {
+
+    /**
+     * Runtime: <a href="https://leetcode.com/submissions/detail/253066747/">0 ms</a>.
+     *
+     * @param nums
+     * @param target
+     * @return
+     */
+    public static int searchInsert(int[] nums, int target) {
+        int low = 0;
+        int high = nums.length - 1;
+        while (low <= high) {
+            int mid = low + (high - low) / 2;
+            if (nums[mid] == target) {
+                return mid;
+            } else if (nums[mid] < target) {
+                low = mid + 1;
+            } else {
+                high = mid - 1;
+            }
+        }
+        return low;
+    }
+
+    public static void main(String[] args) {
+        assertEquals(2, searchInsert(new int[]{1, 2}, 3));
+    }
+}

src/main/java/com/leetcode/arrays/binarysearch/SmallestLetterGreaterThanTarget.java

@@ -0,0 +1,87 @@
+package com.leetcode.arrays.binarysearch;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Level: Easy
+ * Link: https://leetcode.com/problems/find-smallest-letter-greater-than-target/
+ * Description:
+ * Given a list of sorted characters letters containing only lowercase letters, and given a target letter target, find
+ * the smallest element in the list that is larger than the given target.
+ *
+ * Letters also wrap around. For example, if the target is target = 'z' and letters = ['a', 'b'], the answer is 'a'.
+ *
+ * Examples:
+ *
+ * Input:
+ * letters = ["c", "f", "j"]
+ * target = "a"
+ * Output: "c"
+ *
+ * Input:
+ * letters = ["c", "f", "j"]
+ * target = "c"
+ * Output: "f"
+ *
+ * Input:
+ * letters = ["c", "f", "j"]
+ * target = "d"
+ * Output: "f"
+ *
+ * Input:
+ * letters = ["c", "f", "j"]
+ * target = "g"
+ * Output: "j"
+ *
+ * Input:
+ * letters = ["c", "f", "j"]
+ * target = "j"
+ * Output: "c"
+ *
+ * Input:
+ * letters = ["c", "f", "j"]
+ * target = "k"
+ * Output: "c"
+ *
+ * Note:
+ * - letters has a length in range [2, 10000].
+ * - letters consists of lowercase letters, and contains at least 2 unique letters.
+ * - target is a lowercase letter.
+ *
+ * @author rampatra
+ * @since 2019-08-19
+ */
+public class SmallestLetterGreaterThanTarget {
+
+    /**
+     * Runtime: <a href="https://leetcode.com/submissions/detail/253061487/">0 ms</a>.
+     *
+     * @param letters
+     * @param target
+     * @return
+     */
+    public static char nextGreatestLetter(char[] letters, char target) {
+        int low = 0, hi = letters.length - 1;
+        while (low <= hi) {
+            int mid = low + (hi - low) / 2;
+            if (letters[mid] <= target) {
+                low = mid + 1;
+            } else {
+                hi = mid - 1;
+            }
+        }
+        return letters[low % letters.length];
+    }
+
+    public static void main(String[] args) {
+        assertEquals('a', nextGreatestLetter(new char[]{'a'}, 'z'));
+        assertEquals('b', nextGreatestLetter(new char[]{'a', 'b'}, 'a'));
+        assertEquals('b', nextGreatestLetter(new char[]{'a', 'b', 'c'}, 'a'));
+        assertEquals('a', nextGreatestLetter(new char[]{'a', 'b', 'c'}, 'z'));
+        assertEquals('c', nextGreatestLetter(new char[]{'c', 'f', 'j'}, 'a'));
+        assertEquals('f', nextGreatestLetter(new char[]{'c', 'f', 'j'}, 'c'));
+        assertEquals('f', nextGreatestLetter(new char[]{'c', 'f', 'j'}, 'd'));
+        assertEquals('b', nextGreatestLetter(new char[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j', 'k', 'l',
+                'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'}, 'a'));
+    }
+}