some easy problems to get started again

Author: piyushkhemka

21. Merge Two Sorted Lists.cpp

@@ -0,0 +1,46 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
+
+        ListNode *result = new ListNode (-1);
+        ListNode *cur = result;
+
+        while(l1 && l2) {
+
+            if (l1->val < l2->val) {
+                cur->next = l1;
+                l1 = l1->next;
+            }
+            else {
+                cur->next = l2;
+                l2 = l2->next;
+            }
+
+            cur = cur->next;
+
+        }
+
+        while(l1) {
+            cur->next = l1;
+            cur = cur->next;
+            l1 = l1->next;
+        }
+
+        while(l2) {
+            cur->next = l2;
+            cur = cur->next;
+            l2 = l2->next;
+        }
+
+        return result->next;
+
+    }
+};

23. Merge k Sorted Lists.cpp

@@ -0,0 +1,50 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+
+struct mycomp {
+    bool operator() (ListNode* &l1, ListNode* &l2) {
+        return l1->val > l2->val;
+    }
+};
+public:
+    ListNode* mergeKLists(vector<ListNode*>& lists) {
+
+        ListNode *head = new ListNode(-1);
+
+        if (lists.empty())
+            return head->next;
+
+        priority_queue<ListNode *, vector<ListNode *> , mycomp > mh;
+
+        for(auto i : lists) {
+            if (i)
+                mh.push(i);
+        }
+
+
+        ListNode *cur = head;
+
+        while (!mh.empty()) {
+            ListNode *f = mh.top();
+            cur->next = f;
+            cur = cur->next;
+            mh.pop();
+            if (f->next) {
+                f = f->next;
+                mh.push(f);
+            }
+
+        }
+
+        return head->next;
+
+
+    }
+};

263. Ugly Number.cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+    bool isUgly(int num) {
+
+        if(!num)
+            return false;
+
+        while(num % 2 == 0) {
+            num = num/2;
+        }
+
+        while(num % 3 == 0) {
+            num = num/3;
+        }
+
+        while(num % 5 == 0) {
+            num = num/5;
+        }
+
+        return num == 1;
+
+    }
+};

400. Nth Digit.cpp

@@ -0,0 +1,42 @@
+class Solution {
+public:
+    int findNthDigit(int n) {
+
+        if (n <= 9)
+            return n;
+
+        int nine = 9;
+        long i = 0;
+        long copy = n;
+        long sum = 0;
+
+        while (copy > 0) {
+            ++i;
+            sum = nine*pow(10,i-1);
+            sum = sum * i;
+            copy = copy - sum;
+        }
+
+        copy = copy + sum;
+
+        int q = copy / i;
+        int r = copy % i;
+
+        long num = 1*pow(10,i-1) + q;
+        int ans = 0;
+
+        // cout << num << endl;
+
+        if (r == 0) {
+            r = i;
+            --num;
+        }
+        // start from index. r = index and strip away all the remaining digits and then extract the required digit.
+        for(int j = r;j<i; ++j) {
+            num = num/10;
+        }
+        ans = num % 10;
+        return ans;
+
+    }
+};

438. Find All Anagrams in a string.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+    vector<int> findAnagrams(string s, string p) {
+
+        vector<int> result;
+        vector<int> pat(256,0);
+        vector<int> str(256,0);
+
+        for(int i = 0;i<p.length();++i) {
+            ++pat[p[i]];
+            ++str[s[i]];
+        }
+
+        if(pat == str)
+            result.push_back(0);
+
+        for(int i = p.length();i<s.length();++i) {
+            ++str[s[i]];
+            --str[s[i-p.length()]];
+
+            if (pat == str)
+                result.push_back(i-p.length()+1);
+
+        }
+
+        return result;
+    }
+};

450. Delete Node in a BST.cpp

@@ -0,0 +1,63 @@
+/**
+ * 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* deleteNode(TreeNode* root, int key) {
+
+        if(!root)
+            return root;
+
+        if(key > root->val)
+            root->right =  deleteNode(root->right,key);
+
+        else if (key < root->val)
+            root->left =  deleteNode(root->left, key);
+
+        else {
+
+            if(root->left == nullptr && root->right == nullptr) {
+                delete root;
+                return nullptr;
+            }
+
+            else if (root->left == nullptr && root->right) {
+
+                TreeNode *cur = root->right;
+                delete root;
+                return cur;
+
+            }
+
+            else if (root->right == nullptr && root->left) {
+                TreeNode *cur = root->left;
+                delete root;
+                return cur;
+            }
+
+            else {
+                TreeNode *cur = root->right;
+                while(cur->left) {
+                    cur = cur->left;
+                }
+
+
+                cout << cur->val << endl;
+
+                root->val = cur->val;
+                root->right = deleteNode(root->right, cur->val);
+
+            }
+        }
+
+        return root;
+
+
+    }
+};