stack problem and solution

Author: amejiarosario

book/D-interview-questions-solutions.asc

@@ -95,13 +95,18 @@ include::interview-questions/buy-sell-stock.js[tag=solution]
 
 The runtime is `O(n)` and a space complexity of `O(1)`.
 
+
+
 :leveloffset: +1
 
 === Solutions for Linked List Questions
 (((Interview Questions Solutions, Linked Lists)))
 
 :leveloffset: -1
 
+
+
+
 [#linkedlist-q-merge-lists]
 include::content/part02/linked-list.asc[tag=linkedlist-q-merge-lists]
 
@@ -170,14 +175,57 @@ include::interview-questions/linkedlist-same-data.js[tag=description]
 include::interview-questions/linkedlist-same-data.js[tag=solution]
 ----
 
-IMPLEMENTATION NOTES
+The function `findNextPointerIndex` is a helper to navigate each character on a linked list.
+Notice, that we increase the index (`i + 1`) on each iteration.
+If the index overflows, it moves to the next node and reset the index to zero.
+
+
 
 *Complexity Analysis*:
 
 - Time: `O(n)`. We go over all the characters on each lists
 - Space: `O(1)`. Only using pointers and no auxiliary data structures.
 
 
+
+:leveloffset: +1
+
+=== Solutions for Stack Questions
+(((Interview Questions Solutions, Stack)))
+
+:leveloffset: -1
+
+[#stack-q-valid-parentheses]
+include::content/part02/stack.asc[tag=stack-q-valid-parentheses]
+
+We need to validate that brackets are properly opened and closed, following these rules:
+- An opened bracket must be close by the same type.
+- Open brackets mush be closed in the corrent order.
+
+This is a parsing problem and usually stacks are a good candidates for them.
+
+*Algorithm*:
+
+- Create a mapping of opening bracket with its closing bracket
+- Iterate through the string
+    - When we found an opening bracket, insert the corresponding closing bracket into the stack.
+    - When we found a closing bracket, pop from the stack and make sure it correspond to the current character.
+- Check the stack is empty. If there's a leftover, it means that something didn't close properly.
+
+*Implementation*:
+
+[source, javascript]
+----
+include::interview-questions/valid-parentheses.js[tag=description]
+include::interview-questions/valid-parentheses.js[tag=solution]
+----
+
+*Complexity Analysis*:
+
+- Time: `O(n)`. We iterate over each character of the string.
+- Space: `O(n)`. We use an auxiliary stack.
+
+
 // [#linkedlist-q-TAG]
 // include::content/part02/linked-list.asc[tag=linkedlist-q-TAG]
 

book/content/part02/stack.asc

@@ -85,3 +85,22 @@ Implementing the stack with an array and linked list would lead to the same time
 // end::table[]
 
 It's not very common to search for values on a stack (other Data Structures are better suited for this). Stacks are especially useful for implementing <>.
+
+
+==== Interview Questions
+(((Interview Questions, Arrays)))
+
+// tag::stack-q-valid-parentheses[]
+===== Validate Parentheses / Braces / Brackets
+
+*ST-1*) _Given an string with 3 types of brakets: `()`, `{}`, and `[]`. Validate they are properly closed and opened._
+// end::stack-q-valid-parentheses[]
+
+[source, javascript]
+----
+include::../../interview-questions/valid-parentheses.js[tag=description]
+  // write you code here
+}
+----
+
+_Solution: <>_

book/interview-questions/valid-parentheses.js

@@ -0,0 +1,27 @@
+// tag::description[]
+/**
+ * Validate if the parentheses are opened and closed in the right order.
+ *
+ * @example
+ *  isParenthesesValid('(){}[]'); // true
+ *  isParenthesesValid('([{}])'); // true
+ *  isParenthesesValid('([{)}]'); // false
+ *
+ * @param {string} string - The string
+ */
+function isParenthesesValid(string) {
+  // end::description[]
+  // tag::solution[]
+  const map = new Map([['(', ')'], ['{', '}'], ['[', ']']]);
+  const stack = [];
+
+  for (const c of string) {
+    if (map.has(c)) stack.push(map.get(c));
+    else if (c !== stack.pop()) return false;
+  }
+
+  return stack.length === 0;
+}
+// end::solution[]
+
+module.exports = { isParenthesesValid };

book/interview-questions/valid-parentheses.spec.js

@@ -0,0 +1,23 @@
+const { isParenthesesValid } = require('./valid-parentheses');
+
+describe('Stack: Valid Parentheses', () => {
+  it('should be valid', () => {
+    expect(isParenthesesValid('()')).toEqual(true);
+  });
+
+  it('should be valid with different kinds', () => {
+    expect(isParenthesesValid('()[]{}')).toEqual(true);
+  });
+
+  it('should be valid with different nested kinds', () => {
+    expect(isParenthesesValid('([{}])')).toEqual(true);
+  });
+
+  it('should not be valid if incomplete', () => {
+    expect(isParenthesesValid('()(')).toEqual(false);
+  });
+
+  it('should not be valid if invalid character is present', () => {
+    expect(isParenthesesValid('()-')).toEqual(false);
+  });
+});