refactor 131

Author: fishercoder1534

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

@@ -3,7 +3,10 @@
 import java.util.ArrayList;
 import java.util.List;
 
-/**Given a string s, partition s such that every substring of the partition is a palindrome.
+/**
+ * 131. Palindrome Partitioning
+
+ Given a string s, partition s such that every substring of the partition is a palindrome.
 
  Return all possible palindrome partitioning of s.
 
@@ -13,62 +16,52 @@
  [
  ["aa","b"],
  ["a","a","b"]
- ]*/
+ ]
+
+ */
 public class _131 {
 
+  public static class Solution1 {
     public List<List<String>> partition(String s) {
-        List<List<String>> result = new ArrayList();
-        int n = s.length();
-        boolean[][] dp = new boolean[n][n];
-        for (int i = 0; i < n; i++) {
-            for (int j = 0; j <= i; j++) {
-                if (s.charAt(j) == s.charAt(i) && (j + 1 >= i - 1 || dp[j + 1][i - 1])) {
-                    // j+1 >= i-1 means j and i are adjance to each other or only one char apart from each other
-                    //dp[j+1][i-1] means its inner substring is a palindrome, so as long as s.charAt(j) == s.charAt(i), then dp[j][i] must be a palindrome.
-                    dp[j][i] = true;
-                }
-            }
+      List<List<String>> result = new ArrayList();
+      int n = s.length();
+      boolean[][] dp = new boolean[n][n];
+      for (int i = 0; i < n; i++) {
+        for (int j = 0; j <= i; j++) {
+          if (s.charAt(j) == s.charAt(i) && (j + 1 >= i - 1 || dp[j + 1][i - 1])) {
+            // j+1 >= i-1 means j and i are adjance to each other or only one char apart from each other
+            //dp[j+1][i-1] means its inner substring is a palindrome, so as long as s.charAt(j) == s.charAt(i), then dp[j][i] must be a palindrome.
+            dp[j][i] = true;
+          }
         }
+      }
 
-        for (boolean[] list : dp) {
-            for (boolean b : list) {
-                System.out.print(b + ", ");
-            }
-            System.out.println();
+      for (boolean[] list : dp) {
+        for (boolean b : list) {
+          System.out.print(b + ", ");
         }
         System.out.println();
+      }
+      System.out.println();
 
-        backtracking(s, 0, dp, new ArrayList(), result);
+      backtracking(s, 0, dp, new ArrayList(), result);
 
-        return result;
+      return result;
     }
 
     void backtracking(String s, int start, boolean[][] dp, List<String> temp,
-                      List<List<String>> result) {
-        if (start == s.length()) {
-            List<String> newTemp = new ArrayList(temp);
-            result.add(newTemp);
-        }
-        for (int i = start; i < s.length(); i++) {
-            if (dp[start][i]) {
-                temp.add(s.substring(start, i + 1));
-                backtracking(s, i + 1, dp, temp, result);
-                temp.remove(temp.size() - 1);
-            }
-        }
-    }
-
-
-    public static void main(String... strings) {
-        _131 test = new _131();
-        String s = "aab";
-        List<List<String>> result = test.partition(s);
-        for (List<String> list : result) {
-            for (String str : list) {
-                System.out.print(str + ", ");
-            }
-            System.out.println();
+        List<List<String>> result) {
+      if (start == s.length()) {
+        List<String> newTemp = new ArrayList(temp);
+        result.add(newTemp);
+      }
+      for (int i = start; i < s.length(); i++) {
+        if (dp[start][i]) {
+          temp.add(s.substring(start, i + 1));
+          backtracking(s, i + 1, dp, temp, result);
+          temp.remove(temp.size() - 1);
         }
+      }
     }
-
+  }
 }

src/test/java/com/fishercoder/_131Test.java

@@ -0,0 +1,28 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._131;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _131Test {
+  private static _131.Solution1 solution1;
+  private static List<List<String>> expected;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _131.Solution1();
+  }
+
+  @Test
+  public void test1() {
+    expected = new ArrayList();
+    expected.add(Arrays.asList("a", "a", "b"));
+    expected.add(Arrays.asList("aa", "b"));
+    assertEquals(expected, solution1.partition("aab"));
+  }
+}