Added tasks 2501, 2502

Author: javadev

README.md

@@ -1848,6 +1848,8 @@ implementation 'com.github.javadev:leetcode-in-java:1.19'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2502 |[Design Memory Allocator](src/main/java/g2501_2600/s2502_design_memory_allocator/Allocator.java)| Medium | Array, Hash_Table, Design, Simulation | 9 | 100.00
+| 2501 |[Longest Square Streak in an Array](src/main/java/g2501_2600/s2501_longest_square_streak_in_an_array/Solution.java)| Medium | Array, Hash_Table, Dynamic_Programming, Sorting, Binary_Search | 4 | 99.73
 | 2500 |[Delete Greatest Value in Each Row](src.save/main/java/g2401_2500/s2500_delete_greatest_value_in_each_row/Solution.java)| Easy | Array, Sorting, Matrix | 3 | 98.16
 | 2499 |[Minimum Total Cost to Make Arrays Unequal](src.save/main/java/g2401_2500/s2499_minimum_total_cost_to_make_arrays_unequal/Solution.java)| Hard | Array, Hash_Table, Greedy, Counting | 3 | 100.00
 | 2498 |[Frog Jump II](src.save/main/java/g2401_2500/s2498_frog_jump_ii/Solution.java)| Medium | Array, Greedy, Binary_Search | 1 | 100.00

src/main/java/g2501_2600/s2501_longest_square_streak_in_an_array/Solution.java

@@ -0,0 +1,33 @@
+package g2501_2600.s2501_longest_square_streak_in_an_array;
+
+// #Medium #Array #Hash_Table #Dynamic_Programming #Sorting #Binary_Search
+// #2023_03_19_Time_4_ms_(99.73%)_Space_56_MB_(96.80%)
+
+public class Solution {
+    public int longestSquareStreak(int[] nums) {
+        int result = -1;
+        final int max = 100000;
+        boolean[] isExisted = new boolean[max + 1];
+        boolean[] isVisited = new boolean[max + 1];
+        for (int num : nums) {
+            isExisted[num] = true;
+        }
+        for (int i = 2; i * i <= max; i++) {
+            if (!isExisted[i] || isVisited[i]) {
+                continue;
+            }
+            isVisited[i] = true;
+            int length = 1;
+            int j = i * i;
+            while (j >= 0 && j <= max && isExisted[j]) {
+                isVisited[j] = true;
+                length++;
+                j = j * j;
+            }
+            if (length > 1) {
+                result = Math.max(result, length);
+            }
+        }
+        return result;
+    }
+}

src/main/java/g2501_2600/s2501_longest_square_streak_in_an_array/readme.md

@@ -0,0 +1,41 @@
+2501\. Longest Square Streak in an Array
+
+Medium
+
+You are given an integer array `nums`. A subsequence of `nums` is called a **square streak** if:
+
+*   The length of the subsequence is at least `2`, and
+*   **after** sorting the subsequence, each element (except the first element) is the **square** of the previous number.
+
+Return _the length of the **longest square streak** in_ `nums`_, or return_ `-1` _if there is no **square streak**._
+
+A **subsequence** is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.
+
+**Example 1:**
+
+**Input:** nums = [4,3,6,16,8,2]
+
+**Output:** 3
+
+**Explanation:** Choose the subsequence [4,16,2]. After sorting it, it becomes [2,4,16].
+
+- 4 = 2 \* 2.
+
+- 16 = 4 \* 4.
+
+Therefore, [4,16,2] is a square streak.
+
+It can be shown that every subsequence of length 4 is not a square streak. 
+
+**Example 2:**
+
+**Input:** nums = [2,3,5,6,7]
+
+**Output:** -1
+
+**Explanation:** There is no square streak in nums so return -1. 
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>5</sup></code>
+*   <code>2 <= nums[i] <= 10<sup>5</sup></code>

src/main/java/g2501_2600/s2502_design_memory_allocator/Allocator.java

