🚀 24-Jun-2020

Author: sureshmangs

algorithms/sorting/merge_sort.cpp

@@ -0,0 +1,56 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+void merge(int a[], int l, int mid, int r){
+    int i, j, k;
+    int n1=mid-l+1;         // left array a[l....mid]
+    int n2=r-(mid+1)+1;   // right array a[mid+1.....r]
+    int L[n1], R[n2];  // temp arrays
+
+    for(int i=0;i<n1;i++)
+        L[i]=a[l+i];
+    for(int j=0;j<n2;j++)
+        R[j]=a[mid+1+j];
+
+    i=0, j=0, k=l;
+    while(i<n1 && j<n2){
+        if(L[i]<=R[j]){
+            a[k]=L[i];
+            i++;
+        } else {
+            a[k]=R[j];
+            j++;
+        }
+        k++;
+    }
+    // adding remaining elements
+    while(i<n1){
+        a[k]=L[i];
+        i++;
+        k++;
+    }
+    while(j<n2){
+        a[k]=R[j];
+        j++;
+        k++;
+    }
+}
+
+void mergeSort(int a[], int l, int r){
+    if(l<r){
+        int mid=l+(r-l)/2;
+        mergeSort(a, l, mid);
+        mergeSort(a, mid+1, r);
+        merge(a, l, mid, r);
+    }
+}
+
+int main(){
+    int n;
+    cin>>n;
+    int a[n];
+    for(int i=0;i<n;i++) cin>>a[i];
+    mergeSort(a, 0, n-1);
+    for(int i=0;i<n;i++) cout<<a[i]<<" ";
+    return 0;
+}

competitive programming/leetcode/1232. Check If It Is a Straight Line.cpp

@@ -0,0 +1,54 @@
+You are given an array coordinates, coordinates[i] = [x, y], where [x, y] represents the coordinate of a point. Check if these points make a straight line in the XY plane.
+
+
+
+
+
+Example 1:
+
+
+
+Input: coordinates = [[1,2],[2,3],[3,4],[4,5],[5,6],[6,7]]
+Output: true
+Example 2:
+
+
+
+Input: coordinates = [[1,1],[2,2],[3,4],[4,5],[5,6],[7,7]]
+Output: false
+
+
+Constraints:
+
+2 <= coordinates.length <= 1000
+coordinates[i].length == 2
+-10^4 <= coordinates[i][0], coordinates[i][1] <= 10^4
+coordinates contains no duplicate point.
+
+
+
+
+
+class Solution {
+public:
+    bool checkStraightLine(vector<vector<int>>& coords) {
+        int n=coords.size();
+        if(n<=2) return true;
+        int x1=coords[0][0];
+        int y1=coords[0][1];
+        int x2=coords[1][0];
+        int y2=coords[1][1];
+        double dy=y2-y1;
+        double dx=x2-x1;
+        for(int i=0;i<n-1;i++){
+            x1=coords[i][0];
+            y1=coords[i][1];
+            x2=coords[i+1][0];
+            y2=coords[i+1][1];
+            int tdy=y2-y1;
+            int tdx=x2-x1;
+            if(dy*tdx!=dx*tdy) return false;
+        }
+        return true;
+    }
+};

competitive programming/leetcode/2020-June-Challenge/Day-23-Count Complete Tree Nodes.cpp

@@ -0,0 +1,52 @@
+Given a complete binary tree, count the number of nodes.
+
+Note:
+
+Definition of a complete binary tree from Wikipedia:
+In a complete binary tree every level, except possibly the last, is completely filled, and all nodes in the last level are as far left as possible. It can have between 1 and 2h nodes inclusive at the last level h.
+
+Example:
+
+Input:
+    1
+   / \
+  2   3
+ / \  /
+4  5 6
+
+Output: 6
+
+
+
+
+
+
+
+
+/**
+ * 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:
+
+    void countNodesUtil(TreeNode* root, int &cnt){
+        if(!root) return;
+        countNodesUtil(root->left, cnt);
+        cnt++;
+        countNodesUtil(root->right, cnt);
+    }
+
+    int countNodes(TreeNode* root) {
+        int cnt=0;
+        countNodesUtil(root, cnt);
+        return cnt;
+    }
+};

competitive programming/leetcode/222. Count Complete Tree Nodes.cpp

@@ -0,0 +1,52 @@
+Given a complete binary tree, count the number of nodes.
+
+Note:
+
+Definition of a complete binary tree from Wikipedia:
+In a complete binary tree every level, except possibly the last, is completely filled, and all nodes in the last level are as far left as possible. It can have between 1 and 2h nodes inclusive at the last level h.
+
+Example:
+
+Input:
+    1
+   / \
+  2   3
+ / \  /
+4  5 6
+
+Output: 6
+
+
+
+
+
+
+
+
+/**
+ * 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:
+
+    void countNodesUtil(TreeNode* root, int &cnt){
+        if(!root) return;
+        countNodesUtil(root->left, cnt);
+        cnt++;
+        countNodesUtil(root->right, cnt);
+    }
+
+    int countNodes(TreeNode* root) {
+        int cnt=0;
+        countNodesUtil(root, cnt);
+        return cnt;
+    }
+};

mathematical/check_if_prime.cpp

@@ -0,0 +1,52 @@
+/*
+For a given number N check if it is prime or not. A prime number is a number which is only divisible by 1 and itself.
+
+Input:
+First line contains an integer, the number of test cases 'T'. T testcases follow. Each test case should contain a positive integer N.
+
+Output:
+For each testcase, in a new line, print "Yes" if it is a prime number else print "No".
+
+Constraints:
+1 <= T <= 100
+1 <= N <= 109
+
+Example:
+Input:
+1
+5
+Output:
+Yes
+
+Explanation:
+Testcase 1: 5 is the prime number as it is divisible only by 1 and 5.
+*/
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+bool prime(long int n){
+    if(n<=1) return false;
+    if(n<=3) return true;
+    if(n%2==0 || n%3==0) return false;
+    for(long int i=5;i<=sqrt(n);i+=6){
+        if(n%i==0 || n%(i+2)==0) return false;
+    }
+    return true;
+}
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    int t;
+    cin>>t;
+    while(t--){
+        long int n;
+        cin>>n;
+        prime(n)? cout<<"Yes\n" : cout<<"No\n";
+    }
+
+return 0;
+}