Updated JUnit version + Repeated DNA Sequence done

Author: rampatra

src/main/java/com/leetcode/arrays/CanPlaceFlowers.java

@@ -1,7 +1,8 @@
 package com.leetcode.arrays;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * Level: Easy

src/main/java/com/leetcode/arrays/NestedListWeightSumI.java

@@ -5,4 +5,12 @@
  * @since 2019-07-27
  */
 public class NestedListWeightSumI {
+
+    public long nestedSum(Object[] nestedList, long sum, int depth) {
+        return -1;
+    }
+
+    public static void main(String[] args) {
+
+    }
 }

src/main/java/com/leetcode/dynamicprogramming/PaintHouseII.java

@@ -1,6 +1,6 @@
 package com.leetcode.dynamicprogramming;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 /**
  * Level: Hard

src/main/java/com/leetcode/maps/RepeatedDnaSequence.java

@@ -1,8 +1,69 @@
 package com.leetcode.maps;
 
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 /**
  * @author rampatra
  * @since 2019-07-29
  */
 public class RepeatedDnaSequence {
-}
+
+    /**
+     * Rabin-Karp Algorithm: https://brilliant.org/wiki/rabin-karp-algorithm/
+     *
+     * @param s
+     * @return
+     */
+    public static List<String> findRepeatedDnaSequences(String s) {
+        if (s.length() < 10) return new ArrayList<>();
+
+        Set<String> repeatedSequences = new HashSet<>();
+        Map<Long, Set<String>> hashToStringMap = new HashMap<>();
+        long hashOfSequence = computeHash(s);
+        hashToStringMap.put(hashOfSequence, new HashSet<String>() {{
+            add(s.substring(0, 10));
+        }});
+
+        long pow = (long) Math.pow(4, 9);
+
+        for (int i = 10; i < s.length(); i++) {
+            hashOfSequence = (hashOfSequence - (pow * (s.charAt(i - 10) - 'A'))) * 4 + (s.charAt(i) - 'A');
+            String subString = s.substring(i - 10 + 1, i + 1);
+
+            if (hashToStringMap.get(hashOfSequence) != null && hashToStringMap.get(hashOfSequence).contains(subString)) {
+                repeatedSequences.add(subString);
+                continue;
+            }
+
+            hashToStringMap.putIfAbsent(hashOfSequence, new HashSet<>());
+            hashToStringMap.get(hashOfSequence).add(subString);
+        }
+
+        return new ArrayList<>(repeatedSequences);
+    }
+
+    private static long computeHash(String s) {
+        long hash = 0;
+        for (int i = 0; i < 10; i++) {
+            hash += (Math.pow(4, i) * (s.charAt(9 - i) - 'A'));
+        }
+        return hash;
+    }
+
+    public static void main(String[] args) {
+
+        assertEquals(new ArrayList<>(),
+                findRepeatedDnaSequences("AAAAACCC"));
+
+        assertEquals(Arrays.asList("AAAAACCCCC", "CCCCCAAAAA"),
+                findRepeatedDnaSequences("AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"));
+
+        assertEquals(Collections.singletonList("AAAAAAAAAA"),
+                findRepeatedDnaSequences("AAAAAAAAAAAA"));
+
+        assertEquals(Collections.singletonList("BBBBBBBBBB"),
+                findRepeatedDnaSequences("BBBBBBBBBBBB"));
+    }
+}

src/main/java/com/leetcode/stacks/ReversePolishNotation.java

@@ -1,8 +1,93 @@
 package com.leetcode.stacks;
 
+import java.util.Stack;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 /**
+ * Level: Medium
+ * Problem Link: https://leetcode.com/problems/evaluate-reverse-polish-notation
+ * Problem Description:
+ * Evaluate the value of an arithmetic expression in Reverse Polish Notation.
+ * <p>
+ * Valid operators are +, -, *, /. Each operand may be an integer or another expression.
+ * <p>
+ * Note:
+ * Division between two integers should truncate toward zero.
+ * The given RPN expression is always valid. That means the expression would always evaluate to a result and there
+ * won't be any divide by zero operation.
+ * <p>
+ * Example 1:
+ * Input: ["2", "1", "+", "3", "*"]
+ * Output: 9
+ * Explanation: ((2 + 1) * 3) = 9
+ * <p>
+ * Example 2:
+ * Input: ["4", "13", "5", "/", "+"]
+ * Output: 6
+ * Explanation: (4 + (13 / 5)) = 6
+ * <p>
+ * Example 3:
+ * Input: ["10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"]
+ * Output: 22
+ * Explanation:
+ * ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
+ * = ((10 * (6 / (12 * -11))) + 17) + 5
+ * = ((10 * (6 / -132)) + 17) + 5
+ * = ((10 * 0) + 17) + 5
+ * = (0 + 17) + 5
+ * = 17 + 5
+ * = 22
+ *
  * @author rampatra
  * @since 2019-07-27
  */
 public class ReversePolishNotation {
+
+    /**
+     * Time Complexity:
+     * Space Complexity:
+     * Runtime: <a href="https://leetcode.com/submissions/detail/246794713/">5 ms</a>.
+     *
+     * @param tokens
+     * @return
+     */
+    public static int evalRPN(String[] tokens) {
+        int operand1;
+        int operand2;
+
+        Stack<Integer> stack = new Stack<>();
+
+        for (String s : tokens) {
+            switch (s) {
+                case "+":
+                    stack.push(stack.pop() + stack.pop());
+                    break;
+                case "-":
+                    operand1 = stack.pop();
+                    operand2 = stack.pop();
+                    stack.push(operand2 - operand1);
+                    break;
+                case "*":
+                    stack.push(stack.pop() * stack.pop());
+                    break;
+                case "/":
+                    operand1 = stack.pop();
+                    operand2 = stack.pop();
+                    stack.push(operand2 / operand1);
+                    break;
+                default:
+                    stack.push(Integer.parseInt(s));
+            }
+        }
+
+        return stack.pop();
+    }
+
+    public static void main(String[] args) {
+        assertEquals(18, evalRPN(new String[]{"18"}));
+        assertEquals(9, evalRPN(new String[]{"2", "1", "+", "3", "*"}));
+        assertEquals(6, evalRPN(new String[]{"4", "13", "5", "/", "+"}));
+        assertEquals(22, evalRPN(new String[]{"10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"}));
+    }
 }

src/main/java/com/leetcode/trees/SymmetricTree.java

@@ -3,7 +3,7 @@
 import java.util.LinkedList;
 import java.util.Queue;
 
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * Level: Easy