Merge branch 'codemistic:main' into rotate-a-linked-list

Author: Namanjain6152

CPP/Problems/FindingSmallestAndLargestElementUsingDivideAndConquer

@@ -0,0 +1,61 @@
+#include <iostream>
+#include <bits/stdc++.h>
+#include <climits>
+using namespace std;
+
+void cal(vector<int> &arr,vector<int> &res,int l,int u)
+{
+    int sz=(u-l+1);
+    int min1=INT_MAX,max1=0;
+    for (int i=l;i<=u;i++)
+    {
+        if (arr[i]<min1)
+            min1=arr[i];
+        if (arr[i]>max1)
+            max1=arr[i];
+    }
+    if (sz==1)
+    {
+        res[0]=(res[0]<min1)?res[0]:min1;
+        res[1]=(res[1]>max1)?res[1]:max1;
+    }
+    else
+    {
+        for (int i=l;i<=u;i++)
+        {
+            if (arr[i]<res[0] && arr[i]!=min1)
+                res[0]=(res[0]<arr[i])?res[0]:arr[i];
+            if (arr[i]>res[1] && arr[i]!=max1)
+                res[1]=(res[1]>arr[i])?res[1]:arr[i];
+        }
+    }
+}
+
+void show(vector<int> &arr,vector<int> &res,int l,int u)
+{
+    int size1=(u-l+1);
+    if (size1>4)
+    {
+        int mid=l+(u-l)/2;
+        show(arr,res,l,mid);
+        show(arr,res,mid+1,u);
+    }
+    cal(arr,res,l,u);
+}
+
+int main()
+{
+    int n=0;
+    cout<<"PLEASE ENTER THE NUMBER OF ARRAY ELEMENTS"<<endl;
+    cin>>n;
+    vector<int> arr(n,0),res(2,0);
+    res[0]=INT_MAX;
+    res[1]=0;
+    cout<<"PLEASE ENTER THE ARRAY ELEMENTS"<<endl;
+    for (int i=0;i<n;i++)
+        cin>>arr[i];
+    show(arr,res,0,n-1);
+    cout<<"THE SECOND SMALLEST NUMBER IS- "<<res[0]<<endl
+    cout<<"THE SECOND LARGEST NUMBER IS- "<<res[1]<<endl;
+    return 0;
+}

CPP/Problems/Leetcode 91 - Decode Ways.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:  
+    int numDecodings(string s) {
+        if(s[0] == '0')return 0;
+        int n = s.length();
+        vector<int> dp(n+2,0);
+        dp[n+1] = 1;
+        dp[n] = 1;
+        for(int i = n-1; i >= 0; i--){
+            int ans = 0;   
+            int num = s[i] - '0';
+            if(num > 0)ans += dp[i+1];
+            if(i+1 < s.length() && num > 0){
+                num = num*10+(s[i+1] - '0');
+                if(num > 0 && num <= 26)ans += dp[i+2];
+            }
+            dp[i] = ans;
+        }
+        return dp[0];        
+    }
+};

CPP/Problems/Leetcode-1470-Shuffle the Array.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    vector<int> shuffle(vector<int>& nums, int n) {
+     
+        vector<int> ans;
+       
+        int i=0;
+        int slice=nums.size()/2-1;
+        int j=slice+1;
+        while(i<slice || j<nums.size()){
+            ans.push_back(nums[i]);
+            ans.push_back(nums[j]);
+            i++;
+            j++;
+        }
+        return ans; 
+    }
+};

CPP/Problems/Leetcode-376 Wiggle Sequence.cpp

@@ -0,0 +1,21 @@
+// https://leetcode.com/problems/wiggle-subsequence/
+
+class Solution {
+public:
+    int wiggleMaxLength(vector<int>& nums) {
+        if(nums.size()< 2)
+            return nums.size();
+        int ans = 1;
+        int f = -1;
+        for(int i=1; i < nums.size(); i++){
+            if(nums[i] > nums[i-1]){
+                if(f==-1 || f==0) ans++;
+                f = 1;
+            }else if(nums[i] < nums[i-1]){
+                if(f==1 || f==-1)ans++;
+                f=0;
+            }
+        }
+        return ans;
+    }
+};

CPP/Problems/Longest-Continuous-Increasing-Subsequence-Easy.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int findLengthOfLCIS(vector<int>& nums) {
+        int count=1;
+        int count1=1;
+        for(int i=0;i<nums.size()-1;i++)
+        {
+            if(nums[i+1]>nums[i])
+            {count++;
+            count1=max(count,count1);}
+            else
+                count=1;
+
+        }
+        return count1;
+        
+    }
+};

CPP/Problems/mergeLinedList/Namanjain6152.md

@@ -0,0 +1,36 @@
+<!-- creating node type own data structure -->
+struct Node {
+  int data;
+  struct Node *next;
+  
+  Node(int x) {
+    data = x;
+    next = NULL;
+  }
+};
+*/
+//Function to merge two sorted linked list.
+Node* sortedMerge(Node* head1, Node* head2)  
+{  
+    // code here
+    if(!head1) return head2;
+    if(!head2) return head1;
+    Node* dummy= new Node(-1);
+    Node* ptr1= head1,*ptr2=head2;
+    Node* tail=dummy;
+    while(ptr1&&ptr2){
+        if(ptr1->data<=ptr2->data){
+            tail->next= ptr1;
+            tail=ptr1;
+            ptr1=ptr1->next;
+        }
+        else{
+            tail->next=ptr2;
+            tail=ptr2;
+            ptr2=ptr2->next;
+        }
+    }
+    if(ptr1) tail->next=ptr1;
+    if(ptr2) tail->next=ptr2;
+    return dummy->next;
+}  

