Leetcode 1394 : Find Lucky Integer

Author: kshitizsaini113

src/main/java/array/lucky_integer/FrequencyArray.java

@@ -0,0 +1,55 @@
+package array.lucky_integer;
+
+/**
+ * Solves the "Find Lucky Integer" problem using a highly optimized frequency array.
+ *
+ * <p>This approach leverages the problem's constraint that all numbers are within a
+ * small, positive range (1 to 500). It uses a simple array as a direct-access
+ * frequency map, which is significantly more performant and memory-efficient than
+ * using a {@code HashMap} or {@code TreeMap} for this specific scenario.
+ */
+public class FrequencyArray {
+
+    /**
+     * Finds the largest lucky integer using a frequency array.
+     *
+     * <p>The logic iterates backwards from the maximum possible value. The first
+     * lucky number encountered is guaranteed to be the largest, allowing for an
+     * early exit.
+     *
+     * <p><b>Complexity:</b>
+     * <ul>
+     *   <li>Time: O(N + M), where N is the length of {@code arr} and M is the
+     *       maximum possible value (500). This is effectively O(N).
+     *   <li>Space: O(M), which is constant space O(1) as M is fixed.
+     * </ul>
+     *
+     * @param arr The input array of integers.
+     * @return The largest lucky integer in the array, or -1 if none exists.
+     */
+    public int findLucky(int[] arr) {
+        // Per the constraints, arr[i] is between 1 and 500.
+        // We create an array of size 501 to use indices 1 through 500.
+        int[] frequencies = new int[501];
+
+        // First pass: count the frequency of each number.
+        // This is an O(N) operation.
+        for (int num : arr) {
+            // We can safely do this because of the constraint 1 <= num <= 500.
+            frequencies[num]++;
+        }
+
+        // Second pass: check for a lucky number, starting from the largest possible.
+        // This is an O(M) operation.
+        for (int i = 500; i >= 1; i--) {
+            // If the number (i) is equal to its frequency (frequencies[i])...
+            if (frequencies[i] == i) {
+                // ...we've found the largest lucky number, so we can return immediately.
+                return i;
+            }
+        }
+
+        // If the loop completes, no lucky number was found.
+        return -1;
+    }
+}

src/main/java/array/lucky_integer/FrequencyMap.java

@@ -9,6 +9,8 @@
  * <p>This approach first iterates through the array to build a frequency map of all
  * numbers, then iterates through the map to find the largest number whose value
  * matches its frequency.
