Update notes of stack/queue problems

Author: enginebai

leetcode/1047.remove-all-adjacent-duplicates-in-string.md

@@ -1,5 +1,22 @@
 ## [1047. Remove All Adjacent Duplicates In String](https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string/)
 
+## Clarification Questions
+* No, it's clear from problem description.
+ 
+## Test Cases
+### Normal Cases
+```
+Input: 
+Output: 
+```
+### Edge / Corner Cases
+* 
+```
+Input: 
+Output: 
+```
+
+## Stack
 ```kotlin
 fun removeDuplicates(s: String): String {
     val stack = Stack<Char>()

leetcode/1249.minimum-remove-to-make-valid-parentheses.md

@@ -1,5 +1,21 @@
 ## [1249. Minimum Remove to Make Valid Parentheses](https://leetcode.com/problems/minimum-remove-to-make-valid-parentheses/)
 
+## Clarification Questions
+* No, it's clear from problem description.
+ 
+## Test Cases
+### Normal Cases
+```
+Input: 
+Output: 
+```
+### Edge / Corner Cases
+* 
+```
+Input: 
+Output: 
+```
+
 ```kotlin
 fun minRemoveToMakeValid(s: String): String {
     if (s.isEmpty()) return ""

leetcode/155.min-stack.md

@@ -1,4 +1,21 @@
 ## [155. Min Stack](https://leetcode.com/problems/min-stack/)
+
+## Clarification Questions
+* No, it's clear from problem description.
+ 
+## Test Cases
+### Normal Cases
+```
+Input: 
+Output: 
+```
+### Edge / Corner Cases
+* 
+```
+Input: 
+Output: 
+```
+
 We keep the peek value and current min via using two stack, and manipulate at the same time.
 
 ```js

leetcode/1823.find-the-winner-of-the-circular-game.md

@@ -1,5 +1,21 @@
 ## [1823. Find the Winner of the Circular Game](https://leetcode.com/problems/find-the-winner-of-the-circular-game)
 
+## Clarification Questions
+* No, it's clear from problem description.
+ 
+## Test Cases
+### Normal Cases
+```
+Input: 
+Output: 
+```
+### Edge / Corner Cases
+* 
+```
+Input: 
+Output: 
+```
+
 ### Simulation
 ```kotlin
 fun findTheWinner(n: Int, k: Int): Int {

leetcode/20.valid-parentheses.md

@@ -1,5 +1,21 @@
 ## [20. Valid Parentheses](https://leetcode.com/problems/valid-parentheses/)
 
+## Clarification Questions
+* No, it's clear from problem description.
+ 
+## Test Cases
+### Normal Cases
+```
+Input: 
+Output: 
+```
+### Edge / Corner Cases
+* 
+```
+Input: 
+Output: 
+```
+
 ```kotlin
 fun isValid(s: String): Boolean {
     val mapping = mapOf(')' to '(', ']' to '[', '}' to '{')

leetcode/224.basic-calculator.md

@@ -1,8 +1,33 @@
-## [224. Basic Calculator](https://leetcode.com/problems/basic-calculator/)
+# [224. Basic Calculator](https://leetcode.com/problems/basic-calculator/)
+
+## Clarification Questions
+* Is the input string always valid? (i.e. no invalid characters, the parentheses are always balanced, etc.)
+ 
+## Test Cases
+### Normal Cases
+```
+Input: 
+Output: 
+```
+### Edge / Corner Cases
+* There are multiple nested parentheses.
+```
+Input: 
+Output: 
+```
+
+## Stack
+For this basic calculator, there are several cases we need to consider:
+1. The number: We need to build the number from digits. Mind the number can be more than one digit.
+2. The operator `+/-`: We need to calculate the result based on the operator.
+3. `(`: We start to calculate the result inside the parenthese. We have parenthese that we have to calculate first, then sum up the results before and inside the parenthese. Since we need to cache the result and sign, we can use a stack to store the previous result and sign before the parenthese. 
+4. `)`: We finish calculating the result inside the parenthese, we need to sum up the previous result (cached in the stack) and the current result inside the parenthese. 
+
+Here we use a variable `result` for the current evaluation, and we push the previous result and sign before the parenthese to the stack when we meet `(`, then we reset `result` for calculating the result inside the parenthese.
 
 Let's use `9+1-(3+2)-5` as example, we add/substract the number one by one from the beginning, 0 + 9 at first and keep adding (`sign * number`) if we meet operator.
 
-* Nice explanation: https://leetcode.com/problems/basic-calculator/discuss/62361/Iterative-Java-solution-with-stack
+> Nice explanation: https://leetcode.com/problems/basic-calculator/discuss/62361/Iterative-Java-solution-with-stack
 
 ```kotlin
 fun calculate(s: String): Int {
@@ -19,8 +44,8 @@ fun calculate(s: String): Int {
             number = number * 10 + (s[i] - '0')
         } 
         else if (s[i] == '(') {
-            // XXX +/- (
-            // Cache the result XXX and sign before parenthese
+            // XYZ +/- (
+            // Cache the current result XYZ and sign before parenthese
             stack.push(result)
             stack.push(sign)
 

leetcode/225.implement-stack-using-queues.md

@@ -1,5 +1,21 @@
 ## [225. Implement Stack using Queues](https://leetcode.com/problems/implement-stack-using-queues/)
 
+## Clarification Questions
+* No, it's clear from problem description.
+ 
+## Test Cases
+### Normal Cases
+```
+Input: 
+Output: 
+```
+### Edge / Corner Cases
+* 
+```
+Input: 
+Output: 
+```
+
 ```kotlin
 class MyStack() {
 

leetcode/232.implement-queue-using-stacks.md

@@ -1,5 +1,21 @@
 ## [232. Implement Queue using Stacks](https://leetcode.com/problems/implement-queue-using-stacks/)
 
+## Clarification Questions
+* No, it's clear from problem description.
+ 
+## Test Cases
+### Normal Cases
+```
+Input: 
+Output: 
+```
+### Edge / Corner Cases
+* 
+```
+Input: 
+Output: 
+```
+
 We will keep the value stack to be the "right" order in queue.
 
 ```kotlin

leetcode/2866.beautiful-towers-ii.md

@@ -1,5 +1,21 @@
 ## [2866. Beautiful Towers II](https://leetcode.com/problems/beautiful-towers-ii/description/)
 
+## Clarification Questions
+* No, it's clear from problem description.
+ 
+## Test Cases
+### Normal Cases
+```
+Input: 
+Output: 
+```
+### Edge / Corner Cases
+* 
+```
+Input: 
+Output: 
+```
+
 **Idea!!** We iterate `i` from left to right and use `i` as peak to build the highest tower subject to the max height from left to `i` (peak).
 
 ```js

leetcode/316.remove-duplicate-letters.md

@@ -1,5 +1,21 @@
 ## [316. Remove Duplicate Letters](https://leetcode.com/problems/remove-duplicate-letters/description/)
 
+## Clarification Questions
+* No, it's clear from problem description.
+ 
+## Test Cases
+### Normal Cases
+```
+Input: 
+Output: 
+```
+### Edge / Corner Cases
+* 
+```
+Input: 
+Output: 
+```
+
 ### Stack
 ```kotlin
 fun removeDuplicateLetters(s: String): String {

leetcode/394.decode-string.md

@@ -1,5 +1,21 @@
 ## [394. Decode String](https://leetcode.com/problems/decode-string/)
 
+## Clarification Questions
+* No, it's clear from problem description.
+ 
+## Test Cases
+### Normal Cases
+```
+Input: 
+Output: 
+```
+### Edge / Corner Cases
+* 
+```
+Input: 
+Output: 
+```
+
 Let's use `30[a20[bc]d]efg` as example:
 * We iterate all character and determine what the character is.
     * For number digit, we will iterate until we meet `[`. and push the number, for example `123[`, we will parse to be `123` and push `123`.

leetcode/402.remove-k-digits.md

@@ -1,5 +1,21 @@
 ## [402. Remove K Digits](https://leetcode.com/problems/remove-k-digits/description/)
 
+## Clarification Questions
+* No, it's clear from problem description.
+ 
+## Test Cases
+### Normal Cases
+```
+Input: 
+Output: 
+```
+### Edge / Corner Cases
+* 
+```
+Input: 
+Output: 
+```
+
 ### Monotonic Stack
 Given sequence of digits, how can we build the smallest number? Suppose we have digits = `[1, 3, 2]`, then the smallest number would be `123` which is the digits in ascending order.
 

leetcode/496.next-greater-element-i.md

@@ -1,5 +1,21 @@
 ## [496. Next Greater Element I](https://leetcode.com/problems/next-greater-element-i/)
 
+## Clarification Questions
+* No, it's clear from problem description.
+ 
+## Test Cases
+### Normal Cases
+```
+Input: 
+Output: 
+```
+### Edge / Corner Cases
+* 
+```
+Input: 
+Output: 
+```
+
 * We can use monotonic stack (decreasing) to track the next greater element, for example, `[3, 2, 1, 6, 5]` we will push `3`, `2`, `1` but pop `3`, `2`, `1` when encountering `6`, means that the next greater element for `3`, `2`, `1` is `6`.
 * We use hash table to track the item and its next greater element.
 

leetcode/503.next-greater-element-ii.md

@@ -1,5 +1,20 @@
 ## [503. Next Greater Element II](https://leetcode.com/problems/next-greater-element-ii/)
 
+## Clarification Questions
+* No, it's clear from problem description.
+ 
+## Test Cases
+### Normal Cases
+```
+Input: 
+Output: 
+```
+### Edge / Corner Cases
+* 
+```
+Input: 
+Output: 
+```
 ```kotlin
 fun nextGreaterElements(nums: IntArray): IntArray {
     val results = IntArray(nums.size) { _ -> -1 }

leetcode/622.design-circular-queue.md

@@ -1,5 +1,21 @@
 ## [622. Design Circular Queue](https://leetcode.com/problems/design-circular-queue/)
 
+## Clarification Questions
+* No, it's clear from problem description.
+ 
+## Test Cases
+### Normal Cases
+```
+Input: 
+Output: 
+```
+### Edge / Corner Cases
+* 
+```
+Input: 
+Output: 
+```
+
 ```kotlin
 class MyCircularQueue(k: Int) {