🚀 24-Aug-2020

Author: sureshmangs

competitive programming/leetcode/1. Two Sum.cpp

@@ -63,3 +63,15 @@ class Solution {
        return res;
     }
 };
+
+
+
+
+/*
+Approach1:
+The brute force approach is simple.
+Loop through each element xx and find if there is another value that equals to target - xtarget−x.
+
+Approach2:
+Sort the array, and use the two pointer technique.
+*/

competitive programming/leetcode/1032. Stream of Characters.cpp

@@ -0,0 +1,99 @@
+Implement the StreamChecker class as follows:
+
+StreamChecker(words): Constructor, init the data structure with the given words.
+query(letter): returns true if and only if for some k >= 1, the last k characters queried (in order from oldest to newest, including this letter just queried) spell one of the words in the given list.
+
+
+Example:
+
+StreamChecker streamChecker = new StreamChecker(["cd","f","kl"]); // init the dictionary.
+streamChecker.query('a');          // return false
+streamChecker.query('b');          // return false
+streamChecker.query('c');          // return false
+streamChecker.query('d');          // return true, because 'cd' is in the wordlist
+streamChecker.query('e');          // return false
+streamChecker.query('f');          // return true, because 'f' is in the wordlist
+streamChecker.query('g');          // return false
+streamChecker.query('h');          // return false
+streamChecker.query('i');          // return false
+streamChecker.query('j');          // return false
+streamChecker.query('k');          // return false
+streamChecker.query('l');          // return true, because 'kl' is in the wordlist
+
+
+Note:
+
+1 <= words.length <= 2000
+1 <= words[i].length <= 2000
+Words will only consist of lowercase English letters.
+Queries will only consist of lowercase English letters.
+The number of queries is at most 40000.
+
+
+
+
+
+
+
+    struct TrieNode {
+            bool ew; // end of word
+            struct TrieNode* child[26];
+    };
+
+    struct TrieNode* createNode(){
+        struct TrieNode* newNode=new TrieNode;
+        newNode->ew=false;
+        for(int i=0;i<26;i++)
+            newNode->child[i]=NULL;
+        return newNode;
+    }
+
+    void insert(struct TrieNode* root, string word){
+            struct TrieNode* cur=root;
+            int wordLen=word.length();
+            for(int i=wordLen-1;i>=0;i--){
+                int index=word[i]-'a';
+                // create new node if not already exist
+                if(cur->child[index]==NULL)
+                    cur->child[index]=createNode();
+                // point to new node
+                cur=cur->child[index];
+            }
+            cur->ew=true; // end of word
+      }
+
+
+
+class StreamChecker {
+public:
+    struct TrieNode* root= createNode();
+    string stream="";
+
+
+    StreamChecker(vector<string>& words) {
+
+        int n=words.size();
+        for(int i=0;i<n;i++)
+            insert(root, words[i]);
+
+    }
+
+    bool query(char letter) {
+        stream+=letter;
+        TrieNode* cur=root;
+        int sLen=stream.length();
+        for(int i=sLen-1; i>=0;i--){
+            int index=stream[i]-'a';
+            if(cur->ew==true) return true;
+            if(cur->child[index]==NULL) return false;
+            cur=cur->child[index];
+        }
+        return (cur!=NULL && cur->ew);
+    }
+};
+
+/**
+ * Your StreamChecker object will be instantiated and called as such:
+ * StreamChecker* obj = new StreamChecker(words);
+ * bool param_1 = obj->query(letter);
+ */

competitive programming/leetcode/128. Longest Consecutive Sequence.cpp

