Java solution 224 && 225

java/_224BasicCalculator.java

@@ -0,0 +1,54 @@
+import java.util.Stack;
+
+/**
+ * Implement a basic calculator to evaluate a simple expression string.
+ * The expression string may contain open ( and closing parentheses ), the plus + or minus sign -, non-negative integers and empty spaces .
+ * You may assume that the given expression is always valid.
+ * <p>
+ * Some examples:
+ * "1 + 1" = 2
+ * " 2-1 + 2 " = 3
+ * "(1+(4+5+2)-3)+(6+8)" = 23
+ * <p>
+ * Note: Do not use the eval built-in library function.
+ * <p>
+ * Created by drfish on 6/8/2017.
+ */
+public class _224BasicCalculator {
+
+    public int calculate(String s) {
+        int sign = 1;
+        int result = 0;
+        Stack<Integer> stack = new Stack<>();
+
+        for (int i = 0; i < s.length(); i++) {
+            if (Character.isDigit(s.charAt(i))) {
+                int sum = s.charAt(i) - '0';
+                while (i + 1 < s.length() && Character.isDigit(s.charAt(i + 1))) {
+                    sum = sum * 10 + s.charAt(i + 1) - '0';
+                    i++;
+                }
+                result += sum * sign;
+            } else if (s.charAt(i) == '+') {
+                sign = 1;
+            } else if (s.charAt(i) == '-') {
+                sign = -1;
+            } else if (s.charAt(i) == '(') {
+                stack.push(result);
+                stack.push(sign);
+                result = 0;
+                sign = 1;
+            } else if (s.charAt(i) == ')') {
+                result = result * stack.pop() + stack.pop();
+            }
+        }
+        return result;
+    }
+
+    public static void main(String[] args) {
+        _224BasicCalculator solution = new _224BasicCalculator();
+        assert 2 == solution.calculate("1 + 1");
+        assert 3 == solution.calculate(" 2-1 + 2 ");
+        assert 23 == solution.calculate("(1+(4+5+2)-3)+(6+8)");
+    }
+}

java/_225ImplementStackUsingQueues.java

@@ -0,0 +1,64 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * Implement the following operations of a stack using queues.
+ * <p>
+ * push(x) -- Push element x onto stack.
+ * pop() -- Removes the element on top of the stack.
+ * top() -- Get the top element.
+ * empty() -- Return whether the stack is empty.
+ * <p>
+ * Notes:
+ * You must use only standard operations of a queue -- which means only push to back, peek/pop from front, size, and is empty operations are valid.
+ * Depending on your language, queue may not be supported natively. You may simulate a queue by using a list or deque (double-ended queue), as long as you use only standard operations of a queue.
+ * You may assume that all operations are valid (for example, no pop or top operations will be called on an empty stack).
+ * <p>
+ * Credits:
+ * Special thanks to @jianchao.li.fighter for adding this problem and all test cases.
+ * <p>
+ * Created by drfish on 6/8/2017.
+ */
+public class _225ImplementStackUsingQueues {
+    public class MyStack {
+        private Queue<Integer> queue;
+
+        /**
+         * Initialize your data structure here.
+         */
+        public MyStack() {
+            queue = new LinkedList<>();
+        }
+
+        /**
+         * Push element x onto stack.
+         */
+        public void push(int x) {
+            queue.add(x);
+            for (int i = 0; i < queue.size() - 1; i++) {
+                queue.add(queue.poll());
+            }
+        }
+
+        /**
+         * Removes the element on top of the stack and returns that element.
+         */
+        public int pop() {
+            return queue.poll();
+        }
+
+        /**
+         * Get the top element.
+         */
+        public int top() {
+            return queue.peek();
+        }
+
+        /**
+         * Returns whether the stack is empty.
+         */
+        public boolean empty() {
+            return queue.isEmpty();
+        }
+    }
+}