Merge branch 'master' into tranlsation/hebrew

Author: trekhleb

README.md

@@ -31,7 +31,7 @@ _Read this in other languages:_
 [_Português_](README.pt-BR.md),
 [_Русский_](README.ru-RU.md),
 [_Türkçe_](README.tr-TR.md),
-[_Italiana_](README.it-IT.md),
+[_Italiano_](README.it-IT.md),
 [_Bahasa Indonesia_](README.id-ID.md),
 [_Українська_](README.uk-UA.md),
 [_Arabic_](README.ar-AR.md),
@@ -144,6 +144,8 @@ a set of rules that precisely define a sequence of operations.
 * **Linked Lists**
   * `B` [Straight Traversal](src/algorithms/linked-list/traversal)
   * `B` [Reverse Traversal](src/algorithms/linked-list/reverse-traversal)
+* **Stack**
+  * `B` [Valid Parentheses](src/algorithms/stack/valid-parentheses)  - check if a string has valid parentheses in the correct order
 * **Trees**
   * `B` [Depth-First Search](src/algorithms/tree/depth-first-search) (DFS)
   * `B` [Breadth-First Search](src/algorithms/tree/breadth-first-search) (BFS)
@@ -198,7 +200,7 @@ algorithm is an abstraction higher than a computer program.
 * **Brute Force** - look at all the possibilities and selects the best solution
   * `B` [Linear Search](src/algorithms/search/linear-search)
   * `B` [Rain Terraces](src/algorithms/uncategorized/rain-terraces) - trapping rain water problem
-  * `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach to the top
+  * `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach the top
   * `A` [Maximum Subarray](src/algorithms/sets/maximum-subarray)
   * `A` [Travelling Salesman Problem](src/algorithms/graph/travelling-salesman) - shortest possible route that visits each city and returns to the origin city
   * `A` [Discrete Fourier Transform](src/algorithms/math/fourier-transform) - decompose a function of time (a signal) into the frequencies that make it up
@@ -229,7 +231,7 @@ algorithm is an abstraction higher than a computer program.
   * `B` [Jump Game](src/algorithms/uncategorized/jump-game)
   * `B` [Unique Paths](src/algorithms/uncategorized/unique-paths)
   * `B` [Rain Terraces](src/algorithms/uncategorized/rain-terraces) - trapping rain water problem
-  * `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach to the top
+  * `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach the top
   * `B` [Seam Carving](src/algorithms/image-processing/seam-carving) - content-aware image resizing algorithm
   * `A` [Levenshtein Distance](src/algorithms/string/levenshtein-distance) - minimum edit distance between two sequences
   * `A` [Longest Common Subsequence](src/algorithms/sets/longest-common-subsequence) (LCS)
@@ -242,9 +244,9 @@ algorithm is an abstraction higher than a computer program.
   * `A` [Bellman-Ford Algorithm](src/algorithms/graph/bellman-ford) - finding the shortest path to all graph vertices
   * `A` [Floyd-Warshall Algorithm](src/algorithms/graph/floyd-warshall) - find the shortest paths between all pairs of vertices
   * `A` [Regular Expression Matching](src/algorithms/string/regular-expression-matching)
-* **Backtracking** - similarly to brute force, try to generate all possible solutions, but each time you generate next solution you test
-if it satisfies all conditions, and only then continue generating subsequent solutions. Otherwise, backtrack, and go on a
-different path of finding a solution. Normally the DFS traversal of state-space is being used.
+* **Backtracking** - similarly to brute force, try to generate all possible solutions, but each time you generate the next solution, you test
+if it satisfies all conditions and only then continue generating subsequent solutions. Otherwise, backtrack and go on a
+different path to finding a solution. Normally the DFS traversal of state-space is being used.
   * `B` [Jump Game](src/algorithms/uncategorized/jump-game)
   * `B` [Unique Paths](src/algorithms/uncategorized/unique-paths)
   * `B` [Power Set](src/algorithms/sets/power-set) - all subsets of a set
@@ -254,8 +256,8 @@ different path of finding a solution. Normally the DFS traversal of state-space
   * `A` [Combination Sum](src/algorithms/sets/combination-sum) - find all combinations that form specific sum
 * **Branch & Bound** - remember the lowest-cost solution found at each stage of the backtracking
 search, and use the cost of the lowest-cost solution found so far as a lower bound on the cost of
-a least-cost solution to the problem, in order to discard partial solutions with costs larger than the
-lowest-cost solution found so far. Normally BFS traversal in combination with DFS traversal of state-space
+a least-cost solution to the problem in order to discard partial solutions with costs larger than the
+lowest-cost solution found so far. Normally, BFS traversal in combination with DFS traversal of state-space
 tree is being used.
 
 ## How to use this repository
