Merge pull request #43 from komalreddy3/valid_parantheses

Added a Algorithm named Valid parentheses

Author: tejas-2232

15. Valid Parentheses/validParentheses.js

@@ -0,0 +1,52 @@
+// INTRODUCTION 
+
+// Javascript implementation to check if string has valid number of parentheses
+
+// THE CHALLENGE 
+
+// check whether the string has valid number of parentheses or not 
+
+// ALGORITHMIC THINKING 
+
+
+// 1. Initialize an empty stack:
+// 1.1 Create an empty array called stack to serve as the stack.
+
+// 2 Iterate through each character in the input string:
+// 2.1 Use a for...of loop to iterate through each character (ch) in the given string (s).
+
+// 3. Check for opening brackets:
+// 3.1 If the current character is an opening bracket ('(', '{', '['), push it onto the stack.
+
+// 4. Check for closing brackets:
+// 4.1 If the current character is a closing bracket (')', '}', ']'):
+// 4.1.1 Check if the stack is empty. If so, return false, as there is no matching opening bracket.
+// 4.1.2 Check if the top of the stack matches the corresponding opening bracket. If not, return false.
+// 4.1.3 If the brackets match, pop the top element from the stack.
+
+// 5. Check for remaining elements in the stack:
+// 5.1 After processing all characters in the input string, check if there are any remaining elements in the stack.
+// 5.1.1 If the stack is empty, return true, indicating a valid string.
+// 5.1.2 If the stack is not empty, return false, indicating an invalid string.
+
+
+// CODE IMPLEMENTATION
+
+function validString (s){
+    let stack=[];
+    for(let ch of s){
+        if(ch=='(' || ch=='{' || ch=='[') stack.push(ch);
+        else{
+            if(!stack.length || (ch==')' && stack[stack.length-1]!=='(') || (ch==']' && stack[stack.length-1]!=='[') || (ch=='}' && stack[stack.length-1]!=='{')) return false;
+            else stack.pop();
+        }
+    }
+    if(stack.length==0) return true;
+    else return false;
+}
+
+if(validString("()]")){
+    console.log("Its a valid string");
+}else{
+    console.log("Its not a valid string");
+}

README.md

@@ -1649,4 +1649,151 @@ __code Implementation:__ <p>
 
 
 <hr>
-<hr>
+<hr>
+
+<b>15. Valid Parentheses </b>
+
+<p> Valid parentheses refer to a sequence of parentheses – including round brackets (), square brackets [], and curly braces {} – that is properly nested and closed. In a valid expression, each opening parenthesis has a corresponding closing parenthesis, and they are arranged in a balanced manner.</p>
+
+<p> Valid parentheses play a crucial role in programming, especially in expressions and syntax. Properly balanced parentheses are essential to ensure that code is interpreted correctly and avoids errors.</p>
+
+__The challenge:__ <p> - 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.</p> 
+
+```js 
+s="()"
+output = Its a valid string
+
+s="()]"
+output= Its not a valid string
+```
+
+__Algorithmic Thinking:__ <p>1. Initialize an empty stack:
+1.1  Create an empty array called stack to serve as the stack.
+
+2 Iterate through each character in the input string:
+2.1 Use a for...of loop to iterate through each character (ch) in the given string (s).
+
+3. Check for opening brackets:
+3.1 If the current character is an opening bracket ('(', '{', '['), push it onto the stack.
+
+4. Check for closing brackets:
+4.1 If the current character is a closing bracket (')', '}', ']'):
+4.1.1 Check if the stack is empty. If so, return false, as there is no matching opening bracket.
+4.1.2 Check if the top of the stack matches the corresponding opening bracket. If not, return false.
+4.1.3 If the brackets match, pop the top element from the stack.
+
+5. Check for remaining elements in the stack:
+5.1 After processing all characters in the input string, check if there are any remaining elements in the stack.
+5.1.1 If the stack is empty, return true, indicating a valid string.
+5.1.2 If the stack is not empty, return false, indicating an invalid string.
+</p>
+
+
+__code Implementation:__ <p> 
+Step 1: Initialize an empty stack
+
+    ```js 
+    let stack = [];
+    ```
+
+ Step 2: Iterate through each character in the input string
+
+ Step 3: Check for opening brackets
+
+    ```js 
+    if (ch == '(' || ch == '{' || ch == '[') {
+            stack.push(ch); // Push opening bracket onto the stack
+     }
+    ```
+
+Step 4: Check for closing brackets 
+
+    ```js
+   else {
+            // Step 4: Check for closing brackets
+            if (
+                !stack.length ||
+                (ch == ')' && stack[stack.length - 1] !== '(') ||
+                (ch == ']' && stack[stack.length - 1] !== '[') ||
+                (ch == '}' && stack[stack.length - 1] !== '{')
+            ) {
+                return false; // Invalid string, mismatched brackets
+            } else {
+                stack.pop(); // Pop the matching opening bracket from the stack
+            }
+        }
+    ```
+
+Step 5: Check for remaining elements in the stack
+
+
+    ```js
+    if (stack.length == 0) {
+        return true; // Valid string, all brackets matched
+    } else {
+        return false; // Invalid string, unmatched opening brackets
+    }
+    ```
+
+Step 6. Example Usage
+
+    ```js
+    if (validString("()]")) {
+    console.log("It's a valid string");
+    } else {
+    console.log("It's not a valid string");
+    }
+    ```
+Let's Implement
+
+ ```js
+  function validString(s) {
+    // Step 1: Initialize an empty stack
+    let stack = [];
+
+    // Step 2: Iterate through each character in the input string
+    for (let ch of s) {
+        // Step 3: Check for opening brackets
+        if (ch == '(' || ch == '{' || ch == '[') {
+            stack.push(ch); // Push opening bracket onto the stack
+        } else {
+            // Step 4: Check for closing brackets
+            if (
+                !stack.length ||
+                (ch == ')' && stack[stack.length - 1] !== '(') ||
+                (ch == ']' && stack[stack.length - 1] !== '[') ||
+                (ch == '}' && stack[stack.length - 1] !== '{')
+            ) {
+                return false; // Invalid string, mismatched brackets
+            } else {
+                stack.pop(); // Pop the matching opening bracket from the stack
+            }
+        }
+    }
+
+    // Step 5: Check for remaining elements in the stack
+    if (stack.length == 0) {
+        return true; // Valid string, all brackets matched
+    } else {
+        return false; // Invalid string, unmatched opening brackets
+    }
+}
+
+// Step 6: Example usage
+if (validString("()]")) {
+    console.log("It's a valid string");
+} else {
+    console.log("It's not a valid string");
+}
+ ```
+</p>
+
+
+<hr>
+<hr>