Updated repository structure

Author: avidLearnerInProgress

01matrix.py

@@ -0,0 +1,27 @@
+class Solution:
+     def updateMatrix(self, A: List[List[int]]) -> List[List[int]]:
+        def validNeighbours(i, j, d):
+            for dx, dy in (1, 0), (-1, 0), (0, 1), (0, -1):
+                ni, nj, dn = i + dx, j + dy, d + 1
+                if 0 <= ni < len(A) and 0 <= nj < len(A[0]):
+                    yield ni, nj, dn
+               
+        def bfs(i, j):
+            dist = collections.defaultdict(lambda: float('inf'))
+            queue = collections.deque([(i, j, 0)])
+            while queue:
+                i, j, d = queue.popleft()
+                if A[i][j] == 0:
+                    return d
+                for ni, nj, dn in validNeighbours(i, j, d):
+                    if dn < dist[(ni, nj)]:
+                        dist[(ni, nj)] = dn
+                        queue.append((ni, nj, dn))
+            return A[i][j]
+           
+       
+        for i in range(len(A)):
+            for j in range(len(A[0])):
+                if A[i][j] == 1:
+                    A[i][j] = bfs(i, j)    
+        return A

23.intervalList.cpp

@@ -0,0 +1,13 @@
+class Solution {
+public:
+    vector<vector<int>> intervalIntersection(vector<vector<int>>& A, vector<vector<int>>& B) {
+        vector<vector<int>> res;
+        for(int i = 0, j = 0; i < A.size() && j < B.size();) {
+            int lo = max(A[i][0], B[j][0]), hi = min(A[i][1], B[j][1]);
+            if(lo <= hi) res.push_back({lo, hi});
+	        if(hi == A[i][1]) i++;
+	        else j++;
+        }
+        return res;
+    }
+};x

30-days-of-code-may/01.firstBadVersion.cpp

@@ -0,0 +1,22 @@
+// The API isBadVersion is defined for you.
+// bool isBadVersion(int version);
+
+class Solution {
+public:
+    int firstBadVersion(int n) {
+       
+        int start = 1, end = n, mid;
+        
+        while(start < end){
+            
+            mid = start + (end - start)/2;
+            if(isBadVersion(mid)){
+                end = mid;
+            }
+            else{
+                start = mid + 1;
+            }
+        }
+        return start;
+    }
+};

30-days-of-code-may/02.jewelAndStones.cpp

@@ -0,0 +1,22 @@
+class Solution {
+public:
+    int numJewelsInStones(string J, string S) {
+        if(J.size() == 0 or S.size() == 0) return 0;
+        
+        map<char, int> stones;
+        
+        for(int i=0; i<S.size();i++){
+            if(stones.find(S[i]) == stones.end())
+                stones[S[i]] = 1;
+            else
+                stones[S[i]]++;
+        }
+        int c = 0;
+        for(char j:J){
+            if(stones.find(j) != stones.end()){
+                c+=stones[j];
+            }
+        }
+        return c;
+    }
+};

30-days-of-code-may/03.ransomNote.cpp

@@ -0,0 +1,18 @@
+
+class Solution {
+public:
+    bool canConstruct(string ransomNote, string magazine) {
+        
+        map<int,int> mp;
+        
+        for(char m : magazine)
+            mp[m-'a']++;
+        
+        for(char r : ransomNote){
+            if(--mp[r-'a'] < 0)
+                return false;
+            
+        }
+        return true;
+    }
+};

30-days-of-code-may/04.numberComplement.cpp

@@ -0,0 +1,42 @@
+class Solution {
+public:
+    int findComplement(int num) {
+      
+        
+        if(num == 0) return 0;
+        vector<int> bits;
+        
+        while(num != 0){
+            bits.push_back(num % 2);    
+            num /= 2;
+        }
+        //for(auto i : bits)cout<<i<<" ";
+        //cout<<"\n";
+        
+        reverse(bits.begin(), bits.end());
+        
+        //for(auto i : bits)cout<<i<<" ";
+        vector<int> complement;
+        for(auto i : bits){
+            if(i == 0)
+                complement.push_back(1);
+            else
+                complement.push_back(0);
+        }
+        
+        //cout<<"\n";
+        //for(auto i : complement)cout<<i<<" ";
+        
+        int sz = complement.size()- 1;
+        unsigned int complement_no = 0;
+        for(int i=sz; i>=0; i--){
+            //cout<<"sz-i: "<<sz-i<<"\t";
+            int expr = (complement[i] * pow(2, (sz- i)));
+            //cout<<expr<<"\t\n";
+            complement_no += expr;
+        }
+        
+        //cout<<complement_no<<"\n";
+        return complement_no;
+    }
+};

30-days-of-code-may/05.firstUniqueCharString.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int firstUniqChar(string s) {
+        
+        if(s.size() == 0) return -1;
+        
+        map<char, int> mp;
+        for(auto ch : s)
+            mp[ch]++;
+        
+        for(int i=0; i<s.size(); i++){
+                if(mp[s[i]] == 1){
+                    return i;
+                }
+        }
+        return -1;
+    }
+};

30-days-of-code-may/06.majorityElement.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int majorityElement(vector<int>& nums) {
+        if(nums.size() == 0) return 0;
+
+        map<int, int> hash;
+        for(auto num : nums)
+            hash[num]++;
+        int sz = nums.size();
+        
+        for(auto const& p : hash){
+            if(p.second > sz/2){
+                return p.first;
+            }
+        }
+        return -1;
+    }
+};