@@ -295,14 +297,14 @@ rm -rf ./node_modules
 npm i
 ```
 
-Also make sure that you're using a correct Node version (`>=16`). If you're using [nvm](https://github.com/nvm-sh/nvm) for Node version management you may run `nvm use` from the root folder of the project and the correct version will be picked up.
+Also, make sure that you're using the correct Node version (`>=16`). If you're using [nvm](https://github.com/nvm-sh/nvm) for Node version management you may run `nvm use` from the root folder of the project and the correct version will be picked up.
 
 **Playground**
 
 You may play with data-structures and algorithms in `./src/playground/playground.js` file and write
 tests for it in `./src/playground/__test__/playground.test.js`.
 
-Then just simply run the following command to test if your playground code works as expected:
+Then just, simply run the following command to test if your playground code works as expected:
 
 ```
 npm test -- 'playground'
@@ -318,7 +320,7 @@ npm test -- 'playground'
 ### Big O Notation
 
 *Big O notation* is used to classify algorithms according to how their running time or space requirements grow as the input size grows.
-On the chart below you may find most common orders of growth of algorithms specified in Big O notation.
+On the chart below, you may find the most common orders of growth of algorithms specified in Big O notation.
 
 ![Big O graphs](./assets/big-o-graph.png)
 

src/algorithms/stack/valid-parentheses/README.md

@@ -0,0 +1,44 @@
+# Valid Parentheses Problem
+
+Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.
+
+An input string is valid if:
+
+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.
+ 
+
+Example 1:
+
+`Input: s = "()"`
+
+Output: true
+
+Example 2:
+
+`Input: s = "()[]{}"`
+
+Output: true
+
+Example 3:
+
+`Input: s = "(]"`
+
+Output: false
+
+This is actually a very common interview question and a very good example of how to use a stack data structure to solve problems. 
+
+## Solution
+The problem can be solved in two ways
+
+### Bruteforce Approach
+We can iterate through the string and then for each character in the string, we check for it's last closing character in the the string. Once we find the last closing character in the string, we remove both characters and then repeat the iteration, if we don't find a closing character for an opening character, then the string is invalid. The time complexity of this would be O(n^2) which is not so efficient.
+
+### Using a Stack
+We can use a hashtable to store all opening characters and the value would be the respective closing character. We can then iterate through the string and if we encounter an opening parantheses, we push it's closing character to the stack. If we ecounter a closing paraentheses, then we pop the stack and confirm that the popped element is equal to the current closing parentheses character. If it is not then the string is invalid. At the end of the iteration, we also need to check that the stack is empty. If it is not then the string is invalid. If it is, then the string is valid. This is a more efficient approach with a Time complexity and Space complexity of O(n).
+
+
+## References
+
+- [Leetcode](https://leetcode.com/problems/valid-parentheses/)

src/algorithms/stack/valid-parentheses/__test__/validParentheses.test.js

@@ -0,0 +1,23 @@
+import isValid from '../validParentheses';
+
+describe('validParentheses', () => {
+  it('should return false when string is empty', () => {
+    expect(isValid('')).toBe(false);
+  });
+
+  it('should return true when string contains valid parentheses in correct order', () => {
+    expect(isValid('()')).toBe(true);
+    expect(isValid('()[]{}')).toBe(true);
+    expect(isValid('((({[]})))')).toBe(true);
+  });
+
+  it('should return false when string contains invalid parentheses', () => {
+    expect(isValid('(]')).toBe(false);
+    expect(isValid('()[]{} }')).toBe(false);
+    expect(isValid('((({[(]})))')).toBe(false);
+  });
+
+  it('should return false when string contains valid parentheses in wrong order', () => {
+    expect(isValid('({)}')).toBe(false);
+  });
+});

src/algorithms/stack/valid-parentheses/validParentheses.js

@@ -0,0 +1,42 @@
+import Stack from '../../../data-structures/stack/Stack';
+import HashTable from '../../../data-structures/hash-table/HashTable';
+
+// Declare hashtable containg opening parentheses as key and it's closing parentheses as value.
+const hashTable = new HashTable(3);
+hashTable.set('{', '}');
+hashTable.set('(', ')');
+hashTable.set('[', ']');
+
+/**
+ * Check if string has valid parentheses.
+ *
+ * @param {string} parenthesesString
+ * @return {boolean}
+ */
+export default function isValid(parenthesesString) {
+  // If string is empty return false
+  if (parenthesesString.length === 0) {
+    return false;
+  }
+  // Create stack
+  const stack = new Stack();
+
+  // Loop through each character of string
+  for (let i = 0; i < parenthesesString.length; i += 1) {
+    const currentCharacter = parenthesesString[i];
+    // If character is opening parentheses push it's closing parentheses to stack
+    if (hashTable.has(currentCharacter)) {
+      stack.push(hashTable.get(currentCharacter));
+    } else {
+      /* If character is a closing parentheses then,:
+      check If stack is empty, if it is return false.
+      if stack is not empty, pop from stack and compare it with current character.
+      If they are not same return false. */
+      if (stack.isEmpty() || stack.pop() !== currentCharacter) {
+        return false;
+      }
+    }
+  }
+  // If stack is empty return true else return false
+  return stack.isEmpty();
+}