feat: write alternative solution

Author: JCPedroza

src/leet-code/0020-valid-parentheses/README.md

@@ -0,0 +1,40 @@
+# Valid Parentheses
+
+Given a string `str` containing just the characters `'('`, `')'`, `'['`, `']'`,
+`'{'`, `'}'`, determine if the string is valid.
+
+* Open brackets must be closed by the same type of brackets.
+* Open brackets must be closed in the correct order.
+* Every close bracket has a corresponding open bracket of the same type.
+* Empty strings are valid strings.
+
+## Function Signature
+
+```typescript
+function hasValidParentheses(str: string): boolean
+```
+
+## Expected Behavior
+
+```
+In: ''
+Out: true
+
+In: '('
+Out: false
+
+In: '()'
+Out: true
+
+In: '(]'
+Out: false
+
+In: '()[]{}'
+Out: true
+
+In: '[{()}]'
+Out: true
+
+In: '([)'
+Out: false
+```

src/leet-code/0020-valid-parentheses/valid-parenth-replace.js

@@ -0,0 +1,33 @@
+const adjacentParens = /\(\)|\{\}|\[\]/g
+
+/**
+ * Validates whether a string contains valid parentheses. Uses the 'replace'
+ * string method.
+ *
+ * Time complexity: O(n^2)
+ * Space complexity: O(n)
+ *
+ * @param {string} str String to be validated.
+ * @returns {boolean} Whether the string contains valid parentheses.
+ */
+const hasValidParentheses = (str) => {
+  if (str.length === 0) return true
+  else if (str.length % 2 !== 0) return false
+
+  let currentStr = str
+  let prevLength
+
+  // Remove adjacent pairs until there are none (until string size doesn't
+  // change)
+  do {
+    prevLength = currentStr.length
+    currentStr = currentStr.replace(adjacentParens, '')
+  } while (currentStr.length < prevLength)
+
+  return currentStr.length === 0
+}
+
+module.exports = {
+  fun: hasValidParentheses,
+  id: 'string-remove'
+}

src/leet-code/0020-valid-parentheses/valid-parenth-stack.js

@@ -5,42 +5,27 @@ const parens = new Map([
   ['{', '}']
 ])
 
-/**
- * Unboxes a string option into a string.
- *
- * @param {string | undefined} str String option to be unboxed.
- * @returns {string} Unboxed string.
- */
-const unboxOption = (str) => {
-  if (str === undefined) throw new Error('string is undefined')
-  return str
-}
-
 /**
  * Validates whether a string contains valid parentheses. Uses a stack.
  *
  * Time complexity: O(n)
  * Space complexity: O(n)
  *
  * @param {string} str String to be validated
- * @returns Whether the string contains valid parentheses.
+ * @returns {boolean} Whether the string contains valid parentheses.
  */
 const hasValidParentheses = (str) => {
-  // Empty string is valid
   if (str.length === 0) return true
-
-  // String of odd length can't be valid
   if (str.length % 2 !== 0) return false
 
   /** @type {string[]} */
   const stack = []
 
-  for (let idx = 0; idx < str.length; idx++) {
-    const currentChar = str[idx]
-
-    if (parens.has(currentChar)) {
-      stack.push(unboxOption(parens.get(currentChar)))
-    } else if (stack.pop() !== currentChar) {
+  for (const char of str) {
+    if (parens.has(char)) {
+      const parChar = parens.get(char)
+      if (parChar !== undefined) stack.push(parChar)
+    } else if (stack.pop() !== char) {
       return false
     }
   }

src/leet-code/0020-valid-parentheses/valid-parenth.repo.js

@@ -1,7 +1,9 @@
 const isParenthStack = require('./valid-parenth-stack')
+const isParenthReplace = require('./valid-parenth-replace')
 
 const solutions = [
-  isParenthStack
+  isParenthStack,
+  isParenthReplace
 ]
 
 module.exports = solutions

src/leet-code/0020-valid-parentheses/valid-parenth.test.js

@@ -33,9 +33,33 @@ for (const { fun, id } of solutions) {
 
     it('identifies valid string of length 4', () => {
       assert.equal(fun('(())'), true)
-      assert.equal(fun('({})'), true)
+      assert.equal(fun('[[]]'), true)
+      assert.equal(fun('{{}}'), true)
+      assert.equal(fun('([])'), true)
+      assert.equal(fun('[][]'), true)
       assert.equal(fun('()[]'), true)
-      assert.equal(fun('()()'), true)
+      assert.equal(fun('{}()'), true)
+    })
+
+    it('identifies invalid string of length 4', () => {
+      assert.equal(fun('(((('), false)
+      assert.equal(fun('))))'), false)
+      assert.equal(fun('{{})'), false)
+      assert.equal(fun('())('), false)
+      assert.equal(fun('][[]'), false)
+    })
+
+    it('identifies valid string of length 6', () => {
+      assert.equal(fun('((()))'), true)
+      assert.equal(fun('[[[]]]'), true)
+      assert.equal(fun('{{{}}}'), true)
+    })
+
+    it('identifies valid large string', () => {
+      assert.equal(
+        fun('({()}[{}]([]))[{{}}]{}((()))'),
+        true
+      )
     })
   })
 }

src/leet-code/0020-valid-parentheses/valid-parenth.time.js

@@ -0,0 +1,10 @@
+const { timeAndReport } = require('../../../lib/time')
+
+const solutions = require('./valid-parenth.repo')
+
+const parensStr = '({()}[{}]([]))[{{}}]{}((()))'
+const args = [parensStr]
+const runs = 100_000
+const id = 'LeetCode 0020 "Valid Parentheses"'
+
+timeAndReport(solutions, args, runs, id)