refactor 439

Author: fishercoder1534

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

@@ -51,34 +51,38 @@
  */
 public class _439 {
 
-    /**Below is my original solution, but looking at Discuss, a more concise way is to use just one stack, process it from right to left,
-     * example: https://discuss.leetcode.com/topic/64409/very-easy-1-pass-stack-solution-in-java-no-string-concat*/
-
-    public String parseTernary(String expression) {
-        Deque<Character> stack = new ArrayDeque<>();
-        Deque<Character> tmpStack = new ArrayDeque<>();
-        for (char c : expression.toCharArray()) {
-            stack.addFirst(c);
-        }
-        while (!stack.isEmpty()) {
-            if (stack.peek() != '?') {
-                tmpStack.addFirst(stack.pollFirst());
-            } else {
-                char char1 = tmpStack.removeFirst();
-                tmpStack.removeFirst();//remove ':'
-                char char2 = tmpStack.removeFirst();
-                stack.removeFirst();//remove '?'
-                char judge = stack.removeFirst();
-                tmpStack.addFirst(judge == 'T' ? char1 : char2);
-                while (!tmpStack.isEmpty()) {
-                    stack.addFirst(tmpStack.pollFirst());
-                }
+    public static class Solution1 {
+        /**
+         * Below is my original solution, but looking at Discuss, a more concise way is to use just one
+         * stack, process it from right to left, example: https://discuss.leetcode.com/topic/64409/very-easy-1-pass-stack-solution-in-java-no-string-concat
+         */
+
+        public String parseTernary(String expression) {
+            Deque<Character> stack = new ArrayDeque<>();
+            Deque<Character> tmpStack = new ArrayDeque<>();
+            for (char c : expression.toCharArray()) {
+                stack.addFirst(c);
             }
-            if (stack.size() == 1) {
-                break;
+            while (!stack.isEmpty()) {
+                if (stack.peek() != '?') {
+                    tmpStack.addFirst(stack.pollFirst());
+                } else {
+                    char char1 = tmpStack.removeFirst();
+                    tmpStack.removeFirst();//remove ':'
+                    char char2 = tmpStack.removeFirst();
+                    stack.removeFirst();//remove '?'
+                    char judge = stack.removeFirst();
+                    tmpStack.addFirst(judge == 'T' ? char1 : char2);
+                    while (!tmpStack.isEmpty()) {
+                        stack.addFirst(tmpStack.pollFirst());
+                    }
+                }
+                if (stack.size() == 1) {
+                    break;
+                }
             }
+            return Character.toString(stack.removeFirst());
         }
-        return Character.toString(stack.removeFirst());
     }
 
 }

src/test/java/com/fishercoder/_439Test.java

@@ -10,41 +10,40 @@
  * Created by fishercoder on 5/18/17.
  */
 public class _439Test {
-    private static _439 test;
-    private static String expression;
-    private static String expected;
-    private static String actual;
-
-    @BeforeClass
-    public static void setup() {
-        test = new _439();
-    }
-
-    @Test
-    public void test1() {
-        expression = "T?2:3";
-        expected = "2";
-        assertEquals(expected, test.parseTernary(expression));
-    }
-
-    @Test
-    public void test2() {
-        expression = "F?1:T?4:5";
-        expected = "4";
-        assertEquals(expected, test.parseTernary(expression));
-    }
-
-    @Test
-    public void test3() {
-        expression = "T?T?F:5:3";
-        expected = "F";
-        assertEquals(expected, test.parseTernary(expression));
-    }
-
-    @Test
-    public void test4() {
-        expression = "T?T:F?T?1:2:F?3:4";
-        expected = "T";
-        assertEquals(expected, test.parseTernary(expression));
-    }
+  private static _439.Solution1 solution1;
+  private static String expression;
+  private static String expected;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _439.Solution1();
+  }
+
+  @Test
+  public void test1() {
+    expression = "T?2:3";
+    expected = "2";
+    assertEquals(expected, solution1.parseTernary(expression));
+  }
+
+  @Test
+  public void test2() {
+    expression = "F?1:T?4:5";
+    expected = "4";
+    assertEquals(expected, solution1.parseTernary(expression));
+  }
+
+  @Test
+  public void test3() {
+    expression = "T?T?F:5:3";
+    expected = "F";
+    assertEquals(expected, solution1.parseTernary(expression));
+  }
+
+  @Test
+  public void test4() {
+    expression = "T?T:F?T?1:2:F?3:4";
+    expected = "T";
+    assertEquals(expected, solution1.parseTernary(expression));
+  }
 }