Solutions added for LeetCode #462, #1423

Author: rayworks

src/main/java/org/sean/array/MaxCardPoints.java

@@ -0,0 +1,38 @@
+package org.sean.array;
+
+/***
+ * 1423. Maximum Points You Can Obtain from Cards
+ */
+public class MaxCardPoints {
+
+    public int maxScore(int[] cardPoints, int k) {
+        int len = cardPoints.length;
+        if (k == 1) {
+            return Math.max(cardPoints[0], cardPoints[len - 1]);
+        }
+        int total = 0;
+        for (int e : cardPoints) {
+            total += e;
+        }
+        if (k >= len)
+            return total;
+
+        // reverse thinking : find the subarray with the min sum
+        // sliding window
+        int winLen = len - k;
+        int sum = 0;
+        for (int j = 0; j < winLen; j++) {
+            sum += cardPoints[j];
+        }
+        int min = sum;
+        for (int i = 1; i + winLen <= len; i++) {
+            sum -= cardPoints[i - 1];
+            sum += cardPoints[i + winLen - 1];
+
+            if (min > sum) {
+                min = sum;
+            }
+        }
+        return total - min;
+    }
+}

src/main/java/org/sean/sorting/MinMoveCalculator.java

@@ -0,0 +1,56 @@
+package org.sean.sorting;
+
+import java.util.Random;
+
+/***
+ * 462. Minimum Moves to Equal Array Elements II
+ */
+public class MinMoveCalculator {
+    public int minMoves2(int[] nums) {
+        if (nums.length <= 1)
+            return 0;
+
+        // Find the median of the array
+        // * Sorting the array could be one of the solutions, but its time complexity goes to O(n*lgn)
+        // * By partition : O(n)
+        int median = partition(nums, 0, nums.length - 1, (nums.length + 1) / 2);
+
+        int mv = 0;
+        for (int e : nums) {
+            mv += Math.abs(e - median);
+        }
+        return mv;
+    }
+
+    private void swap(int[] nums, int i, int j) {
+        int tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+
+    private int partition(int[] nums, int l, int r, int targetPos) {
+        // randomizing the pivot is important
+        final int randIndex = new Random().nextInt(r - l + 1) + l;
+        swap(nums, randIndex, r);
+        final int pivot = nums[r];
+
+
+        // int pivot = nums[r];
+        int swapIndex = l;
+        for (int i = l; i < r; i++) {
+            if (nums[i] <= pivot) {
+                swap(nums, i, swapIndex++);
+            }
+        }
+        swap(nums, swapIndex, r);
+
+        int cnt = swapIndex - l + 1;
+        if (cnt == targetPos)
+            return nums[swapIndex];
+        else if (cnt > targetPos) {
+            return partition(nums, l, swapIndex - 1, targetPos);
+        } else {
+            return partition(nums, swapIndex + 1, r, targetPos - cnt);
+        }
+    }
+}

src/test/java/org/sean/array/MaxCardPointsTest.java

@@ -0,0 +1,21 @@
+package org.sean.array;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class MaxCardPointsTest {
+
+    private MaxCardPoints cardPoints;
+
+    @Before
+    public void setUp() throws Exception {
+        cardPoints = new MaxCardPoints();
+    }
+
+    @Test
+    public void maxScore() {
+        assertEquals(232, cardPoints.maxScore(new int[]{11, 49, 100, 20, 86, 29, 72}, 4));
+    }
+}

src/test/java/org/sean/sorting/MinMoveCalculatorTest.java

@@ -0,0 +1,21 @@
+package org.sean.sorting;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class MinMoveCalculatorTest {
+
+    private MinMoveCalculator calculator;
+
+    @Before
+    public void setUp() throws Exception {
+        calculator = new MinMoveCalculator();
+    }
+
+    @Test
+    public void minMoves2() {
+        assertEquals(14, calculator.minMoves2(new int[]{1, 0, 0, 8, 6}));
+    }
+}