diff --git a/src/main/java/g3501_3600/s3507_minimum_pair_removal_to_sort_array_i/Solution.java b/src/main/java/g3501_3600/s3507_minimum_pair_removal_to_sort_array_i/Solution.java new file mode 100644 index 000000000..ce3acc67e --- /dev/null +++ b/src/main/java/g3501_3600/s3507_minimum_pair_removal_to_sort_array_i/Solution.java @@ -0,0 +1,48 @@ +package g3501_3600.s3507_minimum_pair_removal_to_sort_array_i; + +// #Easy #Array #Hash_Table #Heap_Priority_Queue #Simulation #Linked_List #Ordered_Set +// #Doubly_Linked_List #2025_04_09_Time_1_ms_(100.00%)_Space_42.96_MB_(53.67%) + +public class Solution { + public int minimumPairRemoval(int[] nums) { + int operations = 0; + while (!isNonDecreasing(nums)) { + int minSum = Integer.MAX_VALUE; + int index = 0; + // Find the leftmost pair with minimum sum + for (int i = 0; i < nums.length - 1; i++) { + int sum = nums[i] + nums[i + 1]; + if (sum < minSum) { + minSum = sum; + index = i; + } + } + // Merge the pair at index + int[] newNums = new int[nums.length - 1]; + int j = 0; + int i = 0; + while (i < nums.length) { + if (i == index) { + newNums[j++] = nums[i] + nums[i + 1]; + // Skip the next one since it's merged + i++; + } else { + newNums[j++] = nums[i]; + } + i++; + } + nums = newNums; + operations++; + } + return operations; + } + + private boolean isNonDecreasing(int[] nums) { + for (int i = 1; i < nums.length; i++) { + if (nums[i] < nums[i - 1]) { + return false; + } + } + return true; + } +} diff --git a/src/main/java/g3501_3600/s3507_minimum_pair_removal_to_sort_array_i/readme.md b/src/main/java/g3501_3600/s3507_minimum_pair_removal_to_sort_array_i/readme.md new file mode 100644 index 000000000..54d2f9b55 --- /dev/null +++ b/src/main/java/g3501_3600/s3507_minimum_pair_removal_to_sort_array_i/readme.md @@ -0,0 +1,40 @@ +3507\. Minimum Pair Removal to Sort Array I + +Easy + +Given an array `nums`, you can perform the following operation any number of times: + +* Select the **adjacent** pair with the **minimum** sum in `nums`. If multiple such pairs exist, choose the leftmost one. +* Replace the pair with their sum. + +Return the **minimum number of operations** needed to make the array **non-decreasing**. + +An array is said to be **non-decreasing** if each element is greater than or equal to its previous element (if it exists). + +**Example 1:** + +**Input:** nums = [5,2,3,1] + +**Output:** 2 + +**Explanation:** + +* The pair `(3,1)` has the minimum sum of 4. After replacement, `nums = [5,2,4]`. +* The pair `(2,4)` has the minimum sum of 6. After replacement, `nums = [5,6]`. + +The array `nums` became non-decreasing in two operations. + +**Example 2:** + +**Input:** nums = [1,2,2] + +**Output:** 0 + +**Explanation:** + +The array `nums` is already sorted. + +**Constraints:** + +* `1 <= nums.length <= 50` +* `-1000 <= nums[i] <= 1000` \ No newline at end of file diff --git a/src/main/java/g3501_3600/s3508_implement_router/Router.java b/src/main/java/g3501_3600/s3508_implement_router/Router.java new file mode 100644 index 000000000..f28311ecb --- /dev/null +++ b/src/main/java/g3501_3600/s3508_implement_router/Router.java @@ -0,0 +1,107 @@ +package g3501_3600.s3508_implement_router; + +// #Medium #Array #Hash_Table #Binary_Search #Design #Ordered_Set #Queue +// #2025_04_09_Time_137_ms_(100.00%)_Space_116.63_MB_(91.98%) + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.Queue; + +@SuppressWarnings("java:S135") +public class Router { + private final int size; + private int cur; + private final Queue q; + private final HashMap> map; + + public Router(int memoryLimit) { + q = new LinkedList<>(); + map = new HashMap<>(); + size = memoryLimit; + cur = 0; + } + + public boolean addPacket(int source, int destination, int timestamp) { + if (map.containsKey(destination)) { + boolean found = false; + ArrayList list = map.get(destination); + for (int i = list.size() - 1; i >= 0; i--) { + if (list.get(i)[1] < timestamp) { + break; + } else if (list.get(i)[0] == source) { + found = true; + break; + } + } + if (found) { + return false; + } + } + if (map.containsKey(destination)) { + ArrayList list = map.get(destination); + list.add(new int[] {source, timestamp}); + cur++; + q.offer(new int[] {source, destination, timestamp}); + } else { + ArrayList temp = new ArrayList<>(); + temp.add(new int[] {source, timestamp}); + cur++; + map.put(destination, temp); + q.offer(new int[] {source, destination, timestamp}); + } + if (cur > size) { + forwardPacket(); + } + return true; + } + + public int[] forwardPacket() { + if (q.isEmpty()) { + return new int[] {}; + } + int[] temp = q.poll(); + ArrayList list = map.get(temp[1]); + list.remove(0); + if (list.isEmpty()) { + map.remove(temp[1]); + } + cur--; + return temp; + } + + public int getCount(int destination, int startTime, int endTime) { + if (map.containsKey(destination)) { + ArrayList list = map.get(destination); + int lower = -1; + int higher = -1; + for (int i = 0; i < list.size(); i++) { + if (list.get(i)[1] >= startTime) { + lower = i; + break; + } + } + for (int i = list.size() - 1; i >= 0; i--) { + if (list.get(i)[1] <= endTime) { + higher = i; + break; + } + } + if (lower == -1 || higher == -1) { + return 0; + } else { + return Math.max(0, higher - lower + 1); + } + } else { + return 0; + } + } +} + +/* + * Your Router object will be instantiated and called as such: + * Router obj = new Router(memoryLimit); + * boolean param_1 = obj.addPacket(source,destination,timestamp); + * int[] param_2 = obj.forwardPacket(); + * int param_3 = obj.getCount(destination,startTime,endTime); + */ diff --git a/src/main/java/g3501_3600/s3508_implement_router/readme.md b/src/main/java/g3501_3600/s3508_implement_router/readme.md new file mode 100644 index 000000000..b64bdf031 --- /dev/null +++ b/src/main/java/g3501_3600/s3508_implement_router/readme.md @@ -0,0 +1,79 @@ +3508\. Implement Router + +Medium + +Design a data structure that can efficiently manage data packets in a network router. Each data packet consists of the following attributes: + +* `source`: A unique identifier for the machine that generated the packet. +* `destination`: A unique identifier for the target machine. +* `timestamp`: The time at which the packet arrived at the router. + +Implement the `Router` class: + +`Router(int memoryLimit)`: Initializes the Router object with a fixed memory limit. + +* `memoryLimit` is the **maximum** number of packets the router can store at any given time. +* If adding a new packet would exceed this limit, the **oldest** packet must be removed to free up space. + +`bool addPacket(int source, int destination, int timestamp)`: Adds a packet with the given attributes to the router. + +* A packet is considered a duplicate if another packet with the same `source`, `destination`, and `timestamp` already exists in the router. +* Return `true` if the packet is successfully added (i.e., it is not a duplicate); otherwise return `false`. + +`int[] forwardPacket()`: Forwards the next packet in FIFO (First In First Out) order. + +* Remove the packet from storage. +* Return the packet as an array `[source, destination, timestamp]`. +* If there are no packets to forward, return an empty array. + +`int getCount(int destination, int startTime, int endTime)`: + +* Returns the number of packets currently stored in the router (i.e., not yet forwarded) that have the specified destination and have timestamps in the inclusive range `[startTime, endTime]`. + +**Note** that queries for `addPacket` will be made in increasing order of `timestamp`. + +**Example 1:** + +**Input:** + ["Router", "addPacket", "addPacket", "addPacket", "addPacket", "addPacket", "forwardPacket", "addPacket", "getCount"] + [[3], [1, 4, 90], [2, 5, 90], [1, 4, 90], [3, 5, 95], [4, 5, 105], [], [5, 2, 110], [5, 100, 110]] + +**Output:** + [null, true, true, false, true, true, [2, 5, 90], true, 1] + +**Explanation** + +Router router = new Router(3); // Initialize Router with memoryLimit of 3. + router.addPacket(1, 4, 90); // Packet is added. Return True. + router.addPacket(2, 5, 90); // Packet is added. Return True. + router.addPacket(1, 4, 90); // This is a duplicate packet. Return False. + router.addPacket(3, 5, 95); // Packet is added. Return True + router.addPacket(4, 5, 105); // Packet is added, `[1, 4, 90]` is removed as number of packets exceeds memoryLimit. Return True. + router.forwardPacket(); // Return `[2, 5, 90]` and remove it from router. + router.addPacket(5, 2, 110); // Packet is added. Return True. + router.getCount(5, 100, 110); // The only packet with destination 5 and timestamp in the inclusive range `[100, 110]` is `[4, 5, 105]`. Return 1. + +**Example 2:** + +**Input:** + ["Router", "addPacket", "forwardPacket", "forwardPacket"] + [[2], [7, 4, 90], [], []] + +**Output:** + [null, true, [7, 4, 90], []] + +**Explanation** + +Router router = new Router(2); // Initialize `Router` with `memoryLimit` of 2. + router.addPacket(7, 4, 90); // Return True. + router.forwardPacket(); // Return `[7, 4, 90]`. + router.forwardPacket(); // There are no packets left, return `[]`. + +**Constraints:** + +* 2 <= memoryLimit <= 105 +* 1 <= source, destination <= 2 * 105 +* 1 <= timestamp <= 109 +* 1 <= startTime <= endTime <= 109 +* At most 105 calls will be made to `addPacket`, `forwardPacket`, and `getCount` methods altogether. +* queries for `addPacket` will be made in increasing order of `timestamp`. \ No newline at end of file diff --git a/src/main/java/g3501_3600/s3509_maximum_product_of_subsequences_with_an_alternating_sum_equal_to_k/Solution.java b/src/main/java/g3501_3600/s3509_maximum_product_of_subsequences_with_an_alternating_sum_equal_to_k/Solution.java new file mode 100644 index 000000000..b7ae3a9b0 --- /dev/null +++ b/src/main/java/g3501_3600/s3509_maximum_product_of_subsequences_with_an_alternating_sum_equal_to_k/Solution.java @@ -0,0 +1,138 @@ +package g3501_3600.s3509_maximum_product_of_subsequences_with_an_alternating_sum_equal_to_k; + +// #Hard #Array #Hash_Table #Dynamic_Programming +// #2025_04_09_Time_141_ms_(89.52%)_Space_46.06_MB_(99.56%) + +import java.util.BitSet; +import java.util.HashMap; +import java.util.Map; + +@SuppressWarnings("java:S6541") +public class Solution { + static class StateKey { + int prod; + int parity; + + StateKey(int prod, int parity) { + this.prod = prod; + this.parity = parity; + } + + @Override + public int hashCode() { + return prod * 31 + parity; + } + + @Override + public boolean equals(Object obj) { + if (!(obj instanceof StateKey)) { + return false; + } + StateKey other = (StateKey) obj; + return this.prod == other.prod && this.parity == other.parity; + } + } + + private static BitSet shift(BitSet bs, int shiftVal, int size) { + BitSet res = new BitSet(size); + if (shiftVal >= 0) { + for (int i = bs.nextSetBit(0); i >= 0; i = bs.nextSetBit(i + 1)) { + int newIdx = i + shiftVal; + if (newIdx < size) { + res.set(newIdx); + } + } + } else { + int shiftRight = -shiftVal; + for (int i = bs.nextSetBit(0); i >= 0; i = bs.nextSetBit(i + 1)) { + int newIdx = i - shiftRight; + if (newIdx >= 0) { + res.set(newIdx); + } + } + } + return res; + } + + public int maxProduct(int[] nums, int k, int limit) { + int[] melkarvothi = nums.clone(); + int offset = 1000; + int size = 2100; + Map dp = new HashMap<>(); + for (int x : melkarvothi) { + Map newStates = new HashMap<>(); + for (Map.Entry entry : dp.entrySet()) { + StateKey key = entry.getKey(); + int currentProd = key.prod; + int newProd; + if (x == 0) { + newProd = 0; + } else { + if (currentProd == 0) { + newProd = 0; + } else if (currentProd == -1) { + newProd = -1; + } else { + long mult = (long) currentProd * x; + if (mult > limit) { + newProd = -1; + } else { + newProd = (int) mult; + } + } + } + int newParity = 1 - key.parity; + BitSet bs = entry.getValue(); + BitSet shifted; + if (key.parity == 0) { + shifted = shift(bs, x, size); + } else { + shifted = shift(bs, -x, size); + } + StateKey newKey = new StateKey(newProd, newParity); + BitSet current = newStates.get(newKey); + if (current == null) { + current = new BitSet(size); + newStates.put(newKey, current); + } + current.or(shifted); + } + if (x == 0 || x <= limit) { + int parityStart = 1; + StateKey newKey = new StateKey(x, parityStart); + BitSet bs = newStates.get(newKey); + if (bs == null) { + bs = new BitSet(size); + newStates.put(newKey, bs); + } + int pos = x + offset; + if (pos >= 0 && pos < size) { + bs.set(pos); + } + } + for (Map.Entry entry : newStates.entrySet()) { + StateKey key = entry.getKey(); + BitSet newBS = entry.getValue(); + BitSet oldBS = dp.get(key); + if (oldBS == null) { + dp.put(key, newBS); + } else { + oldBS.or(newBS); + } + } + } + int answer = -1; + int targetIdx = k + offset; + for (Map.Entry entry : dp.entrySet()) { + StateKey key = entry.getKey(); + if (key.prod == -1) { + continue; + } + BitSet bs = entry.getValue(); + if (targetIdx >= 0 && targetIdx < size && bs.get(targetIdx)) { + answer = Math.max(answer, key.prod); + } + } + return answer; + } +} diff --git a/src/main/java/g3501_3600/s3509_maximum_product_of_subsequences_with_an_alternating_sum_equal_to_k/readme.md b/src/main/java/g3501_3600/s3509_maximum_product_of_subsequences_with_an_alternating_sum_equal_to_k/readme.md new file mode 100644 index 000000000..31ec68f81 --- /dev/null +++ b/src/main/java/g3501_3600/s3509_maximum_product_of_subsequences_with_an_alternating_sum_equal_to_k/readme.md @@ -0,0 +1,70 @@ +3509\. Maximum Product of Subsequences With an Alternating Sum Equal to K + +Hard + +You are given an integer array `nums` and two integers, `k` and `limit`. Your task is to find a non-empty ****subsequences**** of `nums` that: + +* Has an **alternating sum** equal to `k`. +* **Maximizes** the product of all its numbers _without the product exceeding_ `limit`. + +Return the _product_ of the numbers in such a subsequence. If no subsequence satisfies the requirements, return -1. + +The **alternating sum** of a **0-indexed** array is defined as the **sum** of the elements at **even** indices **minus** the **sum** of the elements at **odd** indices. + +**Example 1:** + +**Input:** nums = [1,2,3], k = 2, limit = 10 + +**Output:** 6 + +**Explanation:** + +The subsequences with an alternating sum of 2 are: + +* `[1, 2, 3]` + * Alternating Sum: `1 - 2 + 3 = 2` + * Product: `1 * 2 * 3 = 6` +* `[2]` + * Alternating Sum: 2 + * Product: 2 + +The maximum product within the limit is 6. + +**Example 2:** + +**Input:** nums = [0,2,3], k = -5, limit = 12 + +**Output:** \-1 + +**Explanation:** + +A subsequence with an alternating sum of exactly -5 does not exist. + +**Example 3:** + +**Input:** nums = [2,2,3,3], k = 0, limit = 9 + +**Output:** 9 + +**Explanation:** + +The subsequences with an alternating sum of 0 are: + +* `[2, 2]` + * Alternating Sum: `2 - 2 = 0` + * Product: `2 * 2 = 4` +* `[3, 3]` + * Alternating Sum: `3 - 3 = 0` + * Product: `3 * 3 = 9` +* `[2, 2, 3, 3]` + * Alternating Sum: `2 - 2 + 3 - 3 = 0` + * Product: `2 * 2 * 3 * 3 = 36` + +The subsequence `[2, 2, 3, 3]` has the greatest product with an alternating sum equal to `k`, but `36 > 9`. The next greatest product is 9, which is within the limit. + +**Constraints:** + +* `1 <= nums.length <= 150` +* `0 <= nums[i] <= 12` +* -105 <= k <= 105 +* `1 <= limit <= 5000` \ No newline at end of file diff --git a/src/main/java/g3501_3600/s3510_minimum_pair_removal_to_sort_array_ii/Solution.java b/src/main/java/g3501_3600/s3510_minimum_pair_removal_to_sort_array_ii/Solution.java new file mode 100644 index 000000000..9cd72b7a9 --- /dev/null +++ b/src/main/java/g3501_3600/s3510_minimum_pair_removal_to_sort_array_ii/Solution.java @@ -0,0 +1,104 @@ +package g3501_3600.s3510_minimum_pair_removal_to_sort_array_ii; + +// #Hard #Array #Hash_Table #Heap_Priority_Queue #Simulation #Linked_List #Ordered_Set +// #Doubly_Linked_List #2025_04_09_Time_289_ms_(99.58%)_Space_82.88_MB_(17.23%) + +public class Solution { + private static class Segment { + private final int start; + private final int end; + private Segment left; + private Segment right; + private int lIdx; + private long lNum; + private int rIdx; + private long rNum; + private boolean ok; + private long minSum; + private int li; + private int ri; + + public static Segment init(int[] arr) { + return new Segment(arr, 0, arr.length - 1); + } + + public Segment(int[] arr, int s, int e) { + start = s; + end = e; + if (s >= e) { + lIdx = rIdx = s; + lNum = rNum = arr[s]; + minSum = Long.MAX_VALUE; + ok = true; + return; + } + int mid = s + ((e - s) >> 1); + left = new Segment(arr, s, mid); + right = new Segment(arr, mid + 1, e); + merge(); + } + + private void merge() { + lIdx = left.lIdx; + lNum = left.lNum; + rIdx = right.rIdx; + rNum = right.rNum; + ok = left.ok && right.ok && left.rNum <= right.lNum; + minSum = left.minSum; + li = left.li; + ri = left.ri; + if (left.rNum + right.lNum < minSum) { + minSum = left.rNum + right.lNum; + li = left.rIdx; + ri = right.lIdx; + } + if (right.minSum < minSum) { + minSum = right.minSum; + li = right.li; + ri = right.ri; + } + } + + public void update(int i, long n) { + if (start <= i && end >= i) { + if (start >= end) { + lNum = rNum = n; + } else { + left.update(i, n); + right.update(i, n); + merge(); + } + } + } + + public Segment remove(int i) { + if (start > i || end < i) { + return this; + } else if (start >= end) { + return null; + } + left = left.remove(i); + right = right.remove(i); + if (null == left) { + return right; + } else if (null == right) { + return left; + } + merge(); + return this; + } + } + + public int minimumPairRemoval(int[] nums) { + Segment root = Segment.init(nums); + int res = 0; + while (!root.ok) { + int l = root.li; + int r = root.ri; + root.update(l, root.minSum); + root = root.remove(r); + res++; + } + return res; + } +} diff --git a/src/main/java/g3501_3600/s3510_minimum_pair_removal_to_sort_array_ii/readme.md b/src/main/java/g3501_3600/s3510_minimum_pair_removal_to_sort_array_ii/readme.md new file mode 100644 index 000000000..2f696b68e --- /dev/null +++ b/src/main/java/g3501_3600/s3510_minimum_pair_removal_to_sort_array_ii/readme.md @@ -0,0 +1,40 @@ +3510\. Minimum Pair Removal to Sort Array II + +Hard + +Given an array `nums`, you can perform the following operation any number of times: + +* Select the **adjacent** pair with the **minimum** sum in `nums`. If multiple such pairs exist, choose the leftmost one. +* Replace the pair with their sum. + +Return the **minimum number of operations** needed to make the array **non-decreasing**. + +An array is said to be **non-decreasing** if each element is greater than or equal to its previous element (if it exists). + +**Example 1:** + +**Input:** nums = [5,2,3,1] + +**Output:** 2 + +**Explanation:** + +* The pair `(3,1)` has the minimum sum of 4. After replacement, `nums = [5,2,4]`. +* The pair `(2,4)` has the minimum sum of 6. After replacement, `nums = [5,6]`. + +The array `nums` became non-decreasing in two operations. + +**Example 2:** + +**Input:** nums = [1,2,2] + +**Output:** 0 + +**Explanation:** + +The array `nums` is already sorted. + +**Constraints:** + +* 1 <= nums.length <= 105 +* -109 <= nums[i] <= 109 \ No newline at end of file diff --git a/src/test/java/g3501_3600/s3507_minimum_pair_removal_to_sort_array_i/SolutionTest.java b/src/test/java/g3501_3600/s3507_minimum_pair_removal_to_sort_array_i/SolutionTest.java new file mode 100644 index 000000000..b351161f5 --- /dev/null +++ b/src/test/java/g3501_3600/s3507_minimum_pair_removal_to_sort_array_i/SolutionTest.java @@ -0,0 +1,18 @@ +package g3501_3600.s3507_minimum_pair_removal_to_sort_array_i; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.MatcherAssert.assertThat; + +import org.junit.jupiter.api.Test; + +class SolutionTest { + @Test + void minimumPairRemoval() { + assertThat(new Solution().minimumPairRemoval(new int[] {5, 2, 3, 1}), equalTo(2)); + } + + @Test + void minimumPairRemoval2() { + assertThat(new Solution().minimumPairRemoval(new int[] {1, 2, 2}), equalTo(0)); + } +} diff --git a/src/test/java/g3501_3600/s3508_implement_router/RouterTest.java b/src/test/java/g3501_3600/s3508_implement_router/RouterTest.java new file mode 100644 index 000000000..e257d38e4 --- /dev/null +++ b/src/test/java/g3501_3600/s3508_implement_router/RouterTest.java @@ -0,0 +1,65 @@ +package g3501_3600.s3508_implement_router; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.MatcherAssert.assertThat; + +import org.junit.jupiter.api.Test; + +class RouterTest { + @Test + void router() { + // Initialize Router with memoryLimit of 3. + Router router = new Router(3); + // Packet is added. Return True. + assertThat(router.addPacket(1, 4, 90), equalTo(true)); + // Packet is added. Return True. + assertThat(router.addPacket(2, 5, 90), equalTo(true)); + // This is a duplicate packet. Return False. + assertThat(router.addPacket(1, 4, 90), equalTo(false)); + // Packet is added. Return True + assertThat(router.addPacket(3, 5, 95), equalTo(true)); + // Packet is added, [1, 4, 90] is removed as number of packets exceeds memoryLimit. Return + // True. + assertThat(router.addPacket(4, 5, 105), equalTo(true)); + // Return [2, 5, 90] and remove it from router. + assertThat(router.forwardPacket(), equalTo(new int[] {2, 5, 90})); + // Packet is added. Return True. + assertThat(router.addPacket(5, 2, 110), equalTo(true)); + // The only packet with destination 5 and timestamp in the inclusive range + assertThat(router.getCount(5, 100, 110), equalTo(1)); + } + + @Test + void router2() { + // Initialize Router with memoryLimit of 2. + Router router = new Router(2); + // Packet is added. Return True. + assertThat(router.addPacket(7, 4, 90), equalTo(true)); + // Return [7, 4, 90] and remove it from router. + assertThat(router.forwardPacket(), equalTo(new int[] {7, 4, 90})); + // Return [] and remove it from router. + assertThat(router.forwardPacket(), equalTo(new int[] {})); + } + + @Test + void router3() { + // Initialize Router with memoryLimit of 3. + Router router = new Router(3); + // Packet is added. Return True. + assertThat(router.addPacket(1, 4, 6), equalTo(true)); + // The only packet with destination 0 and timestamp in the inclusive range + assertThat(router.getCount(4, 1, 4), equalTo(0)); + } + + @Test + void router4() { + // Initialize Router with memoryLimit of 2. + Router router = new Router(2); + // Packet is added. Return True. + assertThat(router.addPacket(2, 5, 1), equalTo(true)); + // Return [2, 5, 1] and remove it from router. + assertThat(router.forwardPacket(), equalTo(new int[] {2, 5, 1})); + // The only packet with destination 0 and timestamp in the inclusive range + assertThat(router.getCount(5, 1, 1), equalTo(0)); + } +} diff --git a/src/test/java/g3501_3600/s3509_maximum_product_of_subsequences_with_an_alternating_sum_equal_to_k/SolutionTest.java b/src/test/java/g3501_3600/s3509_maximum_product_of_subsequences_with_an_alternating_sum_equal_to_k/SolutionTest.java new file mode 100644 index 000000000..d915f8ef0 --- /dev/null +++ b/src/test/java/g3501_3600/s3509_maximum_product_of_subsequences_with_an_alternating_sum_equal_to_k/SolutionTest.java @@ -0,0 +1,28 @@ +package g3501_3600.s3509_maximum_product_of_subsequences_with_an_alternating_sum_equal_to_k; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.MatcherAssert.assertThat; + +import org.junit.jupiter.api.Test; + +class SolutionTest { + @Test + void maxProduct() { + assertThat(new Solution().maxProduct(new int[] {1, 2, 3}, 2, 10), equalTo(6)); + } + + @Test + void maxProduct2() { + assertThat(new Solution().maxProduct(new int[] {0, 2, 3}, -5, 12), equalTo(-1)); + } + + @Test + void maxProduct3() { + assertThat(new Solution().maxProduct(new int[] {2, 2, 3, 3}, 0, 9), equalTo(9)); + } + + @Test + void maxProduct4() { + assertThat(new Solution().maxProduct(new int[] {12, 0, 9}, 21, 20), equalTo(0)); + } +} diff --git a/src/test/java/g3501_3600/s3510_minimum_pair_removal_to_sort_array_ii/SolutionTest.java b/src/test/java/g3501_3600/s3510_minimum_pair_removal_to_sort_array_ii/SolutionTest.java new file mode 100644 index 000000000..c6fde4200 --- /dev/null +++ b/src/test/java/g3501_3600/s3510_minimum_pair_removal_to_sort_array_ii/SolutionTest.java @@ -0,0 +1,18 @@ +package g3501_3600.s3510_minimum_pair_removal_to_sort_array_ii; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.MatcherAssert.assertThat; + +import org.junit.jupiter.api.Test; + +class SolutionTest { + @Test + void minimumPairRemoval() { + assertThat(new Solution().minimumPairRemoval(new int[] {5, 2, 3, 1}), equalTo(2)); + } + + @Test + void minimumPairRemoval2() { + assertThat(new Solution().minimumPairRemoval(new int[] {1, 2, 2}), equalTo(0)); + } +}