add 1775

fishercoder1534 · fishercoder1534 · commit 973ef65c451b · 2021-03-09T11:51:42.000-08:00
diff --git a/README.md b/README.md
@@ -13,6 +13,7 @@ _If you like this project, please leave me a star._ &#9733;
 |1781|[Sum of Beauty of All Substrings](https://leetcode.com/problems/sum-of-beauty-of-all-substrings/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1781.java) ||Medium|HashTable, String|
 |1780|[Check if Number is a Sum of Powers of Three](https://leetcode.com/problems/check-if-number-is-a-sum-of-powers-of-three/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1780.java) ||Medium|Math, Backtracking, Recursion|
 |1779|[Find Nearest Point That Has the Same X or Y Coordinate](https://leetcode.com/problems/find-nearest-point-that-has-the-same-x-or-y-coordinate/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1779.java) ||Easy|Array|
+|1775|[Equal Sum Arrays With Minimum Number of Operations](https://leetcode.com/problems/equal-sum-arrays-with-minimum-number-of-operations/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1775.java) ||Medium|Greedy|
 |1774|[Closest Dessert Cost](https://leetcode.com/problems/closest-dessert-cost/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1774.java) ||Medium|Greedy|
 |1773|[Count Items Matching a Rule](https://leetcode.com/problems/count-items-matching-a-rule/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1773.java) ||Easy|Array, String|
 |1772|[Sort Features by Popularity](https://leetcode.com/problems/sort-features-by-popularity/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1772.java) ||Medium|HashTable, Sort|
diff --git a/src/main/java/com/fishercoder/solutions/_1775.java b/src/main/java/com/fishercoder/solutions/_1775.java
@@ -0,0 +1,73 @@
+package com.fishercoder.solutions;
+
+import java.util.Arrays;
+
+public class _1775 {
+    public static class Solution1 {
+        public int minOperations(int[] nums1, int[] nums2) {
+            int[] longer = nums1.length > nums2.length ? nums1 : nums2;
+            int[] shorter = nums1.length > nums2.length ? nums2 : nums1;
+            if (longer.length > shorter.length * 6) {
+                /**This is the impossible case that we'll rule out first.*/
+                return -1;
+            }
+            Arrays.sort(longer);
+            Arrays.sort(shorter);
+            int i = 0;
+            int j = 0;
+            int diff = 0;
+            while (i < longer.length || j < shorter.length) {
+                if (i < longer.length) {
+                    diff += longer[i++];
+                }
+                if (j < shorter.length) {
+                    diff -= shorter[j++];
+                }
+            }
+            int minOps = 0;
+            i = 0;
+            j = shorter.length - 1;
+            if (diff < 0) {
+                /**if diff is negative, this means we'll need to decrease numbers in the shorter array and increase the numbers in the longer array to make the diff to be zero
+                 * and each time, we'll be greedy: take the bigger delta from two of the arrays.*/
+                while (diff < 0) {
+                    if (i < longer.length && j >= 0) {
+                        if (6 - longer[i] < shorter[j] - 1) {
+                            diff += shorter[j--] - 1;
+                        } else {
+                            diff += 6 - longer[i++];
+                        }
+                    } else if (i < longer.length) {
+                        diff += 6 - longer[i++];
+                    } else {
+                        diff += shorter[j--] - 1;
+                    }
+                    minOps++;
+                }
+                return minOps;
+            } else if (diff > 0) {
+                /**if diff is positive, this means we'll need to decrease the numbers in the longer array and increase the numbers in the shorter array to make the diff to be zero
+                 * and each time, we'll be greedy: take the bigger delta from two of the arrays.*/
+                i = longer.length - 1;
+                j = 0;
+                while (diff > 0) {
+                    if (i >= 0 && j < shorter.length) {
+                        if (longer[i] - 1 > 6 - shorter[j]) {
+                            diff -= longer[i--] - 1;
+                        } else {
+                            diff -= 6 - shorter[j++];
+                        }
+                    } else if (i >= 0) {
+                        diff -= longer[i--] - 1;
+                    } else {
+                        diff -= 6 - shorter[j++];
+                    }
+                    minOps++;
+                }
+                return minOps;
+            } else {
+                return minOps;
+            }
+        }
+    }
+}
diff --git a/src/test/java/com/fishercoder/_1775Test.java b/src/test/java/com/fishercoder/_1775Test.java
@@ -0,0 +1,32 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._1775;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _1775Test {
+    private static _1775.Solution1 solution1;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _1775.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        assertEquals(3, solution1.minOperations(new int[]{1, 2, 3, 4, 5, 6}, new int[]{1, 1, 2, 2, 2, 2}));
+    }
+
+    @Test
+    public void test2() {
+        assertEquals(-1, solution1.minOperations(new int[]{1, 1, 1, 1, 1, 1, 1}, new int[]{6}));
+    }
+
+    @Test
+    public void test3() {
+        assertEquals(3, solution1.minOperations(new int[]{6, 6}, new int[]{1}));
+    }
+
+}
