Committed

Author: rachitvk

Leetcode/ImplementMagicDictionary.cpp

@@ -0,0 +1,40 @@
+class MagicDictionary {
+public:
+    /** Initialize your data structure here. */
+    MagicDictionary() {
+        
+    }
+    
+    /** Build a dictionary through a list of words */
+    void buildDict(vector<string> dict) {
+        for(int i=0;i<dict.size();i++)
+            words.insert(dict[i]);
+    }
+    
+    /** Returns if there is any word in the trie that equals to the given word after modifying exactly one character */
+    bool search(string word) {
+         
+        for(int i=0;i<word.length();i++){
+            string temp=word;
+            for(int j=0;j<26;j++){
+                temp[i]='a'+ j;
+                if(words.find(temp)!=words.end() && temp!=word){
+                  return true;
+                }
+            }
+        }
+        return false;
+    }
+    
+    private :
+        unordered_set<string>words;
+};
+
+
+
+/**
+ * Your MagicDictionary object will be instantiated and called as such:
+ * MagicDictionary obj = new MagicDictionary();
+ * obj.buildDict(dict);
+ * bool param_2 = obj.search(word);
+ */

Leetcode/IntervalListIntersections.cpp

@@ -0,0 +1,35 @@
+/**
+ * Definition for an interval.
+ * struct Interval {
+ *     int start;
+ *     int end;
+ *     Interval() : start(0), end(0) {}
+ *     Interval(int s, int e) : start(s), end(e) {}
+ * };
+ */
+class Solution {
+public:
+    vector<Interval> intervalIntersection(vector<Interval>& A, vector<Interval>& B) {
+        
+        int i=0;
+        int j=0;
+        
+        vector<Interval>ans;
+        
+        while(i<A.size() && j<B.size()){
+           int l=max(A[i].start,B[j].start);
+           int r=min(A[i].end,B[j].end);
+            
+            if(l<=r)
+                ans.push_back(Interval(l,r));
+            
+            if(A[i].end < B[j].end)
+                i++;
+            else
+                j++;
+        }
+        
+        return ans;
+        
+    }
+};

Leetcode/KDifferentPairsInArray.cpp

@@ -0,0 +1,41 @@
+class Solution {
+public:
+    int findPairs(vector<int>& nums, int k) {
+        unordered_set<int>s;
+        unordered_set<int>t;
+        
+        
+        for(int i=0;i<nums.size();i++){
+            s.insert(nums[i]);
+        }
+        
+        
+        int ans=0;
+        
+        if(k<0)
+            return 0;
+        
+        if(k==0){
+           unordered_map<int,int>mp;
+            
+            for(int i=0;i<nums.size();i++){
+                mp[nums[i]]++;
+                if(mp[nums[i]]==2)
+                    ans++;
+            }
+            return ans;
+        }
+        
+        for(auto itr=s.begin();itr!=s.end();itr++){
+            int c=*itr;
+            
+            if(t.find(c+k)!=t.end())
+                ans++;
+            if(t.find(c-k)!=t.end())
+                ans++;
+            t.insert(c);
+        }
+        
+        return ans;
+    }
+};

Leetcode/MaxChunksToSortArray1.cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+    int maxChunksToSorted(vector<int>& arr) {
+        int ans=0;
+        
+        int last=-1;
+        int mx=-1;
+        int mn=0;
+        
+        for(int i=0;i<arr.size();i++){
+            mx=max(mx,arr[i]);
+            
+        
+            if(mx-mn+1 == (i-last)){
+                ans++;
+                mn=i+1;
+                last=i;
+            }
+        }
+        
+        return ans;
+    }
+};

Leetcode/MergeTrees.cpp

@@ -0,0 +1,35 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
+          if(!t1 && !t2)
+              return NULL;
+         if(t1 && !t2){
+              TreeNode* r=new TreeNode(t1->val);
+              r->left=mergeTrees(t1->left,t2);
+              r->right=mergeTrees(t1->right,t2);
+             return r;
+         }
+         else if(!t1 && t2){
+             TreeNode* r=new TreeNode(t2->val);
+             r->left=mergeTrees(t1,t2->left);
+             r->right=mergeTrees(t1,t2->right);
+             return r;
+         }
+         else{
+            TreeNode* r=new TreeNode(t1->val+t2->val);
+            r->left=mergeTrees(t1->left,t2->left);
+            r->right=mergeTrees(t1->right,t2->right);
+             return r;
+         }
+        return NULL;
+    }
+};

Leetcode/MinAbsoluteDifferenceInBST.cpp

@@ -0,0 +1,35 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    
+    vector<int>v;
+    
+    void helper(TreeNode* root){
+        if(!root)
+            return;
+        helper(root->left);
+        v.push_back(root->val);
+        helper(root->right);
+    }
+    
+    int getMinimumDifference(TreeNode* root) {
+        helper(root);
+        
+        int ans=INT_MAX;
+        int n=v.size();
+        
+        for(int i=0;i<n-1;i++){
+            ans=min(ans,v[i+1]-v[i]);
+        }
+        
+        return ans;
+    }
+};

Leetcode/PancakeSorting.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    vector<int> pancakeSort(vector<int>& A) {
+        vector<int>ans;
+        
+        for(int i=0;i<A.size();i++){
+            int mp=max_element(A.begin(),A.end()-i)-A.begin();
+            ans.push_back(mp+1);
+            ans.push_back(A.size()-i);
+            reverse(A.begin(),A.begin()+mp+1);
+            reverse(A.begin(),A.end()-i);
+        }
+                
+        return ans;
+    }
+};

Leetcode/ScoreOfParantheses.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int scoreOfParentheses(string s) {
+        
+        int ans=0;
+        int multiplier=0;
+        
+        for(int i=0;i<s.length();i++){
+                    
+            if(s[i]=='(')
+                multiplier++;
+            else{
+                multiplier--;
+                if(s[i-1]=='(')
+                    ans+=1 << multiplier;
+            }
+        }
+        
+        return ans;
+    }
+};

Leetcode/SearchInBinaryTree.cpp

@@ -0,0 +1,23 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* searchBST(TreeNode* root, int val) {
+        if(!root)
+            return NULL;
+        
+        if(root->val > val)
+            return searchBST(root->left,val);
+        if(root->val < val)
+            return searchBST(root->right,val);
+        
+        return root;
+    }
+};