Merge pull request #1970 from Maunish-dave/main

Create 0054-brick-wall.cpp, 0122-best-time-to-buy-and-sell-stock-ii.cpp, Create 1963-minimum-number-of-swaps.cpp

Author: tahsintunan

cpp/0054-brick-wall.cpp

@@ -0,0 +1,42 @@
+ /*
+    Approach: 
+    Store the count of the end of the brick for each row in a hash and keep the track
+    of max number of brick that ends at same position, return rows - max.
+    
+    Time complexity : O(n x m)
+    Space complexity: O(n x m)
+
+    n is number of rows, m is max brick in a row.
+*/
+
+class Solution {
+public:
+    int leastBricks(vector<vector<int>>& wall) {
+
+        map<int,int> end_count;
+        int end_of_brick, max_end_count=0;
+
+        int rows = wall.size(),cols;
+
+        for(int i =0;i<rows;i++){
+            end_of_brick = 0;
+
+            // '-1' because edge of the wall is not considered
+            cols = wall[i].size() -1;
+            for(int j =0;j<cols;j++){
+                end_of_brick += wall[i][j];
+
+                if(end_count.find(end_of_brick)!=end_count.end())
+                {
+                    end_count[end_of_brick]++;
+                }
+                else{
+                    end_count[end_of_brick] = 1;
+                }
+                max_end_count = max(max_end_count,end_count[end_of_brick]);
+            }
+        }
+
+        return rows - max_end_count;
+    }
+};

cpp/0122-best-time-to-buy-and-sell-stock-ii.cpp

@@ -0,0 +1,22 @@
+ /*
+    Approach: 
+    If stock price is going up tomorrow just buy it today and sell it tomorrow.
+    
+    Time complexity : O(n)
+    Space complexity: O(1)
+
+    n is number of days.
+*/
+
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+        int ans =0;
+        
+        // look into the next day and if you are making profit just buy it today.
+        for(int i =1;i<prices.size();i++){
+            if(prices[i]>prices[i-1]) ans += (prices[i]-prices[i-1]);
+        }
+        return ans;
+    }
+};

cpp/1963-minimum-number-of-swaps-to-make-the-string-balanced.cpp

@@ -0,0 +1,46 @@
+/*
+    Approach: 
+    Just check which '[' brackes are wrongly placed correct that bracket.
+    use stack to keep track of bracket
+    
+    Time complexity : O(n)
+    Space complexity: O(n)
+
+    n is length of the string. 
+*/
+
+class Solution {
+public:
+    int minSwaps(string s) {
+
+        int answer=0;
+
+        stack<char> stc;
+        stc.push(']'); 
+
+        int n = s.size();
+
+        for(int i=0;i<n;i++){
+            char top = stc.top();
+
+            if(s[i]==']'){
+
+                // is the '[' bracket correctly placed
+                // if yes then just pop
+                if (top=='[') {
+                    stc.pop();
+                }
+                // if '[' is not correctly placed 
+                // then correct it (push '[') 
+                else{ 
+                    stc.push('[');
+                    answer++;
+                }
+            }
+            else{
+                stc.push('[');
+            }
+        }
+        return answer;
+    }
+};