[PDKhan] WEEK 01 solutions

contains-duplicate/PDKhan.cpp

@@ -0,0 +1,15 @@
+class Solution {
+    public:
+        bool containsDuplicate(vector<int>& nums) {
+            unordered_map<int, int> map;
+
+            for(int i = 0; i < nums.size(); i++){
+                map[nums[i]]++;
+
+                if(map[nums[i]] == 2)
+                    return true;
+            }
+
+            return false;
+        }
+    };

house-robber/PDKhan.cpp

@@ -0,0 +1,22 @@
+class Solution {
+    public:
+        int rob(vector<int>& nums) {
+            int n = nums.size();
+
+            if(n == 0) return 0;
+            if(n == 1) return nums[0];
+            if(n == 2) return max(nums[0], nums[1]);
+
+            int prev2 = nums[0];
+            int prev1 = max(nums[0], nums[1]);
+
+
+            for(int i = 2; i < n; i++){
+                int curr = max(prev1, prev2 + nums[i]);
+                prev2 = prev1;
+                prev1 = curr;
+            }
+
+            return prev1;
+        }
+    };

longest-consecutive-sequence/PDKhan.cpp

@@ -0,0 +1,30 @@
+class Solution {
+    public:
+        int longestConsecutive(vector<int>& nums) {
+            int cnt = 1;
+            int max = 0;
+
+            if(nums.size() == 0)
+                return 0;
+
+            sort(nums.begin(), nums.end());
+
+            for(int i = 1; i < nums.size(); i++){
+                if(nums[i] == nums[i-1] + 1)
+                    cnt++;
+                else if(nums[i] == nums[i-1])
+                    continue;
+                else{
+                    if(max < cnt)
+                        max = cnt;
+
+                    cnt = 1;
+                }
+            }
+
+            if(max < cnt)
+                return cnt;
+
+            return max;
+        }
+    };

top-k-frequent-elements/PDKhan.cpp

@@ -0,0 +1,26 @@
+class Solution {
+    public:
+        vector<int> topKFrequent(vector<int>& nums, int k) {
+            unordered_map<int, int> map;
+            vector<int> result;
+
+            for(int i = 0; i < nums.size(); i++){
+                map[nums[i]]++;
+            }
+
+            priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int,int>>> minHeap;
+
+            for(auto i : map){
+                minHeap.push({i.second, i.first});
+                if(minHeap.size() > k)
+                    minHeap.pop();
+            }
+
+            while(!minHeap.empty()){
+                result.push_back(minHeap.top().second);
+                minHeap.pop();
+            }
+
+            return result;
+        }
+    };

two-sum/PDKhan.cpp

@@ -0,0 +1,18 @@
+class Solution {
+    public:
+        vector<int> twoSum(vector<int>& nums, int target) {
+            unordered_map<int, int> Map;
+
+            for(int i = 0; i < nums.size(); i++){
+                int diff = target - nums[i];
+
+                if(Map.find(diff) != Map.end()){
+                    return { Map[diff], i };
+                }
+
+                Map[nums[i]] = i;
+            }
+
+            return {};
+        }
+    };