Merge pull request #12 from borrelunde/problem_0436_find_right_interval

LeetCode problem: 436. Find Right Interval

Author: borrelunde

src/main/java/com/borrelunde/leetcodesolutions/problem0436/findrightinterval/README.md

@@ -0,0 +1,46 @@
+# 436. Find Right Interval
+
+Difficulty: `Medium`  
+Topics: `Array`, `Binary Search`, `Sorting`
+
+You are given an array of `intervals`, where `intervals[i] = [start_i, end_i]` and each `start_i` is **unique**.
+
+The **right interval** for an interval `i` is an interval `j` such that `start_j >= end_i` and `start_j` is
+**minimized**. Note that `i` may equal `j`.
+
+Return *an array of **right interval** indices for each interval `i`*. If no **right interval** exists for interval `i`,
+then put `-1` at index `i`.
+
+**Example 1:**
+
+```text
+Input: intervals = [[1,2]]
+Output: [-1]
+Explanation: There is only one interval in the collection, so it outputs -1.
+```
+
+**Example 2:**
+
+```text
+Input: intervals = [[3,4],[2,3],[1,2]]
+Output: [-1,0,1]
+Explanation: There is no right interval for [3,4].
+The right interval for [2,3] is [3,4] since start_0 = 3 is the smallest start that is >= end_1 = 3.
+The right interval for [1,2] is [2,3] since start_1 = 2 is the smallest start that is >= end_2 = 2.
+```
+
+**Example 3:**
+
+```text
+Input: intervals = [[1,4],[2,3],[3,4]]
+Output: [-1,2,-1]
+Explanation: There is no right interval for [1,4] and [3,4].
+The right interval for [2,3] is [3,4] since start_2 = 3 is the smallest start that is >= end_1 = 3.
+```
+
+**Constraints:**
+
+- `1 <= intervals.length <= 2 * 10^4`
+- `intervals[i].length == 2`
+- `-10^6 <= start_i <= end_i <= 10^6`
+- The start point of each interval is **unique**.

src/main/java/com/borrelunde/leetcodesolutions/problem0436/findrightinterval/Solution.java

@@ -0,0 +1,126 @@
+package com.borrelunde.leetcodesolutions.problem0436.findrightinterval;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * This is the solution to the LeetCode problem: 436. Find Right Interval
+ *
+ * @author Børre A. Opedal Lunde
+ * @since 2024.02.09
+ */
+public class Solution {
+
+	private static final int INVALID_INDEX = - 1;
+
+	public int[] findRightInterval(int[][] intervals) {
+
+		// Map to store the start value and index of each interval.
+		Map<Integer, Integer> intervalStartValueByIndex = new HashMap<>();
+		for (int i = 0; i < intervals.length; i++) {
+			intervalStartValueByIndex.put(intervals[i][0], i);
+		}
+
+		// Sort the intervals so that a binary search can be used on it.
+		sort(intervals);
+
+		// The array to store the right interval indices.
+		int[] result = new int[intervals.length];
+
+		// Find the right interval for each interval.
+		for (int[] interval : intervals) {
+			int intervalIndex = intervalStartValueByIndex.get(interval[0]);
+			int rightIntervalIndex = binarySearch(intervals, interval[1]);
+			result[intervalIndex] = rightIntervalIndex == INVALID_INDEX
+					? INVALID_INDEX
+					: intervalStartValueByIndex.get(intervals[rightIntervalIndex][0]);
+		}
+
+		// Return the right interval indices array.
+		return result;
+	}
+
+	private static int binarySearch(int[][] intervals, int target) {
+
+		int low = 0;
+		int high = intervals.length - 1;
+
+		while (low <= high) {
+			// Calculate the middle index of the array. Bitwise shift to the
+			// right is the same as dividing by 2, but faster.
+			int middle = low + ((high - low) >> 1);
+
+			if (intervals[middle][0] >= target) {
+				high = middle - 1;
+			} else {
+				low = middle + 1;
+			}
+		}
+
+		// After the loop, low is the smallest index of the interval whose start
+		// value is greater than or equal to the target. However, we need to
+		// check if it is within the bounds of the array. If it is not, then
+		// the target was not found.
+
+		return low < intervals.length ? low : INVALID_INDEX;
+	}
+
+	private static void sort(int[][] matrix) {
+
+		// A temporary matrix is used in the sorting algorithm to store sorted
+		// elements before it is copied to the original matrix.
+		int[][] tempMatrix = new int[matrix.length][2];
+
+		// Start the recursive merge-sorting process.
+		mergeSort(matrix, tempMatrix, 0, matrix.length - 1);
+	}
+
+	private static void mergeSort(int[][] matrix, int[][] tempMatrix, int low, int high) {
+
+		// If the matrix has 0 or 1 elements, it's already sorted.
+		if (low >= high) {
+			return;  // Break out of recursion.
+		}
+
+		// Calculate the middle index of the array. Bitwise shift to the right
+		// is the same as dividing by 2, but faster.
+		int middle = low + ((high - low) >> 1);
+		mergeSort(matrix, tempMatrix, low, middle);  // Sort the left half.
+		mergeSort(matrix, tempMatrix, middle + 1, high);  // Sort the right half.
+		merge(matrix, tempMatrix, low, middle, high);  // Merge the two sorted halves.
+	}
+
+	private static void merge(int[][] matrix, int[][] tempMatrix, int low, int middle, int high) {
+
+		// Indices for left and right halves, and the temporary helper matrix.
+		int left = low;
+		int right = middle + 1;
+		int temp = 0;
+
+		// Merge left and right halves into the temporary matrix.
+		while (left <= middle && right <= high) {
+			if (matrix[left][0] <= matrix[right][0]) {
+				tempMatrix[temp++] = matrix[left++];
+			} else {
+				tempMatrix[temp++] = matrix[right++];
+			}
+		}
+
+		// If there are remaining elements in the left half, copy them into the
+		// temporary matrix.
+		while (left <= middle) {
+			tempMatrix[temp++] = matrix[left++];
+		}
+
+		// The same goes for the right half.
+		while (right <= high) {
+			tempMatrix[temp++] = matrix[right++];
+		}
+
+		// Finally, copy the sorted elements from the temporary matrix to the
+		// original matrix.
+		for (int i = 0; i < temp; i++) {
+			matrix[low + i] = tempMatrix[i];
+		}
+	}
+}