@@ -0,0 +1,115 @@
+Given an unsorted array of integers, find the length of the longest consecutive elements sequence.
+
+Your algorithm should run in O(n) complexity.
+
+Example:
+
+Input: [100, 4, 200, 1, 3, 2]
+Output: 4
+Explanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore its length is 4.
+
+
+
+
+
+
+
+
+
+
+
+
+// TC : O(nlgn)
+
+class Solution {
+public:
+    int longestConsecutive(vector<int>& nums) {
+        int n=nums.size();
+        if(n==0) return 0;
+        sort(nums.begin(), nums.end());
+        int res=1, cnt=1;
+        for(int i=0;i<n-1;i++){
+            if(nums[i+1]==nums[i]) continue;
+            if(abs(nums[i+1]-nums[i]==1)){
+                cnt++;
+            } else cnt=1;
+            if(cnt>res) res=cnt;
+        }
+        return res;
+    }
+};
+
+
+
+
+
+/*
+Brute Force
+Considers each number in nums, attempting to count as high as possible from that number using only numbers in nums.
+After it counts too high (i.e. currentNum refers to a number that nums does not contain),
+it records the length of the sequence if it is larger than the current best.
+*/
+
+// TLE
+class Solution {
+    bool arrayContains(vector<int> nums, int num) {
+        int n=nums.size();
+        for (int i = 0; i < n; i++) {
+            if (nums[i] == num) {
+                return true;
+            }
+        }
+        return false;
+    }
+    public:
+    int longestConsecutive(vector<int> &nums) {
+        int longestStreak = 0;
+
+        for (int num : nums) {
+            int currentNum = num;
+            int currentStreak = 1;
+
+            while (arrayContains(nums, currentNum + 1)) {
+                currentNum += 1;
+                currentStreak += 1;
+            }
+            longestStreak = max(longestStreak, currentStreak);
+        }
+        return longestStreak;
+    }
+};
+
+
+
+
+
+// O(N)
+
+class Solution {
+    public:
+    int longestConsecutive(vector<int> &nums) {
+        int longestStreak = 0;
+        set<int> s;
+        // Hash all the array elements
+        for(int num: nums){
+            s.insert(num);
+        }
+
+         // check each possible sequence from the start then update optimal length
+        for (int num : nums) {
+                int currentNum = num;
+                int currentStreak = 1;
+                 // if current element is the starting element of a sequence
+                if(s.find(currentNum-1)==s.end()){
+                   // Then check for next elements in the sequence
+                    while (s.find(currentNum+1)!=s.end()) {
+                        currentNum += 1;
+                        currentStreak += 1;
+                    }
+                }
+            longestStreak = max(longestStreak, currentStreak);
+        }
+        return longestStreak;
+    }
+};
+

competitive programming/leetcode/138. Copy List with Random Pointer.cpp

@@ -0,0 +1,94 @@
+A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null.
+
+Return a deep copy of the list.
+
+The Linked List is represented in the input/output as a list of n nodes. Each node is represented as a pair of [val, random_index] where:
+
+val: an integer representing Node.val
+random_index: the index of the node (range from 0 to n-1) where random pointer points to, or null if it does not point to any node.
+
+
+Example 1:
+
+
+Input: head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
+Output: [[7,null],[13,0],[11,4],[10,2],[1,0]]
+Example 2:
+
+
+Input: head = [[1,1],[2,1]]
+Output: [[1,1],[2,1]]
+Example 3:
+
+
+
+Input: head = [[3,null],[3,0],[3,null]]
+Output: [[3,null],[3,0],[3,null]]
+Example 4:
+
+Input: head = []
+Output: []
+Explanation: Given linked list is empty (null pointer), so return null.
+
+
+Constraints:
+
+-10000 <= Node.val <= 10000
+Node.random is null or pointing to a node in the linked list.
+Number of Nodes will not exceed 1000.
+
+
+
+
+
+
+
+
+
+
+
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    Node* next;
+    Node* random;
+
+    Node(int _val) {
+        val = _val;
+        next = NULL;
+        random = NULL;
+    }
+};
+*/
+
+class Solution {
+public:
+    Node* copyRandomList(Node* head) {
+        if(!head) return head;
+        Node *curr=head;
+        while(curr!=NULL){
+            Node *tmp=curr->next;
+            curr->next=new Node(curr->val);
+            curr->next->next=tmp;
+            curr=tmp;
+        }
+        curr=head;
+        while(curr!=NULL){
+            if(curr->next!=NULL){
+                curr->next->random=curr->random ? curr->random->next : curr->random;
+            }
+            curr=curr->next ? curr->next->next : curr->next;
+        }
+        Node *original=head, *copy=head->next;
+        Node* tmp=copy; // save start of the copied list
+        while(original && copy){
+            original->next=original->next ? original->next->next: original->next;
+            copy->next=copy->next ? copy->next->next : copy->next;
+            original=original->next;
+            copy=copy->next;
+        }
+        return tmp;
+    }
+};

competitive programming/leetcode/1446. Consecutive Characters.cpp

@@ -0,0 +1,58 @@
+Given a string s, the power of the string is the maximum length of a non-empty substring that contains only one unique character.
+
+Return the power of the string.
+
+
+
+Example 1:
+
+Input: s = "leetcode"
+Output: 2
+Explanation: The substring "ee" is of length 2 with the character 'e' only.
+Example 2:
+
+Input: s = "abbcccddddeeeeedcba"
+Output: 5
+Explanation: The substring "eeeee" is of length 5 with the character 'e' only.
+Example 3:
+
+Input: s = "triplepillooooow"
+Output: 5
+Example 4:
+
+Input: s = "hooraaaaaaaaaaay"
+Output: 11
+Example 5:
+
+Input: s = "tourist"
+Output: 1
+
+
+Constraints:
+
+1 <= s.length <= 500
+s contains only lowercase English letters.
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    int maxPower(string s) {
+        int n=s.length();
+        int maxi=1, cnt=1;
+        for(int i=0;i<n-1;i++){
+            if(s[i]==s[i+1]){
+                cnt++;
+            } else cnt=1;
+            if(cnt>maxi) maxi=cnt;
+        }
+        return maxi;
+    }
+};