[PDKhan] WEEK 05 solutions

best-time-to-buy-and-sell-stock/PDKhan.cpp

@@ -0,0 +1,16 @@
+class Solution {
+    public:
+        int maxProfit(vector<int>& prices) {
+            int min = INT_MAX;
+            int profit = 0;
+
+            for(int i = 0; i < prices.size(); i++){
+                if(prices[i] < min)
+                    min = prices[i];
+
+                profit = max(profit, prices[i] - min);
+            }
+
+            return profit;
+        }
+    };

encode-and-decode-strings/PDKhan.cpp

@@ -0,0 +1,43 @@
+class Solution {
+    public:
+        /*
+         * @param strs: a list of strings
+         * @return: encodes a list of strings to a single string.
+         */
+        string encode(vector<string> &strs) {
+            // write your code here
+            string code;
+
+            for(const string& s : strs){
+                code += to_string(s.size()) + ":" + s;
+            }
+
+            return code;
+        }
+
+        /*
+         * @param str: A string
+         * @return: decodes a single string to a list of strings
+         */
+        vector<string> decode(string &str) {
+            // write your code here
+            vector<string> result;
+            int i;
+
+            while(i < str.size()){
+                int j = i;
+
+                while(str[j] != ':') 
+                    j++;
+
+                int len = stoi(str.substr(i, j - i);
+                string word = str.substr(j + 1, len);
+
+                result.push_back(word);
+
+                i = j + 1 + len;
+            }
+
+            return result;
+        }
+    };

group-anagrams/PDKhan.cpp

@@ -0,0 +1,20 @@
+class Solution {
+    public:
+        vector<vector<string>> groupAnagrams(vector<string>& strs) {
+            unordered_map<string, vector<string>> map;
+            vector<vector<string>> result;
+
+            for(const string& s : strs){
+                string key = s;
+                sort(key.begin(), key.end());
+
+                map[key].push_back(s);
+            }
+
+            for(auto& pair : map){
+                result.push_back(pair.second);
+            }
+
+            return result;
+        }
+    };

implement-trie-prefix-tree/PDKhan.cpp

@@ -0,0 +1,67 @@
+class TrieNode{
+    public:
+        TrieNode* children[26];
+        bool isEnd;
+
+        TrieNode() {
+            isEnd = false;
+
+            for(int i = 0; i < 26; i++)
+                children[i] = nullptr;
+        }
+    };
+
+    class Trie {
+    public:
+        TrieNode* root;
+
+        Trie() {
+            root = new TrieNode();
+        }
+
+        void insert(string word) {
+            TrieNode* node = root;
+
+            for(char ch : word){
+                int index = ch - 'a';
+
+                if(node->children[index] == nullptr){
+                    node->children[index] = new TrieNode();
+                }
+
+                node = node->children[index];
+            }
+
+            node->isEnd = true;
+        }
+
+        bool search(string word) {        
+            TrieNode* node = root;
+
+            for(char ch : word){
+                int index = ch - 'a';
+
+                if(node->children[index] == nullptr)
+                    return false;
+
+                node = node->children[index];
+            }
+
+            return node->isEnd;
+        }
+
+        bool startsWith(string prefix) {
+            TrieNode* node = root;
+
+            for(char ch : prefix){
+                int index = ch - 'a';
+
+                if(node->children[index] == nullptr)
+                    return false;
+
+                node = node->children[index];
+            }
+
+            return true;
+        }
+    };

word-break/PDKhan.cpp

@@ -0,0 +1,21 @@
+class Solution {
+    public:
+        bool wordBreak(string s, vector<string>& wordDict) {
+            vector<bool> dp(s.length()+1, false);
+
+            dp[0] = true;
+
+            for(int i = 1; i <= s.length(); i++){
+                for(string& word : wordDict){
+                    int len = word.length();
+                    if(i - len >= 0 && s.substr(i-len, len) == word)
+                        dp[i] = dp[i - len];
+
+                    if(dp[i])
+                        break;
+                }
+            }
+
+            return dp[s.length()];
+        }
+    };