30-days-of-code-may/07.cousinsInBinaryTree.cpp

@@ -0,0 +1,33 @@
+/**
+ * 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:
+    int parent_x = -1, parent_y = -1, depth_x = -1, depth_y = -1, x, y;
+    
+    void findDepthAndCheckParent(TreeNode* root, int depth) {
+        if(root == NULL) return;
+        if(root->left && root->left->val == x || root->right && root->right->val == x) parent_x = root->val;
+        
+        if(root->left && root->left->val == y || root->right && root->right->val == y) parent_y = root->val;
+        if(root->val == x) depth_x = depth;
+        if(root->val == y) depth_y = depth;
+        
+        findDepthAndCheckParent(root->left, depth + 1);
+        findDepthAndCheckParent(root->right, depth + 1);
+    }
+    
+    bool isCousins(TreeNode* root, int x, int y) {
+        if(root == NULL) return false;
+        this->x = x, this->y = y;
+        findDepthAndCheckParent(root, 0);
+        return (depth_x == depth_y) && (parent_x != parent_y);
+           
+    }
+};

30-days-of-code-may/08.checkPointsOnLine.cpp

@@ -0,0 +1,19 @@
+class Solution {
+public:
+    bool checkStraightLine(vector<vector<int>>& coordinates) {
+        
+        if(coordinates.size() <= 2) return true;
+        int x1 = coordinates[0][0];
+        int y1 = coordinates[0][1];
+        int x2 = coordinates[1][0];
+        int y2 = coordinates[1][1];
+        for(int i=2;i<coordinates.size();i++){
+            int x = coordinates[i][0];
+            int y = coordinates[i][1];
+            if((y2 - y1) * (x1 - x) != (y1 - y) * (x2 - x1))
+                return false;
+        }
+        return true;
+
+    }
+};

30-days-of-code-may/09.townJudege.cpp

@@ -0,0 +1,13 @@
+class Solution {
+public:
+     int findJudge(int N, vector<vector<int>>& trust) {
+        vector<int> count(N + 1, 0);
+        for (auto& t : trust)
+            count[t[0]]--, count[t[1]]++;
+        for (int i = 1; i <= N; ++i) {
+            if (count[i] == N - 1) return i;
+        }
+        return -1;
+    }
+    
+};

30-days-of-code-may/10.floodFill.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) {
+        if (image[sr][sc] != newColor)
+            dfs(image, sr, sc, image[sr][sc], newColor);
+        return image;
+    }
+
+private:
+    void dfs(vector<vector<int>>& image, int i, int j, int c0, int c1) {
+        if (i < 0 || j < 0 || i >= image.size() || j >= image[0].size() || image[i][j] != c0) return;
+        image[i][j] = c1;
+        dfs(image, i, j - 1, c0, c1);
+        dfs(image, i, j + 1, c0, c1);
+        dfs(image, i - 1, j, c0, c1);
+        dfs(image, i + 1, j, c0, c1);
+    }  
+};

30-days-of-code-may/11.singleElementInSortedArray.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    int singleNonDuplicate(vector<int>& nums) {
+        
+        int start = 0, end = nums.size() - 1, mid;      
+        while(start < end){
+            mid = start + (end - start) / 2;
+            if(mid % 2 == 0){
+                if(nums[mid] == nums[mid+1]) start = mid + 2;
+                else if(nums[mid] == nums[mid-1]) end = mid - 2;
+                else return nums[mid];
+            }
+            else{
+                if(nums[mid] == nums[mid-1]) start = mid + 1;
+                if(nums[mid] == nums[mid+1]) end = mid - 1;
+            }
+        }
+        return nums[start];
+    }
+};

30-days-of-code-may/13.triePrefixInsertSearch.cpp

@@ -0,0 +1,57 @@
+class Trie {
+    
+    private:
+    Trie *next[26] = {};
+    bool isWord = false;
+    
+    
+    public:
+        /** Initialize your data structure here. */
+        Trie() {}
+
+        /** Inserts a word into the trie. */
+        void insert(string word) {
+            Trie *node = this;
+            for(auto ch : word){
+                ch -= 'a';
+                
+                if(!node->next[ch]){
+                    node->next[ch] = new Trie();
+                }
+                node = node->next[ch];
+            }
+            node->isWord = true;
+        }
+
+        /** Returns if the word is in the trie. */
+        bool search(string word) {
+            Trie *node = this;
+            for(auto ch : word){
+                ch -= 'a';
+                
+                if(!node->next[ch]) return false;
+                node = node->next[ch];
+            }
+            return node->isWord;
+        }
+
+        /** Returns if there is any word in the trie that starts with the given prefix. */
+        bool startsWith(string prefix) {
+            
+            Trie *node = this;
+            for(auto ch : prefix){
+                ch -= 'a';
+                if(!node->next[ch]) return false;
+                node = node->next[ch];
+            }
+            return true;
+        }
+};
+
+/**
+ * Your Trie object will be instantiated and called as such:
+ * Trie* obj = new Trie();
+ * obj->insert(word);
+ * bool param_2 = obj->search(word);
+ * bool param_3 = obj->startsWith(prefix);
+ */