Oct 2023 hacktoberfest

LeetCode/Algorithms/.vscode/settings.json

@@ -13,6 +13,8 @@
         "initializer_list": "cpp",
         "regex": "cpp",
         "valarray": "cpp",
-        "ostream": "cpp"
+        "ostream": "cpp",
+        "xstring": "cpp",
+        "xlocale": "cpp"
     }
 }

LeetCode/Algorithms/Easy/.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "files.associations": {
+        "xlocale": "cpp"
+    }
+}

LeetCode/Algorithms/Easy/ReverseWordsInAString3.cpp

@@ -0,0 +1,19 @@
+class Solution {
+public:
+    string reverseWords(string s) {
+        stringstream ss(s); 
+
+        string t; 
+        string result = ""; 
+
+        while(getline(ss, t, ' ')) {
+            reverse(t.begin(), t.end()); 
+            result += t + ' ';
+        }
+        return result.substr(0, result.size() - 1); 
+    }
+
+};
+
+// Time Complexity - O(N) 
+// Space Complexity - O(1)

LeetCode/Algorithms/Hard/PaintingTheWalls.cpp

@@ -0,0 +1,25 @@
+// Memoization 
+// Time Complexity - O(N^2)
+// Space Complexity - O(N^2)
+
+class Solution {
+public:
+    int paintWalls(vector<int>& cost, vector<int>& time) {
+
+        return dfs(cost, time, cost.size(), 0); 
+    }
+
+    int dfs(vector<int> &cost, vector<int> &time, int remain, int i) {
+        if(remain <= 0) {
+            return 0; 
+        }
+
+        if(i == cost.size()) {
+            return INT_MAX;
+        }
+
+        int pain = dfs(cost, time, remain - 1 - time[i], i + 1); 
+        int skip = dfs(cost, time, remain, i+1); 
+        return min(pain, skip); 
+    }
+};

LeetCode/Algorithms/Hard/PoorPigs.cpp

@@ -0,0 +1,25 @@
+class Solution {
+public:
+    int poorPigs(int buckets, int minutesToDie, int minutesToTest) {
+        if(buckets-- == 1) {
+            return 0; 
+        }
+
+        // 60 / 15 + 1 = 5 
+        int base = minutesToTest / minutesToDie + 1; 
+
+        // buckets = 5
+        // buckets = 25, take 5 
+        // buckets = buckets>25 and buckets < 125 
+        int res = 0; 
+        while(buckets > 0) {
+            buckets = buckets / base; 
+            res += 1; 
+        }
+        return res; 
+    }   
+};
+
+// Time Complexity - O(log(1000)) ~ O(1)
+// Space Complexity - O(1)
+// Refer to solution from Suchit Dedeja for it 

LeetCode/Algorithms/Hard/RestoreTheArray.cpp

@@ -0,0 +1,45 @@
+class Solution {
+public:
+    int numberOfArrays(string s, int k) {
+        vector<int> dp(s.size(), -1); 
+
+    }
+};
+
+
+arr = [1,3,4,2], 
+
+mat = 
+      0 1 
+0   [[1,4],
+1    [2,3]]
+
+mpr
+
+1 0 
+4 0 
+2 1 
+3 1 
+
+mpc 
+1 0 
+4 1
+2 0 
+3 1
+
+mpr[1] = 0
+mprc[mpr[1]] = 1 
+mpcc[mpc[1]] = 1
+
+mpr[3] = 1
+mpc[3] = 1
+
+mprc[mpr[1]] = 2
+mpcc[mpc[1]] = 2 
+
+mpr[4] = 1 
+mpc[4] = 1
+
+mprc[mpr[1]] = 3 
+mpcc[mpc[1]] = 3; 
+