refactor 396

Author: fishercoder1534

src/main/java/com/fishercoder/solutions/_396.java

@@ -25,61 +25,62 @@ Calculate the maximum value of F(0), F(1), ..., F(n-1).
 
  So the maximum value of F(0), F(1), F(2), F(3) is F(3) = 26.*/
 
-//F(k) = 0 * Bk[0] + 1 * Bk[1] + ... + (n-1) * Bk[n-1]
 public class _396 {
-    public int maxRotateFunction(int[] A) {
-        if (A == null || A.length == 0) {
-            return 0;
+    public static class Solution1 {
+        /**
+         * F(k) = 0 * Bk[0] + 1 * Bk[1] + ... + (n-1) * Bk[n-1]
+         */
+        public int maxRotateFunction(int[] A) {
+            if (A == null || A.length == 0) {
+                return 0;
+            }
+            int[] F = new int[A.length];
+            int[] B = A;
+            int max = Integer.MIN_VALUE;
+            for (int i = 0; i < A.length; i++) {
+                F[i] = compute(B);
+                max = Math.max(max, F[i]);
+                B = rotate(B);
+            }
+            return max;
         }
-        int[] F = new int[A.length];
-        int[] B = A;
-        int max = Integer.MIN_VALUE;
-        for (int i = 0; i < A.length; i++) {
-            F[i] = compute(B);
-            max = Math.max(max, F[i]);
-            B = rotate(B);
-        }
-        return max;
-    }
 
-    private int compute(int[] b) {
-        int sum = 0;
-        for (int i = 0; i < b.length; i++) {
-            sum += i * b[i];
+        private int compute(int[] b) {
+            int sum = 0;
+            for (int i = 0; i < b.length; i++) {
+                sum += i * b[i];
+            }
+            return sum;
         }
-        return sum;
-    }
 
-    private int[] rotate(int[] a) {
-        int first = a[0];
-        for (int i = 1; i < a.length; i++) {
-            a[i - 1] = a[i];
+        private int[] rotate(int[] a) {
+            int first = a[0];
+            for (int i = 1; i < a.length; i++) {
+                a[i - 1] = a[i];
+            }
+            a[a.length - 1] = first;
+            return a;
         }
-        a[a.length - 1] = first;
-        return a;
     }
 
-    //**credit : https://discuss.leetcode.com/topic/58459/java-o-n-solution-with-explanation
-    public int maxRotateFunctionV2(int[] A) {
-        int allSum = 0;
-        int len = A.length;
-        int F = 0;
-        for (int i = 0; i < len; i++) {
-            F += i * A[i];
-            allSum += A[i];
+    public static class Solution2 {
+        /**
+         * Reference: https://discuss.leetcode.com/topic/58459/java-o-n-solution-with-explanation
+         */
+        public int maxRotateFunction(int[] A) {
+            int allSum = 0;
+            int len = A.length;
+            int F = 0;
+            for (int i = 0; i < len; i++) {
+                F += i * A[i];
+                allSum += A[i];
+            }
+            int max = F;
+            for (int i = len - 1; i >= 1; i--) {
+                F = F + allSum - len * A[i];
+                max = Math.max(F, max);
+            }
+            return max;
         }
-        int max = F;
-        for (int i = len - 1; i >= 1; i--) {
-            F = F + allSum - len * A[i];
-            max = Math.max(F, max);
-        }
-        return max;
-    }
-
-    public static void main(String... strings) {
-        int[] nums = new int[]{4, 3, 2, 6};
-        _396 test = new _396();
-        System.out.println(test.maxRotateFunction(nums));
-        System.out.println(test.maxRotateFunctionV2(nums));
     }
 }

src/test/java/com/fishercoder/_396Test.java

@@ -0,0 +1,34 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._396;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _396Test {
+    private static _396.Solution1 solution1;
+    private static _396.Solution2 solution2;
+    private static int[] A;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _396.Solution1();
+        solution2 = new _396.Solution2();
+    }
+
+    @Test
+    public void test1() {
+        A = new int[]{4, 3, 2, 6};
+        assertEquals(26, solution1.maxRotateFunction(A));
+        assertEquals(26, solution2.maxRotateFunction(A));
+    }
+
+    @Test
+    public void test2() {
+        A = new int[]{1,2,3,4,5,6,7,8,9,10};
+        assertEquals(330, solution1.maxRotateFunction(A));
+        assertEquals(330, solution2.maxRotateFunction(A));
+    }
+
+}