src/test/java/com/borrelunde/leetcodesolutions/problem0436/findrightinterval/SolutionTest.java

@@ -0,0 +1,127 @@
+package com.borrelunde.leetcodesolutions.problem0436.findrightinterval;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+/**
+ * This is the test to the LeetCode problem: 463. Find Right Interval
+ *
+ * @author Børre A. Opedal Lunde
+ * @since 2024.02.09
+ */
+@DisplayName("Find Right Interval")
+class SolutionTest {
+
+	private final Solution solution = new Solution();
+
+	@Test
+	@DisplayName("Example one")
+	void exampleOne() {
+		int[][] intervals = new int[][]{
+				{1, 2}
+		};
+
+		int[] expected = new int[]{- 1};
+		int[] actual = solution.findRightInterval(intervals);
+
+		assertArrayEquals(expected, actual);
+	}
+
+	@Test
+	@DisplayName("Example two")
+	void exampleTwo() {
+		int[][] intervals = new int[][]{
+				{3, 4},
+				{2, 3},
+				{1, 2}
+		};
+
+		int[] expected = new int[]{- 1, 0, 1};
+		int[] actual = solution.findRightInterval(intervals);
+
+		assertArrayEquals(expected, actual);
+	}
+
+	@Test
+	@DisplayName("Example three")
+	void exampleThree() {
+		int[][] intervals = new int[][]{
+				{1, 4},
+				{2, 3},
+				{3, 4}
+		};
+
+		int[] expected = new int[]{- 1, 2, - 1};
+		int[] actual = solution.findRightInterval(intervals);
+
+		assertArrayEquals(expected, actual);
+	}
+
+	@Test
+	@DisplayName("Empty matrix")
+	void emptyMatrix() {
+		int[][] intervals = new int[][]{
+				// Empty.
+		};
+
+		int[] expected = new int[]{};
+		int[] actual = solution.findRightInterval(intervals);
+
+		assertArrayEquals(expected, actual);
+	}
+
+	@Test
+	@DisplayName("Large interval that encompasses others")
+	void largeIntervalEncompassesOthers() {
+		int[][] intervals = {
+				{1, 100},
+				{2, 3},
+				{4, 5},
+				{6, 7}
+		};
+		int[] expected = {- 1, 2, 3, - 1};
+		int[] actual = solution.findRightInterval(intervals);
+		assertArrayEquals(expected, actual);
+	}
+
+	@Test
+	@DisplayName("Non-overlapping, consecutive intervals")
+	void nonOverlappingConsecutiveIntervals() {
+		int[][] intervals = {
+				{1, 2},
+				{2, 3},
+				{3, 4}
+		};
+		int[] expected = {1, 2, - 1};
+		int[] actual = solution.findRightInterval(intervals);
+		assertArrayEquals(expected, actual);
+	}
+
+	@Test
+	@DisplayName("Reverse ordered intervals")
+	void reverseOrderedIntervals() {
+		int[][] intervals = {
+				{3, 4},
+				{2, 3},
+				{1, 2}
+		};
+		int[] expected = {- 1, 0, 1};
+		int[] actual = solution.findRightInterval(intervals);
+		assertArrayEquals(expected, actual);
+	}
+
+	@Test
+	@DisplayName("Intervals with large numbers")
+	void intervalsWithLargeNumbers() {
+		int[][] intervals = {
+				{1000000, 2000000},
+				{2000000, 3000000},
+				{3000000, 4000000}
+		};
+		int[] expected = {1, 2, - 1};
+		int[] actual = solution.findRightInterval(intervals);
+		assertArrayEquals(expected, actual);
+	}
+}