add 1300

fishercoder1534 · fishercoder1534 · commit 7f5990afe370 · 2019-12-28T10:20:50.000-08:00
diff --git a/README.md b/README.md
@@ -9,6 +9,7 @@ _If you like this project, please leave me a star._ &#9733;
 |  #  |      Title     |   Solutions   | Video  | Difficulty  | Tag                   
 |-----|----------------|---------------|--------|-------------|-------------
 |1302|[Deepest Leaves Sum](https://leetcode.com/problems/deepest-leaves-sum/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1302.java) | |Medium||
+|1300|[Sum of Mutated Array Closest to Target](https://leetcode.com/problems/sum-of-mutated-array-closest-to-target/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1300.java) | |Medium||
 |1299|[Replace Elements with Greatest Element on Right Side](https://leetcode.com/problems/replace-elements-with-greatest-element-on-right-side/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1299.java) | |Easy||
 |1297|[Maximum Number of Occurrences of a Substring](https://leetcode.com/problems/maximum-number-of-occurrences-of-a-substring/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1297.java) | |Medium||
 |1296|[Divide Array in Sets of K Consecutive Numbers](https://leetcode.com/problems/divide-array-in-sets-of-k-consecutive-numbers/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1296.java) | |Medium||
diff --git a/src/main/java/com/fishercoder/solutions/_1300.java b/src/main/java/com/fishercoder/solutions/_1300.java
@@ -0,0 +1,87 @@
+package com.fishercoder.solutions;
+
+/**
+ * 1300. Sum of Mutated Array Closest to Target
+ *
+ * Given an integer array arr and a target value target, return the integer value such that when we change all the integers larger than value in the given array to be equal to value,
+ * the sum of the array gets as close as possible (in absolute difference) to target.
+ * In case of a tie, return the minimum such integer.
+ * Notice that the answer is not neccesarilly a number from arr.
+ *
+ * Example 1:
+ * Input: arr = [4,9,3], target = 10
+ * Output: 3
+ * Explanation: When using 3 arr converts to [3, 3, 3] which sums 9 and that's the optimal answer.
+ *
+ * Example 2:
+ * Input: arr = [2,3,5], target = 10
+ * Output: 5
+ *
+ * Example 3:
+ * Input: arr = [60864,25176,27249,21296,20204], target = 56803
+ * Output: 11361
+ * */
+public class _1300 {
+    public static class Solution1 {
+        public int findBestValue(int[] arr, int target) {
+            int ave = target / arr.length;
+            int min = findMin(arr);
+            int max = findMax(arr);
+            //if ave is the best value, what's the difference to target?
+            int closetDiff = findClosestDiffIfReplaceWithVal(arr, ave, target);
+            int bestValue = ave;
+            //extend candidate towards the right to see how close the sum could be to target
+            int candidateOnTheRight = ave;
+            while (candidateOnTheRight <= max) {
+                int thisOne = findClosestDiffIfReplaceWithVal(arr, ++candidateOnTheRight, target);
+                if (thisOne >= closetDiff) {
+                    break;
+                } else {
+                    closetDiff = thisOne;
+                    bestValue = candidateOnTheRight;
+                }
+            }
+
+            //extend candidate towards the left to see how close the sum could be to target
+            int candidateOnTheLeft = ave;
+            while (candidateOnTheLeft >= min) {
+                int thisOne = findClosestDiffIfReplaceWithVal(arr, --candidateOnTheLeft, target);
+                if (thisOne >= closetDiff) {
+                    break;
+                } else {
+                    closetDiff = thisOne;
+                    bestValue = candidateOnTheLeft;
+                }
+            }
+            return bestValue;
+        }
+
+        private int findClosestDiffIfReplaceWithVal(int[] arr, int replaceValue, int target) {
+            int sum = 0;
+            for (int i = 0; i < arr.length; i++) {
+                if (arr[i] > replaceValue) {
+                    sum += replaceValue;
+                } else {
+                    sum += arr[i];
+                }
+            }
+            return Math.abs(sum - target);
+        }
+
+        private int findMax(int[] arr) {
+            int max = arr[0];
+            for (int i = 1; i < arr.length; i++) {
+                max = Math.max(max, arr[i]);
+            }
+            return max;
+        }
+
+        private int findMin(int[] arr) {
+            int min = arr[0];
+            for (int i = 1; i < arr.length; i++) {
+                min = Math.min(min, arr[i]);
+            }
+            return min;
+        }
+    }
+}
diff --git a/src/test/java/com/fishercoder/_1300Test.java b/src/test/java/com/fishercoder/_1300Test.java
@@ -0,0 +1,36 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._1300;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _1300Test {
+    private static _1300.Solution1 solution1;
+    private static int[] arr;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _1300.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        arr = new int[]{4, 9, 3};
+        assertEquals(3, solution1.findBestValue(arr, 10));
+    }
+
+    @Test
+    public void test2() {
+        arr = new int[]{2, 3, 5};
+        assertEquals(5, solution1.findBestValue(arr, 10));
+    }
+
+    @Test
+    public void test3() {
+        arr = new int[]{60864, 25176, 27249, 21296, 20204};
+        assertEquals(11361, solution1.findBestValue(arr, 56803));
+    }
+
+}