+ *
+ * @see FrequencyArray Frequency Array for the optimal approach.
  */
 public class FrequencyMap {
 

src/main/java/array/lucky_integer/FrequencyTreeMap.java

@@ -0,0 +1,64 @@
+package array.lucky_integer;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.TreeMap;
+
+/**
+ * Solves the "Find Lucky Integer" problem using a {@link TreeMap}.
+ *
+ * <p>This implementation leverages a {@code TreeMap} with a reverse order comparator
+ * to store number frequencies. By sorting the numbers in descending order, the search
+ * for the lucky integer can be optimized: the first lucky number found during iteration
+ * is guaranteed to be the largest one, allowing for an early exit.
+ *
+ * <p>While this approach is a valid general-purpose solution, it is not the most
+ * performant for this problem's specific constraints (numbers 1-500), where a
+ * simple frequency array would be faster.
+ *
+ * @see FrequencyArray Frequency Array for the optimal approach.
+ */
+public class FrequencyTreeMap {
+
+    /**
+     * Finds the largest lucky integer using a TreeMap for automatic sorting.
+     *
+     * <p>This approach uses a {@link TreeMap} with a reverse order comparator.
+     * This keeps the keys sorted from largest to smallest. When iterating, the
+     * first lucky number found is guaranteed to be the largest, simplifying the logic.
+     *
+     * <p><b>Complexity:</b>
+     * <ul>
+     *   <li>Time: O(N * log U), where N is the number of elements and U is the
+     *       number of unique elements. Each {@code put} operation in a TreeMap
+     *       is O(log U).
+     *   <li>Space: O(U), to store the unique elements in the map.
+     * </ul>
+     *
+     * @param arr The input array of integers.
+     * @return The largest lucky integer in the array, or -1 if none exists.
+     */
+    public int findLucky(int[] arr) {
+        // Step 1: Create a frequency map that sorts keys in descending order.
+        Map<Integer, Integer> freqMap = new TreeMap<>(Collections.reverseOrder());
+
+        // Build the frequency map. Each `put` takes O(log U) time.
+        for (int num : arr) {
+            freqMap.put(num, freqMap.getOrDefault(num, 0) + 1);
+        }
+
+        // Step 2: Find the first lucky integer.
+        // Because the map is sorted from largest to smallest, the first match
+        // we find is guaranteed to be the largest lucky number.
+        for (Map.Entry<Integer, Integer> entry : freqMap.entrySet()) {
+            // If the number (key) equals its frequency (value)...
+            if (entry.getKey().equals(entry.getValue())) {
+                // ...we've found our answer.
+                return entry.getKey();
+            }
+        }
+
+        // If the loop completes, no lucky number was found.
+        return -1;
+    }
+}

src/main/java/array/lucky_integer/package-info.java

@@ -18,8 +18,24 @@
  *   <li>{@code 1 <= arr[i] <= 500}</li>
  * </ul>
  *
- * @version 1.0
+ * <h3>Implementation Approaches:</h3>
+ *
+ * <p>This package provides multiple solutions, each demonstrating different trade-offs:
+ * <ul>
+ *   <li><b>{@link array.lucky_integer.FrequencyArray FrequencyArray}</b>: The most optimal
+ *       solution given the problem's constraints. It uses a simple {@code int[]} as a
+ *       direct-access frequency map, offering O(N) time and O(1) space complexity.</li>
+ *   <li><b>{@link array.lucky_integer.FrequencyMap FrequencyMap} (using HashMap)</b>: A flexible,
+ *       general-purpose solution that works for any range of input numbers. It provides
+ *       O(N) time complexity but has higher memory overhead than the array approach.</li>
+ *   <li><b>{@link array.lucky_integer.FrequencyTreeMap FrequencyTreeMap}</b>: An approach that uses a
+ *       sorted map ({@code TreeMap}) to simplify finding the largest lucky number. The
+ *       first lucky number found is guaranteed to be the answer, at the cost of a
+ *       slightly higher O(N * log U) time complexity.</li>
+ * </ul>
+ *
  * @see <a href="https://leetcode.com/problems/find-lucky-integer-in-an-array/">LeetCode 1394: Find Lucky Integer in an Array</a>
- * @since 1.0
+ * @since 2.0
+ * @version 1.0
  */
 package array.lucky_integer;

src/test/java/array/lucky_integer/FrequencyArrayTest.java

@@ -0,0 +1,97 @@
+package array.lucky_integer;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Test suite for the {@link FrequencyArray} class.
+ *
+ * <p>This suite validates the correctness of the frequency array approach for finding
+ * the largest lucky integer, covering various scenarios and edge cases.
+ */
+class FrequencyArrayTest {
+
+    private FrequencyArray frequencyArray;
+
+    @BeforeEach
+    void setUp() {
+        frequencyArray = new FrequencyArray();
+    }
+
+    @Test
+    @DisplayName("Should return the largest lucky integer when multiple exist")
+    void findLucky_whenMultipleLuckyIntegersExist_shouldReturnLargest() {
+        int[] arr = {1, 2, 2, 3, 3, 3};
+        assertEquals(3, frequencyArray.findLucky(arr), "The largest lucky integer is 3, as 1 and 3 are both lucky.");
+    }
+
+    @Test
+    @DisplayName("Should return a single lucky integer when one exists")
+    void findLucky_whenOneLuckyIntegerExists_shouldReturnIt() {
+        int[] arr = {2, 2, 3, 4};
+        assertEquals(2, frequencyArray.findLucky(arr), "The only lucky integer is 2.");
+    }
+
+    @Test
+    @DisplayName("Should return -1 when no lucky integer exists")
+    void findLucky_whenNoLuckyIntegerExists_shouldReturnMinusOne() {
+        int[] arr = {1, 2, 2, 3, 3, 2, 1};
+        assertEquals(-1, frequencyArray.findLucky(arr), "No number has a frequency equal to its value.");
+    }
+
+    @Test
+    @DisplayName("Should return -1 for an empty array")
+    void findLucky_whenArrayIsEmpty_shouldReturnMinusOne() {
+        int[] arr = {};
+        assertEquals(-1, frequencyArray.findLucky(arr), "An empty array has no lucky integers.");
+    }
+
+    @Test
+    @DisplayName("Should handle an array where all elements are the same and form a lucky number")
+    void findLucky_whenAllElementsAreSameAndLucky_shouldReturnTheNumber() {
+        int[] arr = {4, 4, 4, 4};
+        assertEquals(4, frequencyArray.findLucky(arr), "4 appears 4 times, so it is lucky.");
+    }
+
+    @Test
+    @DisplayName("Should handle an array where all elements are the same but not lucky")
+    void findLucky_whenAllElementsAreSameAndNotLucky_shouldReturnMinusOne() {
+        int[] arr = {5, 5, 5};
+        assertEquals(-1, frequencyArray.findLucky(arr), "5 appears 3 times, so it is not lucky.");
+    }
+
+    @Test
+    @DisplayName("Should handle a single element array that is lucky")
+    void findLucky_whenSingleElementIsLucky_shouldReturnTheNumber() {
+        int[] arr = {1};
+        assertEquals(1, frequencyArray.findLucky(arr), "1 appears 1 time, so it is lucky.");
+    }
+
+    @Test
+    @DisplayName("Should handle a single element array that is not lucky")
+    void findLucky_whenSingleElementIsNotLucky_shouldReturnMinusOne() {
+        int[] arr = {2};
+        assertEquals(-1, frequencyArray.findLucky(arr), "2 appears 1 time, so it is not lucky.");
+    }
+
+    @Test
+    @DisplayName("Should handle a complex case with various numbers")
+    void findLucky_withComplexArray_shouldReturnCorrectLargestLucky() {
+        int[] arr = {7, 7, 7, 7, 7, 7, 7, 5, 5, 5, 5, 5, 2, 2, 8, 9};
+        assertEquals(7, frequencyArray.findLucky(arr), "Both 5 and 7 are lucky, but 7 is the largest.");
+    }
+
+    @Test
+    @DisplayName("Should handle the maximum constraint value being lucky")
+    void findLucky_withMaximumValueAsLuckyNumber_shouldReturnIt() {
+        // Create an array with 500 instances of the number 500.
+        int[] arr = new int[500];
+        for (int i = 0; i < 500; i++) {
+            arr[i] = 500;
+        }
+        assertEquals(500, frequencyArray.findLucky(arr), "500 appears 500 times and should be a valid lucky number.");
+    }
+}

src/test/java/array/lucky_integer/FrequencyTreeMapTest.java

@@ -0,0 +1,97 @@
+package array.lucky_integer;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Test suite for the {@link FrequencyArray} class.
+ *
+ * <p>This suite validates the correctness of the frequency array approach for finding
+ * the largest lucky integer, covering various scenarios and edge cases.
+ */
+class FrequencyTreeMapTest {
+
+    private FrequencyTreeMap frequencyTreeMap;
+
+    @BeforeEach
+    void setUp() {
+        frequencyTreeMap = new FrequencyTreeMap();
+    }
+
+    @Test
+    @DisplayName("Should return the largest lucky integer when multiple exist")
+    void findLucky_whenMultipleLuckyIntegersExist_shouldReturnLargest() {
+        int[] arr = {1, 2, 2, 3, 3, 3};
+        assertEquals(3, frequencyTreeMap.findLucky(arr), "The largest lucky integer is 3, as 1 and 3 are both lucky.");
+    }
+
+    @Test
+    @DisplayName("Should return a single lucky integer when one exists")
+    void findLucky_whenOneLuckyIntegerExists_shouldReturnIt() {
+        int[] arr = {2, 2, 3, 4};
+        assertEquals(2, frequencyTreeMap.findLucky(arr), "The only lucky integer is 2.");
+    }
+
+    @Test
+    @DisplayName("Should return -1 when no lucky integer exists")
+    void findLucky_whenNoLuckyIntegerExists_shouldReturnMinusOne() {
+        int[] arr = {1, 2, 2, 3, 3, 2, 1};
+        assertEquals(-1, frequencyTreeMap.findLucky(arr), "No number has a frequency equal to its value.");
+    }
+
+    @Test
+    @DisplayName("Should return -1 for an empty array")
+    void findLucky_whenArrayIsEmpty_shouldReturnMinusOne() {
+        int[] arr = {};
+        assertEquals(-1, frequencyTreeMap.findLucky(arr), "An empty array has no lucky integers.");
+    }
+
+    @Test
+    @DisplayName("Should handle an array where all elements are the same and form a lucky number")
+    void findLucky_whenAllElementsAreSameAndLucky_shouldReturnTheNumber() {
+        int[] arr = {4, 4, 4, 4};
+        assertEquals(4, frequencyTreeMap.findLucky(arr), "4 appears 4 times, so it is lucky.");
+    }
+
+    @Test
+    @DisplayName("Should handle an array where all elements are the same but not lucky")
+    void findLucky_whenAllElementsAreSameAndNotLucky_shouldReturnMinusOne() {
+        int[] arr = {5, 5, 5};
+        assertEquals(-1, frequencyTreeMap.findLucky(arr), "5 appears 3 times, so it is not lucky.");
+    }
+
+    @Test
+    @DisplayName("Should handle a single element array that is lucky")
+    void findLucky_whenSingleElementIsLucky_shouldReturnTheNumber() {
+        int[] arr = {1};
+        assertEquals(1, frequencyTreeMap.findLucky(arr), "1 appears 1 time, so it is lucky.");
+    }
+
+    @Test
+    @DisplayName("Should handle a single element array that is not lucky")
+    void findLucky_whenSingleElementIsNotLucky_shouldReturnMinusOne() {
+        int[] arr = {2};
+        assertEquals(-1, frequencyTreeMap.findLucky(arr), "2 appears 1 time, so it is not lucky.");
+    }
+
+    @Test
+    @DisplayName("Should handle a complex case with various numbers")
+    void findLucky_withComplexArray_shouldReturnCorrectLargestLucky() {
+        int[] arr = {7, 7, 7, 7, 7, 7, 7, 5, 5, 5, 5, 5, 2, 2, 8, 9};
+        assertEquals(7, frequencyTreeMap.findLucky(arr), "Both 5 and 7 are lucky, but 7 is the largest.");
+    }
+
+    @Test
+    @DisplayName("Should handle the maximum constraint value being lucky")
+    void findLucky_withMaximumValueAsLuckyNumber_shouldReturnIt() {
+        // Create an array with 500 instances of the number 500.
+        int[] arr = new int[500];
+        for (int i = 0; i < 500; i++) {
+            arr[i] = 500;
+        }
+        assertEquals(500, frequencyTreeMap.findLucky(arr), "500 appears 500 times and should be a valid lucky number.");
+    }
+}