Bitonic Array Maximum

Author: manastalukdar

.vscode/settings.json

@@ -19,6 +19,7 @@
     "Bigtable",
     "Bitmask",
     "Bitmasking",
+    "Bitonic",
     "Bloomberg",
     "Blum",
     "Buschmann",

src/EducativeIo/Courses/GrokkingTheCodingInterview/Ch12_ModifiedBinarySearch/P7_BitonicArrayMaximum/Java/Solution.java

@@ -0,0 +1,25 @@
+package EducativeIo.Courses.GrokkingTheCodingInterview.Ch12_ModifiedBinarySearch.P7_BitonicArrayMaximum.Java;
+
+public class Solution {
+    public static void main(String[] args) {
+        System.out.println(findMax(new int[] {1, 3, 8, 12, 4, 2}));
+        System.out.println(findMax(new int[] {3, 8, 3, 1}));
+        System.out.println(findMax(new int[] {1, 3, 8, 12}));
+        System.out.println(findMax(new int[] {10, 9, 8}));
+    }
+
+    public static int findMax(int[] arr) {
+        int start = 0, end = arr.length - 1;
+        while (start < end) {
+            int mid = start + (end - start) / 2;
+            if (arr[mid] > arr[mid + 1]) {
+                end = mid;
+            } else {
+                start = mid + 1;
+            }
+        }
+
+        // at the end of the while loop, 'start == end'
+        return arr[start];
+    }
+}

src/EducativeIo/Courses/GrokkingTheCodingInterview/Ch12_ModifiedBinarySearch/P7_BitonicArrayMaximum/Java/SolutionTest.java

@@ -0,0 +1,71 @@
+package EducativeIo.Courses.GrokkingTheCodingInterview.Ch12_ModifiedBinarySearch.P7_BitonicArrayMaximum.Java;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.time.Duration;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+
+public class SolutionTest {
+
+    Solution solution;
+
+    @BeforeEach
+    public void setUp() throws Exception {
+        solution = new Solution();
+    }
+
+    @AfterEach
+    public void tearDown() throws Exception {
+        solution = null;
+    }
+
+    @Test
+    public void MainFunction() {
+        assertTimeout(Duration.ofMillis(500), () -> {
+            String[] args = new String[0];
+            assertAll(() -> Solution.main(args));
+        });
+    }
+
+    @Test
+    public void TrivialCase1() {
+        int[] arr = new int[] {1, 3, 8, 12, 4, 2};
+        assertTimeout(Duration.ofMillis(500), () -> {
+            int expected = 12;
+            int actual = Solution.findMax(arr);
+            assertEquals(expected, actual);
+        });
+    }
+
+    @Test
+    public void TrivialCase2() {
+        int[] arr = new int[] {3, 8, 3, 1};
+        assertTimeout(Duration.ofMillis(500), () -> {
+            int expected = 8;
+            int actual = Solution.findMax(arr);
+            assertEquals(expected, actual);
+        });
+    }
+
+    @Test
+    public void TrivialCase3() {
+        int[] arr = new int[] {1, 3, 8, 12};
+        assertTimeout(Duration.ofMillis(500), () -> {
+            int expected = 12;
+            int actual = Solution.findMax(arr);
+            assertEquals(expected, actual);
+        });
+    }
+
+    @Test
+    public void TrivialCase4() {
+        int[] arr = new int[] {10, 9, 8};
+        assertTimeout(Duration.ofMillis(500), () -> {
+            int expected = 10;
+            int actual = Solution.findMax(arr);
+            assertEquals(expected, actual);
+        });
+    }
+}

src/EducativeIo/Courses/GrokkingTheCodingInterview/Ch12_ModifiedBinarySearch/P7_BitonicArrayMaximum/metadata.json

@@ -0,0 +1,33 @@
+{
+    "type": "Coding",
+    "name": "Bitonic Array Maximum",
+    "origin": {
+        "name": "Educative",
+        "link": "https://www.educative.io/courses/grokking-the-coding-interview/RMyRR6wZoYK"
+    },
+    "companies": ["", ""],
+    "categories": [{
+            "name": "Courses",
+            "children": [{
+                "name": "Grokking the Coding Interview: Patterns for Coding Questions",
+                "children": []
+            }]
+        },
+        {
+            "name": "Difficulty",
+            "children": [{
+                "name": "Easy",
+                "children": []
+            }]
+        },
+        {
+            "name": "Pattern",
+            "children": [{
+                "name": "Modified Binary Search",
+                "children": []
+            }]
+        }
+    ],
+    "tags": ["Modified Binary Search"],
+    "buckets": []
+}

src/EducativeIo/Courses/GrokkingTheCodingInterview/Ch12_ModifiedBinarySearch/P7_BitonicArrayMaximum/readme.md

@@ -0,0 +1,55 @@
+# Problem Definition
+
+## Description
+
+Find the maximum value in a given Bitonic array. An array is considered bitonic if it is monotonically increasing and then monotonically decreasing. Monotonically increasing or decreasing means that for any index `i` in the array `arr[i] != arr[i+1]`.
+
+Example 1:
+
+```plaintext
+Input: [1, 3, 8, 12, 4, 2]
+Output: 12
+Explanation: The maximum number in the input bitonic array is '12'.
+```
+
+Example 2:
+
+```plaintext
+Input: [3, 8, 3, 1]
+Output: 8
+```
+
+Example 3:
+
+```plaintext
+Input: [1, 3, 8, 12]
+Output: 12
+```
+
+Example 4:
+
+```plaintext
+Input: [10, 9, 8]
+Output: 10
+```
+
+## Discussion
+
+A bitonic array is a sorted array; the only difference is that its first part is sorted in ascending order and the second part is sorted in descending order. We can use a similar approach as discussed in **Order-agnostic Binary Search**. Since no two consecutive numbers are same (as the array is monotonically increasing or decreasing), whenever we calculate the `middle`, we can compare the numbers pointed out by the index `middle` and `middle+1` to find if we are in the ascending or the descending part. So:
+
+1. If `arr[middle] > arr[middle + 1]`, we are in the second (descending) part of the bitonic array. Therefore, our required number could either be pointed out by `middle` or will be before `middle`. This means we will be doing: `end = middle`.
+2. If `arr[middle] <= arr[middle + 1]`, we are in the first (ascending) part of the bitonic array. Therefore, the required number will be after `middle`. This means we will be doing: `start = middle + 1`.
+
+We can break when `start == end`. Due to the two points mentioned above, both `start` and `end` will be pointing at the maximum number of the bitonic array.
+
+### Time Complexity
+
+Since we are reducing the search range by half at every step, this means that the time complexity of our algorithm will be O(logN) where ‘N’ is the total elements in the given array.
+
+### Space Complexity
+
+The algorithm runs in constant space O(1).
+
+## Notes
+
+## References