Added task 3824

Author: javadev

src/main/java/g3801_3900/s3824_minimum_k_to_reduce_array_within_limit/Solution.java

@@ -0,0 +1,37 @@
+package g3801_3900.s3824_minimum_k_to_reduce_array_within_limit;
+
+// #Medium #Array #Binary_Search #Staff #Biweekly_Contest_175
+// #2026_06_09_Time_16_ms_(100.00%)_Space_130.89_MB_(86.74%)
+
+public class Solution {
+    public int minimumK(int[] nums) {
+        int n = nums.length;
+        int mx = 0;
+        for (int x : nums) {
+            mx = Math.max(mx, x);
+        }
+        long total = 0;
+        for (int x : nums) {
+            total += x;
+        }
+        int left = Math.max((int) Math.ceil(Math.sqrt(n)), (int) Math.ceil(Math.cbrt(total))) - 1;
+        int right = (int) Math.ceil(Math.sqrt(nonPositive(nums, left + 1)));
+        while (left + 1 < right) {
+            int k = (left + right) / 2;
+            if (nonPositive(nums, k) <= (long) k * k) {
+                right = k;
+            } else {
+                left = k;
+            }
+        }
+        return left + 1;
+    }
+
+    private long nonPositive(int[] nums, int k) {
+        long sum = nums.length;
+        for (int x : nums) {
+            sum += (x - 1) / k;
+        }
+        return sum;
+    }
+}

src/main/java/g3801_3900/s3824_minimum_k_to_reduce_array_within_limit/readme.md

@@ -0,0 +1,40 @@
+3824\. Minimum K to Reduce Array Within Limit
+
+Medium
+
+You are given a **positive** integer array `nums`.
+
+For a positive integer `k`, define `nonPositive(nums, k)` as the **minimum** number of **operations** needed to make every element of `nums` **non-positive**. In one operation, you can choose an index `i` and reduce `nums[i]` by `k`.
+
+Return an integer denoting the **minimum** value of `k` such that <code>nonPositive(nums, k) <= k<sup>2</sup></code>.
+
+**Example 1:**
+
+**Input:** nums = [3,7,5]
+
+**Output:** 3
+
+**Explanation:**
+
+When `k = 3`, <code>nonPositive(nums, k) = 6 <= k<sup>2</sup></code>.
+
+*   Reduce `nums[0] = 3` one time. `nums[0]` becomes `3 - 3 = 0`.
+*   Reduce `nums[1] = 7` three times. `nums[1]` becomes `7 - 3 - 3 - 3 = -2`.
+*   Reduce `nums[2] = 5` two times. `nums[2]` becomes `5 - 3 - 3 = -1`.
+
+**Example 2:**
+
+**Input:** nums = [1]
+
+**Output:** 1
+
+**Explanation:**
+
+When `k = 1`, <code>nonPositive(nums, k) = 1 <= k<sup>2</sup></code>.
+
+*   Reduce `nums[0] = 1` one time. `nums[0]` becomes `1 - 1 = 0`.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>5</sup></code>

src/test/java/g3801_3900/s3824_minimum_k_to_reduce_array_within_limit/SolutionTest.java

@@ -0,0 +1,113 @@
+package g3801_3900.s3824_minimum_k_to_reduce_array_within_limit;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minimumK() {
+        assertThat(new Solution().minimumK(new int[] {3, 7, 5}), equalTo(3));
+    }
+
+    @Test
+    void minimumK2() {
+        assertThat(new Solution().minimumK(new int[] {1}), equalTo(1));
+    }
+
+    @Test
+    void minimumK3() {
+        // Single element of value 10: ceil(10/k) <= k => k >= 4 (since 10/4=3 ceil 3, +1 length=4
+        // <= 16)
+        // Actually: nonPositive = 1 + ceil((10-1)/k+? ); test with simple expected
+        assertThat(new Solution().minimumK(new int[] {10}), equalTo(3));
+    }
+
+    @Test
+    void minimumK4() {
+        // Array of all ones: sum = n, each (1-1)/k = 0, so nonPositive = n. Need n <= k*k
+        // n=4 -> k>=2
+        assertThat(new Solution().minimumK(new int[] {1, 1, 1, 1}), equalTo(2));
+    }
+
+    @Test
+    void minimumK5() {
+        // n=9, need k*k >= 9, k>=3
+        assertThat(new Solution().minimumK(new int[] {1, 1, 1, 1, 1, 1, 1, 1, 1}), equalTo(3));
+    }
+
+    @Test
+    void minimumK6() {
+        assertThat(new Solution().minimumK(new int[] {1, 1}), equalTo(2));
+    }
+
+    @Test
+    void minimumK7() {
+        // Two elements of 1000000
+        // n=2, need: 2 + 2*ceil(999999/k) <= k*k
+        // k=126: 2 + 2*ceil(999999/126)=2+2*7937=15876, k*k=15876 -> exactly equal
+        assertThat(new Solution().minimumK(new int[] {1000000, 1000000}), equalTo(126));
+    }
+
+    @Test
+    void minimumK8() {
+        assertThat(new Solution().minimumK(new int[] {2, 3, 4, 5}), equalTo(3));
+    }
+
+    @Test
+    void minimumK9() {
+        assertThat(new Solution().minimumK(new int[] {5, 5, 5}), equalTo(3));
+    }
+
+    @Test
+    void minimumK10() {
+        int[] nums = new int[100];
+        for (int i = 0; i < 100; i++) {
+            nums[i] = 1;
+        }
+        // n=100, need k*k >= 100, k>=10
+        assertThat(new Solution().minimumK(nums), equalTo(10));
+    }
+
+    @Test
+    void minimumK11() {
+        int[] nums = new int[50];
+        for (int i = 0; i < 50; i++) {
+            nums[i] = i + 1;
+        }
+        assertThat(new Solution().minimumK(nums), equalTo(12));
+    }
+
+    @Test
+    void minimumK12() {
+        // n=1, val=2: nonPositive=1+ceil(1/k). Need <= k*k. k=2: 1+1=2 <=4 yes. k=1: 1+1=2 <=1? No
+        assertThat(new Solution().minimumK(new int[] {2}), equalTo(2));
+    }
+
+    @Test
+    void minimumK13() {
+        assertThat(new Solution().minimumK(new int[] {100, 200, 300, 400, 500}), equalTo(12));
+    }
+
+    @Test
+    void minimumK14() {
+        // single element with max int-like value
+        int[] nums = {1000000};
+        // need 1 + ceil(999999/k) <= k*k
+        // k=100: 1 + 10000 = 10001, k*k=10000 -> no
+        // k=101: 1 + ceil(999999/101)=1+9901=9902, k*k=10201 -> yes
+        assertThat(new Solution().minimumK(nums), equalTo(100));
+    }
+
+    @Test
+    void minimumK15() {
+        // n=3, need k*k >= 3, k>=2
+        assertThat(new Solution().minimumK(new int[] {1, 1, 1}), equalTo(2));
+    }
+
+    @Test
+    void minimumK16() {
+        assertThat(new Solution().minimumK(new int[] {1, 2}), equalTo(2));
+    }
+}