Added solution for paranthesis.

anxious-coder-lhs · anxious-coder-lhs · commit 5530dcbde8b3 · 2020-10-09T14:06:20.000+05:30
diff --git a/README.md b/README.md
@@ -30,7 +30,7 @@ Happy to accept any contributions to this in any langugage.
 17. Rearrange Sorted Max Min | [Solution](./level_easy/Rearrange_Sorted_Max_Min.js)
 18. String Duplicates | [Solution](./level_easy/String-Duplicates.js)
 19. [String Reversal](./level_easy/string-reversal-README.md) | [Solution](./recursive_pattern/StringReverse_Recursive.js)
-
+20. Valid Paranthesis | [Solution 1](./level_easy/Paranthesis_Mismatch.ts)
 
 ## Medium
 1. [Minimum Remove to Make Valid Paranthesis](https://leetcode.com/problems/minimum-remove-to-make-valid-parentheses/) | [Solution](./level_medium/LeetCode_1249_Medium.ts)
@@ -49,6 +49,7 @@ Happy to accept any contributions to this in any langugage.
 14. [Leet Code 200 Number of Islands](https://leetcode.com/problems/number-of-islands/) | [Solution 1 DFS](./level_medium/LeetCode_200_NumberOfIslands.ts) | [Solution BFS](./level_medium/LeetCode_200_NumberOfIslands_1.ts) | [Solution Union Find](./level_medium/LeetCode_200_NumberOfIslands_2.ts)
 15. [Leet Code 362 Design Hit Counter](https://leetcode.com/problems/design-hit-counter/) | [Solution 1](./level_medium/LeetCode_362_Hit_Counter_1.ts) | [Solution 2](./level_medium/LeetCode_362_Hit_Counter_Medium.ts)
 16. [LeetCode Web Crawler 1242](https://leetcode.com/problems/web-crawler-multithreaded/) | [Solution 1 ](./level_medium/LeetCode_WebCrawler_MultiThreaded_1242.java) | [Solution 2](level_medium/LeetCode_WebCrawler_MultiThreaded_1242_1.java)
+17. [Leet Code 554 Brick Wall](https://leetcode.com/problems/brick-wall/) | [Solution 1](./level_medium/LeetCode_554_Brick_Wall_Medium.ts)
 
 
 ## Hard
diff --git a/level_easy/Paranthesis_Mismatch.ts b/level_easy/Paranthesis_Mismatch.ts
@@ -0,0 +1,65 @@
+/**
+ * Returns true if the string contains equal opening and closing paranthesis in the right order.
+ * The order of the paranthesis should also be maintained.
+ * 
+ * @param str 
+ */
+function isValidParanethesis(str: string) {
+    // Setting up a counter for frequency count of the paranthesis.
+    // For each type of paranthesis, one counter is maintained.
+    const paranthCount: number[] = [0, 0, 0];
+
+    // For each braces, we measure 2 things to see if the order and numbers are same:
+        // If given, positive weight to opening and negative weight to closing braces, we have total 0 weight at end.
+        // If at any step of iteration, the weight didn't go negative. This is essential bcz closing brace cannot come before negative.
+    
+    // As seen in the example, this does not work if the relative order of the braces also needs to be tracked.
+        // Possible solution for that is to use stack based approach of pulling items from the stack and compare.
+    for(let idx = 0; idx < str.length; idx++) {
+        const elem = str[idx]
+        switch (elem) {
+            case "{":
+                paranthCount[0]++
+                break
+            case "}":
+                paranthCount[0]--
+                break
+            case "(":
+                paranthCount[1]++
+                break
+            case ")":
+                paranthCount[1]--
+                break
+            case "[":
+                paranthCount[2]++
+                break
+            case "]":
+                paranthCount[2]--
+                break
+            default:
+                break
+        }
+
+        if (paranthCount[0] < 0 || paranthCount[1] < 0 || paranthCount[2] < 0) return false;
+    }
+
+    return paranthCount[0] === 0 && paranthCount[1] === 0 && paranthCount[2] === 0;
+}
+
+function testParanthMismatch(str: string) {
+    console.log(`Paranthesis for string ${str} is correct: ${isValidParanethesis(str)}`);
+}
+
+
+testParanthMismatch("(((")
+testParanthMismatch("((()))")
+testParanthMismatch("((())))")
+testParanthMismatch("[{}]")
+testParanthMismatch("[{]}")
+
+/**
+ * This is incorrect, this technique only works if we have only one character. Otherwise interleaving characters will
+ * not give correct results.
+ * 
+ */ 
+testParanthMismatch("[{]}")
diff --git a/level_medium/LeetCode_554_Brick_Wall_Medium.ts b/level_medium/LeetCode_554_Brick_Wall_Medium.ts
@@ -0,0 +1,47 @@
+/**
+ * Problem: Leet Code 554.
+ *      There is a brick wall in front of you. Each brick has equal height but might have
+ * different widths. The brick wall is placed with different bricks together,
+ * such that the total width of the entire wall would be equal. Need to find the
+ * draw a vertical line from the top to the bottom such that it passes the least
+ * number of bricks.
+ * 
+ * Complexity: Time - O(B) where B is the total number of bricks.
+ * Complexity: Space - O(M) where M will atmost be the width of the wall(assuming brick size of 1.)
+ * 
+ * Intuition: Frequency Pattern: At a basic level, at each width of size 1 of brick,
+ * we need to figure out the frequency of open pathways. At an optimized level, the
+ * frequency can be identified for each possible brick width, but not for each
+ * width 1. This is a dictionary approach for figuring out the frequency.
+ * 
+ * The pathways (or width size) with the maximum frequency for open pathways is the
+ * solution for us.
+ * 
+ * Solution: Solution calculates all the entry points at any given brick size
+ * position. So, in the worst case if the bricks are of size 1, it will calculate
+ * the possible entry point at each such position. For optimization, we just figure
+ * out the entry point at only positions where we have a brick.
+ * 
+ * @param wall 
+ */
+function leastBricks(wall: number[][]): number {
+    // Use of a map to add openings at each brick size end.
+    const brickWidths: {[k: number]: number} = {}
+    let maxOpenings = 0
+    
+    // Iterate over all the bricks.
+    for (let row = 0; row < wall.length; row++) {
+        let width = 0;
+        for (let col = 0; col < wall[row].length - 1;col++) {
+            // For each brick, calculate the total width.
+            width += wall[row][col]
+            
+            // Increment the number of openings at each width size.
+            brickWidths[width] = brickWidths[width] | 0
+            brickWidths[width]++
+            maxOpenings = Math.max(maxOpenings, brickWidths[width])
+        }
+    }
+    
+    return wall.length - maxOpenings;
+};
