Minimize Maximum Partition Sum

Author: rvguradiya

problems/arrays/minimize_max_partition_sum.md

@@ -0,0 +1,5 @@
+This problem was asked by **Etsy**.
+
+Given an array of numbers N and an integer k, your task is to split N into k partitions such that the maximum sum of any partition is minimized. Return this sum.
+
+For example, given N = [5, 1, 2, 7, 3, 4] and k = 3, you should return 8, since the optimal partition is [5, 1, 2], [7], [3, 4].

solutions/arrays/minimize_max_partition_sum/Approach1.java

@@ -0,0 +1,61 @@
+public class Approach1 {
+
+    public static void main(String[] args) {
+        int[] N = {5, 1, 2, 7, 3, 4};
+        int k = 3;
+        System.out.println(minimizeMaxPartitionSum(N, k));  // Output: 8
+    }
+
+    public static int minimizeMaxPartitionSum(int[] N, int k) {
+        int left = findMax(N);
+        int right = sumArray(N);
+
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+            if (canPartition(N, k, mid)) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+
+        return left;
+    }
+
+    private static int findMax(int[] N) {
+        int max = Integer.MIN_VALUE;
+        for (int num : N) {
+            if (num > max) {
+                max = num;
+            }
+        }
+        return max;
+    }
+
+    private static int sumArray(int[] N) {
+        int sum = 0;
+        for (int num : N) {
+            sum += num;
+        }
+        return sum;
+    }
+
+    private static boolean canPartition(int[] N, int k, int maxSum) {
+        int currentSum = 0;
+        int requiredPartitions = 1;
+
+        for (int num : N) {
+            if (currentSum + num > maxSum) {
+                requiredPartitions++;
+                currentSum = num;
+                if (requiredPartitions > k) {
+                    return false;
+                }
+            } else {
+                currentSum += num;
+            }
+        }
+
+        return true;
+    }
+}

solutions/arrays/minimize_max_partition_sum/approach1.js

@@ -0,0 +1,38 @@
+function minimizeMaxPartitionSum(N, k) {
+  let left = Array.max(N);
+  let right = Array.sum(N);
+
+  while (left < right) {
+    let mid = left + Math.floor((right - left) / 2);
+    if (canPartition(N, k, mid)) {
+      right = mid;
+    } else {
+      left = mid + 1;
+    }
+  }
+
+  return left;
+}
+
+function canPartition(N, k, maxSum) {
+  let currentSum = 0;
+  let requiredPartitions = 1;
+
+  for (let num of N) {
+    if (currentSum + num > maxSum) {
+      requiredPartitions++;
+      currentSum = num;
+      if (requiredPartitions > k) {
+        return false;
+      }
+    } else {
+      currentSum += num;
+    }
+  }
+
+  return true;
+}
+
+let N = [5, 1, 2, 7, 3, 4];
+let k = 3;
+console.log(minimizeMaxPartitionSum(N, k));