refactor 667

fishercoder1534 · fishercoder1534 · commit 9461a37dbcf1 · 2021-04-13T16:42:11.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_667.java b/src/main/java/com/fishercoder/solutions/_667.java
@@ -9,54 +9,34 @@ public class _667 {
 
     public static class Solutoin1 {
         /**
-         * This brute force solution will result in TLE as soon as n = 10 and k = 4.
+         * inspired by this post: https://leetcode.com/problems/beautiful-arrangement-ii/discuss/1154683/Short-and-Simple-Solution-or-Multiple-Approaches-Explained-with-Examples-! and implemented it on my own
          */
         public int[] constructArray(int n, int k) {
-            List<List<Integer>> allPermutaions = findAllPermutations(n);
-            int[] result = new int[n];
-            for (List<Integer> perm : allPermutaions) {
-                if (isBeautifulArrangement(perm, k)) {
-                    convertListToArray(result, perm);
-                    break;
+            List<Integer> list = new ArrayList<>();
+            int maxSoFar = 1;
+            list.add(1);
+            boolean plus = true;
+            while (k > 0) {
+                if (plus) {
+                    plus = false;
+                    int num = list.get(list.size() - 1) + k;
+                    maxSoFar = Math.max(maxSoFar, num);
+                    list.add(num);
+                } else {
+                    plus = true;
+                    list.add(list.get(list.size() - 1) - k);
                 }
+                k--;
             }
-            return result;
-        }
-
-        private void convertListToArray(int[] result, List<Integer> perm) {
-            for (int i = 0; i < perm.size(); i++) {
-                result[i] = perm.get(i);
+            for (int start = maxSoFar + 1; start <= n; start++) {
+                list.add(start);
             }
-        }
-
-        private boolean isBeautifulArrangement(List<Integer> perm, int k) {
-            Set<Integer> diff = new HashSet<>();
-            for (int i = 0; i < perm.size() - 1; i++) {
-                diff.add(Math.abs(perm.get(i) - perm.get(i + 1)));
+            int[] result = new int[n];
+            for (int i = 0; i < list.size(); i++) {
+                result[i] = list.get(i);
             }
-            return diff.size() == k;
-        }
-
-        private List<List<Integer>> findAllPermutations(int n) {
-            List<List<Integer>> result = new ArrayList<>();
-            backtracking(new ArrayList<>(), result, n);
             return result;
         }
-
-        private void backtracking(List<Integer> list, List<List<Integer>> result, int n) {
-            if (list.size() == n) {
-                result.add(new ArrayList<>(list));
-                return;
-            }
-            for (int i = 1; i <= n; i++) {
-                if (list.contains(i)) {
-                    continue;
-                }
-                list.add(i);
-                backtracking(list, result, n);
-                list.remove(list.size() - 1);
-            }
-        }
     }
 
     public static class Solutoin2 {
diff --git a/src/test/java/com/fishercoder/_667Test.java b/src/test/java/com/fishercoder/_667Test.java
@@ -1,44 +1,52 @@
 package com.fishercoder;
 
+import com.fishercoder.common.utils.CommonUtils;
 import com.fishercoder.solutions._667;
 import org.junit.BeforeClass;
-import org.junit.Ignore;
 import org.junit.Test;
 
 import static org.junit.Assert.assertArrayEquals;
 
 public class _667Test {
-	private static _667.Solutoin1 solution1;
-	private static _667.Solutoin2 solution2;
-	private static int[] expected;
-
-	@BeforeClass
-	public static void setup() {
-		solution1 = new _667.Solutoin1();
-		solution2 = new _667.Solutoin2();
-	}
-
-	@Test
-	public void test1() {
-		expected = new int[] { 1, 2, 3 };
-		assertArrayEquals(expected, solution1.constructArray(3, 1));
-		assertArrayEquals(expected, solution2.constructArray(3, 1));
-	}
-
-	@Test
-	@Ignore//this problem requires you to return any one of the legit answer, so the results vary from time to time, so comment out this test
-	public void test2() {
-		expected = new int[] { 1, 3, 2 };
-		assertArrayEquals(expected, solution1.constructArray(3, 2));
-		assertArrayEquals(expected, solution2.constructArray(3, 2));
-	}
-
-	@Test
-	@Ignore//this problem requires you to return any one of the legit answer, so the results vary from time to time, so comment out this test
-	public void test3() {
-		expected = new int[] { 1, 5, 2, 4, 3, 6, 7, 8, 9, 10 };
-		//		assertArrayEquals(expected, solution1.constructArray(10, 4));//this is not working, so comment out
-		assertArrayEquals(expected, solution2.constructArray(10, 4));
-	}
+    private static _667.Solutoin1 solution1;
+    private static _667.Solutoin2 solution2;
+    private static int[] expected;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _667.Solutoin1();
+        solution2 = new _667.Solutoin2();
+    }
+
+    @Test
+    public void test1() {
+        expected = new int[]{1, 2, 3};
+        assertArrayEquals(expected, solution1.constructArray(3, 1));
+        assertArrayEquals(expected, solution2.constructArray(3, 1));
+    }
+
+    @Test
+    public void test2() {
+        CommonUtils.printArray(solution1.constructArray(3, 2));
+        CommonUtils.printArray(solution2.constructArray(3, 2));
+    }
+
+    @Test
+    public void test3() {
+        CommonUtils.printArray(solution1.constructArray(10, 4));
+        CommonUtils.printArray(solution2.constructArray(10, 4));
+    }
+
+    @Test
+    public void test4() {
+        CommonUtils.printArray(solution1.constructArray(5, 3));
+        CommonUtils.printArray(solution2.constructArray(5, 3));
+    }
+
+    @Test
+    public void test5() {
+        CommonUtils.printArray(solution1.constructArray(5, 2));
+        CommonUtils.printArray(solution2.constructArray(5, 2));
+    }
 
 }