@@ -0,0 +1,79 @@
+package g2501_2600.s2502_design_memory_allocator;
+
+// #Medium #Array #Hash_Table #Design #Simulation
+// #2023_03_19_Time_9_ms_(100.00%)_Space_43_MB_(66.82%)
+
+public class Allocator {
+    Node root;
+
+    public Allocator(int n) {
+        root = new Node(0, n, -1);
+    }
+
+    public int allocate(int size, int mID) {
+        Node cur = root;
+        while (cur != null && (cur.size < size || cur.id != -1)) {
+            cur = cur.next;
+        }
+        // unable to allocate
+        if (cur == null) {
+            return -1;
+        }
+        if (cur.size == size) {
+            cur.id = mID;
+            return cur.ind;
+        } else {
+            Node n = new Node(cur.ind + size, cur.size - size, -1);
+            n.next = cur.next;
+            cur.next = n;
+            cur.size = size;
+            cur.id = mID;
+            return cur.ind;
+        }
+    }
+
+    public int free(int mID) {
+        return collapse(root, mID);
+    }
+
+    public int collapse(Node cur, int id) {
+        // base case
+        if (cur == null) {
+            return 0;
+        }
+        // include size if matching id
+        int res = cur.id == id ? cur.size : 0;
+        // recurse on child
+        res += collapse(cur.next, id);
+        // unallocate
+        if (cur.id == id) {
+            cur.id = -1;
+        }
+        // collapse unallocated adjacent nodes
+        while (cur.next != null && cur.next.id == -1 && cur.id == -1) {
+            cur.size += cur.next.size;
+            cur.next = cur.next.next;
+        }
+        return res;
+    }
+
+    private static class Node {
+        int ind;
+        Node next;
+        int size;
+        int id;
+
+        public Node(int i, int sz, int mID) {
+            ind = i;
+            size = sz;
+            id = mID;
+        }
+    }
+}
+
+/*
+ * Your Allocator object will be instantiated and called as such:
+ * Allocator obj = new Allocator(n);
+ * int param_1 = obj.allocate(size,mID);
+ * int param_2 = obj.free(mID);
+ */

src/main/java/g2501_2600/s2502_design_memory_allocator/readme.md

@@ -0,0 +1,56 @@
+2502\. Design Memory Allocator
+
+Medium
+
+You are given an integer `n` representing the size of a **0-indexed** memory array. All memory units are initially free.
+
+You have a memory allocator with the following functionalities:
+
+1.  **Allocate** a block of `size` consecutive free memory units and assign it the id `mID`.
+2.  **Free** all memory units with the given id `mID`.
+
+**Note** that:
+
+*   Multiple blocks can be allocated to the same `mID`.
+*   You should free all the memory units with `mID`, even if they were allocated in different blocks.
+
+Implement the `Allocator` class:
+
+*   `Allocator(int n)` Initializes an `Allocator` object with a memory array of size `n`.
+*   `int allocate(int size, int mID)` Find the **leftmost** block of `size` **consecutive** free memory units and allocate it with the id `mID`. Return the block's first index. If such a block does not exist, return `-1`.
+*   `int free(int mID)` Free all memory units with the id `mID`. Return the number of memory units you have freed.
+
+**Example 1:**
+
+**Input** ["Allocator", "allocate", "allocate", "allocate", "free", "allocate", "allocate", "allocate", "free", "allocate", "free"] [[10], [1, 1], [1, 2], [1, 3], [2], [3, 4], [1, 1], [1, 1], [1], [10, 2], [7]]
+
+**Output:** [null, 0, 1, 2, 1, 3, 1, 6, 3, -1, 0]
+
+**Explanation:**
+
+Allocator loc = new Allocator(10); // Initialize a memory array of size 10. All memory units are initially free.
+
+loc.allocate(1, 1); // The leftmost block's first index is 0. The memory array becomes [**1**,\_,\_,\_,\_,\_,\_,\_,\_,\_]. We return 0.
+
+loc.allocate(1, 2); // The leftmost block's first index is 1. The memory array becomes [1,**2**,\_,\_,\_,\_,\_,\_,\_,\_]. We return 1.
+
+loc.allocate(1, 3); // The leftmost block's first index is 2. The memory array becomes [1,2,**3**,\_,\_,\_,\_,\_,\_,\_]. We return 2.
+
+loc.free(2); // Free all memory units with mID 2. The memory array becomes [1,\_, 3,\_,\_,\_,\_,\_,\_,\_]. We return 1 since there is only 1 unit with mID 2.
+
+loc.allocate(3, 4); // The leftmost block's first index is 3. The memory array becomes [1,\_,3,**4**,**4**,**4**,\_,\_,\_,\_]. We return 3.
+
+loc.allocate(1, 1); // The leftmost block's first index is 1. The memory array becomes [1,**1**,3,4,4,4,\_,\_,\_,\_]. We return 1.
+
+loc.allocate(1, 1); // The leftmost block's first index is 6. The memory array becomes [1,1,3,4,4,4,**1**,\_,\_,\_]. We return 6.
+
+loc.free(1); // Free all memory units with mID 1. The memory array becomes [\_,\_,3,4,4,4,\_,\_,\_,\_]. We return 3 since there are 3 units with mID 1.
+
+loc.allocate(10, 2); // We can not find any free block with 10 consecutive free memory units, so we return -1.
+
+loc.free(7); // Free all memory units with mID 7. The memory array remains the same since there is no memory unit with mID 7. We return 0. 
+
+**Constraints:**
+
+*   `1 <= n, size, mID <= 1000`
+*   At most `1000` calls will be made to `allocate` and `free`.

