practise 02-Jun-2020

Author: sureshmangs

competitive programming/leetcode/2020-June-Challenge/Day-01-Invert Binary Tree.cpp

@@ -0,0 +1,53 @@
+Invert a binary tree.
+
+Example:
+
+Input:
+
+     4
+   /   \
+  2     7
+ / \   / \
+1   3 6   9
+Output:
+
+     4
+   /   \
+  7     2
+ / \   / \
+9   6 3   1
+Trivia:
+This problem was inspired by this original tweet by Max Howell:
+
+Google: 90% of our engineers use the software you wrote (Homebrew), but you can’t invert a binary tree on a whiteboard so f*** off.
+
+
+
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* invertTree(TreeNode* root) {
+        if(!root) return root;
+        queue<TreeNode*>q;
+        q.push(root);
+        while(!q.empty()){
+            TreeNode* cur = q.front();
+            q.pop();
+            swap(cur->left, cur->right);
+            if(cur->left) q.push(cur->left);
+            if(cur->right) q.push(cur->right);
+        }
+        return root;
+    }
+};

competitive programming/leetcode/2020-June-Challenge/Day-02-Delete Node in a Linked List.cpp

@@ -0,0 +1,47 @@
+Write a function to delete a node (except the tail) in a singly linked list, given only access to that node.
+
+Given linked list -- head = [4,5,1,9], which looks like following:
+
+
+
+
+
+Example 1:
+
+Input: head = [4,5,1,9], node = 5
+Output: [4,1,9]
+Explanation: You are given the second node with value 5, the linked list should become 4 -> 1 -> 9 after calling your function.
+Example 2:
+
+Input: head = [4,5,1,9], node = 1
+Output: [4,5,9]
+Explanation: You are given the third node with value 1, the linked list should become 4 -> 5 -> 9 after calling your function.
+
+
+Note:
+
+The linked list will have at least two elements.
+All of the nodes' values will be unique.
+The given node will not be the tail and it will always be a valid node of the linked list.
+Do not return anything from your function.
+
+
+
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    void deleteNode(ListNode* node) {
+        ListNode *tmp=node->next;
+        node->val=tmp->val;
+        node->next=tmp->next;
+        delete tmp;
+    }
+};

competitive programming/leetcode/21. Merge Two Sorted Lists.cpp

@@ -0,0 +1,54 @@
+Merge two sorted linked lists and return it as a new sorted list. The new list should be made by splicing together the nodes of the first two lists.
+
+Example:
+
+Input: 1->2->4, 1->3->4
+Output: 1->1->2->3->4->4
+
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
+        ListNode *start, *last;
+        if(!l1) return l2;
+        if(!l2) return l1;
+        if(l1->val <= l2->val){
+            start=l1;
+            l1=l1->next;
+        }
+        else {
+            start=l2;
+            l2=l2->next;
+        }
+        last=start;
+        while(l1 && l2){
+            if(l1->val <= l2->val){
+                last->next=l1;
+                last=last->next;
+                l1=l1->next;
+
+            } else {
+                last->next=l2;
+                last=last->next;
+                l2=l2->next;
+            }
+        }
+        if(l1){
+            last->next=l1;
+        }
+        if(l2){
+            last->next=l2;
+        }
+        return start;
+    }
+};

stack/next_larger_element_in_array.cpp

@@ -0,0 +1,45 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    int t;
+    cin>>t;
+    while(t--){
+        int n;
+        cin>>n;
+        long long a[n];
+        for(int i=0;i<n;i++) cin>>a[i];
+        stack<long long> s;
+        vector<long long> v;
+        for(int i=n-1;i>=0;i--){
+
+            if(s.empty()==true)
+                v.push_back(-1);
+
+            else if(s.empty()==false && s.top()> a[i])
+                v.push_back(s.top());
+
+            else if(s.empty()==false && s.top()<=a[i]){
+                    while(s.empty()==false && s.top()<=a[i]){
+                        s.pop();
+                     if(s.empty()==true)
+                          v.push_back(-1);
+                     else if(s.empty()==false && s.top()> a[i])
+                            v.push_back(s.top());
+                     }
+                    }
+
+            s.push(a[i]);
+        }
+        for(int i=n-1;i>=0;i--){
+            cout<<v[i]<<" ";
+        }
+        cout<<endl;
+    }
+
+
+
+return 0;
+}

stack/stock_span_problem.cpp

@@ -0,0 +1,37 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    int t;
+    cin>>t;
+    while(t--){
+        int n;
+        cin>>n;
+        int a[n];
+        for(int i=0;i<n;i++) cin>>a[i];
+
+        stack<pair<int, int> >s;
+        vector<int> v;
+
+        for(int i=0;i<n;i++){
+            if(s.empty()) v.push_back(-1);
+            else if(!s.empty() && s.top().first > a[i]) v.push_back(s.top().second);
+            else if(!s.empty() && s.top().first<=a[i]){
+                while(!s.empty() && s.top().first<=a[i]){
+                    s.pop();
+                     if(s.empty()) v.push_back(-1);
+                     else if(!s.empty() && s.top().first > a[i]) v.push_back(s.top().second);
+                }
+            }
+            s.push({a[i], i});
+        }
+        for(int i=0;i<n;i++) cout<<i-v[i]<<" ";
+            cout<<endl;
+    }
+
+
+
+return 0;
+}

tree/invert_a_binary_tree.cpp

@@ -0,0 +1,49 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+struct node{
+    int data;
+    struct node* left;
+    struct node* right;
+};
+
+struct node* newNode(int value){
+    struct node* tmp=(struct node*)malloc(sizeof(struct node));
+    tmp->data=value;
+    tmp->left=tmp->right=NULL;
+    return tmp;
+};
+
+
+node* invertTree(struct node* root) {
+        if(!root) return root;
+        queue<node*>q;
+        q.push(root);
+        while(!q.empty()){
+            struct node* cur = q.front();
+            q.pop();
+            swap(cur->left, cur->right);
+            if(cur->left) q.push(cur->left);
+            if(cur->right) q.push(cur->right);
+        }
+        return root;
+}
+
+void inorder(struct node* root){
+    if(!root) return;
+    inorder(root->left);
+    cout<<root->data<<" ";
+    inorder(root->right);
+}
+
+int main(){
+    struct node* root=newNode(1);
+    root->left=newNode(2);
+    root->right=newNode(3);
+    root->left->right=newNode(4);
+    inorder(root);
+    cout<<endl;
+    root = invertTree(root);
+    inorder(root);
+    return 0;
+}