CPP/Problems/pow(x,n).cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+  //binary exponentiation
+    double power(double x, int n){
+        if(n==0)return 1;
+      
+        double d=power(x,n/2);
+        if(n&1)return x*d*d;
+        return d*d;
+    }
+    double myPow(double x, int n) {
+        
+      if(n>0){return power(x,n);}
+        return 1/power(x,n);//a^-1=1/a
+    }
+};

CPP/Problems/remove-element.js

@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @param {number} val
+ * @return {number}
+ */
+var removeElement = function (nums, val) {
+   
+    let count = 0;
+   
+    for (let i = 0; i < nums.length; i++) {
+        
+        if (nums[i] !== val) {
+            nums[count++] = nums[i];
+        }
+    }
+    return count;
+};
+//Leetcode

CPP/graph_tree/LCA_Binary-tree.cpp

@@ -0,0 +1,100 @@
+// C++ Program for Lowest Common Ancestor in a Binary Tree
+// A O(n) solution to find LCA of two given values n1 and n2
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+// A Binary Tree node
+struct Node
+{
+	int key;
+	struct Node *left, *right;
+};
+
+// Utility function creates a new binary tree node with given key
+Node * newNode(int k)
+{
+	Node *temp = new Node;
+	temp->key = k;
+	temp->left = temp->right = NULL;
+	return temp;
+}
+
+// Finds the path from root node to given root of the tree, Stores the
+// path in a vector path[], returns true if path exists otherwise false
+bool findPath(Node *root, vector<int> &path, int k)
+{
+	// base case
+	if (root == NULL) return false;
+
+	// Store this node in path vector. The node will be removed if
+	// not in path from root to k
+	path.push_back(root->key);
+
+	// See if the k is same as root's key
+	if (root->key == k)
+		return true;
+
+	// Check if k is found in left or right sub-tree
+	if ( (root->left && findPath(root->left, path, k)) ||
+		(root->right && findPath(root->right, path, k)) )
+		return true;
+
+	// If not present in subtree rooted with root, remove root from
+	// path[] and return false
+	path.pop_back();
+	return false;
+}
+
+// Returns LCA if node n1, n2 are present in the given binary tree,
+// otherwise return -1
+int findLCA(Node *root, int n1, int n2)
+{
+	// to store paths to n1 and n2 from the root
+	vector<int> path1, path2;
+
+	// Find paths from root to n1 and root to n2. If either n1 or n2
+	// is not present, return -1
+	if ( !findPath(root, path1, n1) || !findPath(root, path2, n2))
+		return -1;
+
+	/* Compare the paths to get the first different value */
+	int i;
+	for (i = 0; i < path1.size() && i < path2.size() ; i++)
+		if (path1[i] != path2[i])
+			break;
+	return path1[i-1];
+}
+
+// Driver program to test above functions
+int main()
+{
+	// Let us create the Binary Tree shown in above diagram.
+	Node * root = newNode(1);
+	root->left = newNode(2);
+	root->right = newNode(3);
+	root->left->left = newNode(4);
+	root->left->right = newNode(5);
+	root->right->left = newNode(6);
+	root->right->right = newNode(7);
+	cout << "LCA(4, 5) = " << findLCA(root, 4, 5);
+	cout << "\nLCA(4, 6) = " << findLCA(root, 4, 6);
+	cout << "\nLCA(3, 4) = " << findLCA(root, 3, 4);
+	cout << "\nLCA(2, 4) = " << findLCA(root, 2, 4);
+	return 0;
+}
+
+
+/*
+Output
+LCA(4, 5) = 2
+LCA(4, 6) = 1
+LCA(3, 4) = 1
+LCA(2, 4) = 2
+Time Complexity: O(n). The tree is traversed twice, and then path arrays are compared. 
+Auxiliary Space: O(n). Extra Space for path1 and path2.
+
+*/
+
+//contributed by Sourav Naskar

CPP/hashing/quadratic_probing.cpp

@@ -0,0 +1,38 @@
+#include <iostream>
+using namespace std;
+int hashfunction(int key)
+{
+    return key % 13;
+}
+int main()
+{
+    int a[] = {26, 28, 31, 34, 35, 25, 31, 31, 31, 25};
+    int h[13];
+    int n = 13;
+    for (int i = 0; i < 13; i++)
+        h[i] = -999;
+    for (int i = 0; i < 10; i++)
+    {
+        if (h[hashfunction(a[i])] != -999)
+        {
+            int j = 1;
+            int pcount = 1;
+            int k;
+            k = hashfunction(a[i]);
+            while (pcount < n / 2 && h[(k + j) % 13] != -999)
+            {
+                k = (k + j) % 13;
+                cout << a[i] << "->" << k << " ";
+                j = j + 2;
+                pcount++;
+            }
+            cout << endl;
+            if (h[(k + j) % 13] == -999)
+                h[(k + j) % 13] = a[i];
+        }
+        else
+            h[hashfunction(a[i])] = a[i];
+    }
+    for (int i = 0; i < 13; i++)
+        cout << h[i] << " ";
+}

CPP/map/mapConcepts.cpp

@@ -0,0 +1,19 @@
+```
+#include<bits/stdc++.h>>
+using namespace std;
+int main() {
+    
+//Map: Commom use- counts frequency of various objects
+//Maps are special arrays in which the indices(keys) of elements can be negative or very big or even strings! 
+
+// map<key_datatype, value_datatype> m;
+
+map<string, int>m; //defines a map in which the keys of elements are strings.
+m["hello"]=50;
+m["world"]=12;
+cout<<m["hello"]<<" "<<m["world"]; //50 12
+
+//Maps are very similar to sets, in sets the values are unique and sorted. In maps, the keys are unique and sorted(lexicographically).
+return 0;
+}
+```