add 439

fishercoder1534 · fishercoder1534 · commit 2c99c700d7da · 2017-05-19T07:28:47.000-07:00
diff --git a/README.md b/README.md
@@ -104,6 +104,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |445|[Add Two Numbers II](https://leetcode.com/problems/add-two-numbers-ii/)|[Solution](../master/src/main/java/com/stevesun/solutions/_445.java)| O(max(m,n)|O(max(m,n)) | Medium| Stack, LinkedList
 |442|[Find All Duplicates in an Array](https://leetcode.com/problems/find-all-duplicates-in-an-array/)|[Solution](../master/src/main/java/com/stevesun/solutions/FindAllDuplicatesinanArray.java)| O(n)|O(1) | Medium| Array
 |441|[Arranging Coins](https://leetcode.com/problems/arrange-coins/)|[Solution](../master/src/main/java/com/stevesun/solutions/ArrangingCoins.java)| O(n)|O(1) | Easy|
+|439|[Ternary Expression Parser](https://leetcode.com/problems/ternary-expression-parser/)|[Solution](../master/src/main/java/com/stevesun/solutions/_439.java)| O(n)|O(n) | Medium| Stack
 |438|[Find All Anagrams in a String](https://leetcode.com/problems/find-all-anagrams-in-a-string/)|[Solution](../master/src/main/java/com/stevesun/solutions/FindAllAnagramsinaString.java)| O(n)|O(1) | Easy|
 |437|[Path Sum III](https://leetcode.com/problems/path-sum-iii/)|[Solution](../master/src/main/java/com/stevesun/solutions/PathSumIII.java) | O(n^2) |O(n) | Easy| DFS, recursion
 |436|[Find Right Interval](https://leetcode.com/problems/find-right-interval/)|[Solution](../master/src/main/java/com/stevesun/solutions/FindRightInterval.java) | O(nlogn) |O(n) | Medium| Binary Search
diff --git a/src/main/java/com/stevesun/solutions/_439.java b/src/main/java/com/stevesun/solutions/_439.java
@@ -0,0 +1,82 @@
+package com.stevesun.solutions;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+/**
+ * 439. Ternary Expression Parser
+ *
+ * Given a string representing arbitrarily nested ternary expressions, calculate the result of the expression.
+ * You can always assume that the given expression is valid and only consists of digits 0-9, ?, :, T and F (T and F represent True and False respectively).
+
+ Note:
+
+ The length of the given string is ≤ 10000.
+ Each number will contain only one digit.
+ The conditional expressions group right-to-left (as usual in most languages).
+ The condition will always be either T or F. That is, the condition will never be a digit.
+ The result of the expression will always evaluate to either a digit 0-9, T or F.
+
+ Example 1:
+
+ Input: "T?2:3"
+
+ Output: "2"
+
+ Explanation: If true, then result is 2; otherwise result is 3.
+
+
+ Example 2:
+
+ Input: "F?1:T?4:5"
+
+ Output: "4"
+
+ Explanation: The conditional expressions group right-to-left. Using parenthesis, it is read/evaluated as:
+
+ "(F ? 1 : (T ? 4 : 5))"                   "(F ? 1 : (T ? 4 : 5))"
+ -> "(F ? 1 : 4)"                 or       -> "(T ? 4 : 5)"
+ -> "4"                                    -> "4"
+ Example 3:
+
+ Input: "T?T?F:5:3"
+
+ Output: "F"
+
+ Explanation: The conditional expressions group right-to-left. Using parenthesis, it is read/evaluated as:
+
+ "(T ? (T ? F : 5) : 3)"                   "(T ? (T ? F : 5) : 3)"
+ -> "(T ? F : 3)"                 or       -> "(T ? F : 5)"
+ -> "F"                                    -> "F"
+ */
+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());
+                }
+            }
+            if (stack.size() == 1) break;
+        }
+        return Character.toString(stack.removeFirst());
+    }
+
+}
diff --git a/src/test/java/com/stevesun/_439Test.java b/src/test/java/com/stevesun/_439Test.java
@@ -0,0 +1,51 @@
+package com.stevesun;
+
+import com.stevesun.solutions._439;
+import com.stevesun.solutions._48;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Created by stevesun 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));
+    }
+}