src/test/java/g2501_2600/s2501_longest_square_streak_in_an_array/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2501_2600.s2501_longest_square_streak_in_an_array;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void longestSquareStreak() {
+        assertThat(new Solution().longestSquareStreak(new int[] {4, 3, 6, 16, 8, 2}), equalTo(3));
+    }
+
+    @Test
+    void longestSquareStreak2() {
+        assertThat(new Solution().longestSquareStreak(new int[] {2, 3, 5, 6, 7}), equalTo(-1));
+    }
+}

src/test/java/g2501_2600/s2502_design_memory_allocator/AllocatorTest.java

@@ -0,0 +1,43 @@
+package g2501_2600.s2502_design_memory_allocator;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class AllocatorTest {
+    @Test
+    void allocator() {
+        // Initialize a memory array of size 10. All memory units are initially free.
+        Allocator loc = new Allocator(10);
+        // The leftmost block's first index is 0. The memory array becomes [1,_,_,_,_,_,_,_,_,_]. We
+        // return 0.
+        assertThat(loc.allocate(1, 1), equalTo(0));
+        // The leftmost block's first index is 1. The memory array becomes [1,2,_,_,_,_,_,_,_,_]. We
+        // return 1.
+        assertThat(loc.allocate(1, 2), equalTo(1));
+        // The leftmost block's first index is 2. The memory array becomes [1,2,3,_,_,_,_,_,_,_]. We
+        // return 2.
+        assertThat(loc.allocate(1, 3), equalTo(2));
+        // Free all memory units with mID 2. The memory array becomes [1,_, 3,_,_,_,_,_,_,_]. We
+        // return 1 since there is only 1 unit with mID 2.
+        loc.free(2);
+        // The leftmost block's first index is 3. The memory array becomes [1,_,3,4,4,4,_,_,_,_]. We
+        // return 3.
+        assertThat(loc.allocate(3, 4), equalTo(3));
+        // The leftmost block's first index is 1. The memory array becomes [1,1,3,4,4,4,_,_,_,_]. We
+        // return 1.
+        assertThat(loc.allocate(1, 1), equalTo(1));
+        // The leftmost block's first index is 6. The memory array becomes [1,1,3,4,4,4,1,_,_,_]. We
+        // return 6.
+        assertThat(loc.allocate(1, 1), equalTo(6));
+        // Free all memory units with mID 1. The memory array becomes [_,_,3,4,4,4,_,_,_,_]. We
+        // return 3 since there are 3 units with mID 1.
+        loc.free(1);
+        // We can not find any free block with 10 consecutive free memory units, so we return -1.
+        assertThat(loc.allocate(10, 2), equalTo(-1));
+        // Free all memory units with mID 7. The memory array remains the same since there is no
+        // memory unit with mID 7. We return 0.
+        loc.free(7);
+    }
+}