Hashing Important Questions Added

Author: Utkarsh-Arora-007

Hashing/1. ApplicationsOfHashing.cpp

@@ -0,0 +1,9 @@
+// Applications of hashing:
+
+// 1. Dictionaries Implementation
+// 2. Database indexing
+// 3. Cryptography
+// 4. Caches
+// 5. Symbol Tables in Compilers/Interpreters
+// 6. Routers
+// 7. Getting data from databases

Hashing/10. Unordered_map.cpp

@@ -0,0 +1,76 @@
+**** Unordered_map: ****
+
+Used to store key-value pairs
+Uses Hashing Algorithms
+It has no specific order of keys.
+
+
+#include<iostream>
+#include<unordered_map> m;
+
+using namespace std;
+
+int main()
+{
+    unordered_map<string ,int> m;
+    m["gfg"]= 20;
+    m["ide"]=30;
+    m.insert(["courses", 15]);
+
+    for(auto x: m)
+      cout<<x.first<<" "<<x.second<<endl;
+
+    return 0;  
+}
+
+
+// Program 2
+
+#include<iostream>
+#include<unordered_map> m;
+
+using namespace std;
+
+int main()
+{
+    unordered_map<string, int> m;
+    m["gfg"]= 20;
+    m["ide"]= 30;
+    m["courses"]= 15;
+    if(m.find("ide")!=m.end())
+       cout<<"Found\n";
+
+    else
+       cout<<"Not Found\n";
+
+    for(auto it = m.begin(); it!=m.end(); it++)
+       cout<<(it->first)<<" "<<(it->second)<<endl;
+
+
+
+    if(m.count("ide") > 0)
+       cout<<"Found";
+
+    else
+       cout<<"Not Found";      
+}
+
+
+#include<iostream>
+#include<unordered_map>m;
+
+using namespace std;
+int main()
+{
+    unordered_map<string , int> m;
+    m["gfg"]=20;
+    m["ide"]=30;
+    m["courses"]=15;
+
+    cout<<m.size()<<" ";
+    m.erase("ide");
+    m.erase(m.begin());
+    cout<<m.size()<<" ";
+
+    return 0;
+}

Hashing/11. CountDistinctElements.cpp

@@ -0,0 +1,52 @@
+//Naive Solution
+// Time: Theta(n^2)
+//space: O(1)
+
+
+int countDist(int arr[], int n)
+{
+    int res=0;
+    for(int i=0;i<n;i++)
+    {
+        bool flag= false;
+
+        for(int j=0;j<i;j++)
+        {
+            if(arr[i]==arr[j])
+            {
+                flag= true;
+                break;
+            }
+        }
+        if(flag==false)
+        res++;
+    }
+    return res;
+}
+
+
+//Optimized Solution : using Unordered_set
+// Time: theta(n)
+// space: O(n)
+int countDistinct(int arr[], int n)
+{
+    unordered_set<int>s;
+
+    for(int i=0;i<n;i++)
+      s.insert(arr[i]);
+
+    return s.size();  
+
+}
+
+
+
+//More Optimized way of coding
+
+// int countDistinct(int arr[], int n)
+// {
+//     unordered_set<int> s(arr, arr+n);
+//     return s.size();
+// }
+
+

Hashing/12. FrequencyOfArrayElements.cpp

@@ -0,0 +1,41 @@
+//Naive Approach
+//Time Complexity : O(n^2)
+//Aux Space : O(1)
+
+#include<bits/stdc++.h>
+using namespace std;
+
+void prinFreq (int arr[], int n)
+{
+    for(int i=0;i<n;i++)
+    {
+        bool flag= false;
+        for(int j=0;j<i;j++)
+          if(arr[i]==arr[j]) { flag = true; break; }
+
+        if(flag== true)
+          continue;
+
+        int freq = 1;
+        for(int j= i+1; j<n; j++)
+           if(arr[i]==arr[j])
+              freq++;
+
+        cout<<arr[i]<<" "<<freq<<endl;          
+    }
+}
+
+
+//Efficient Solution
+int countFreq(int arr[], int n)
+{
+    unordered_map<int , int> h;
+    for(int i=0;i<n;i++)
+       h[arr[i]]++;
+
+    for(auto e: h)
+       cout<<e.first<<" "<<e.second<<endl;   
+}
+
+//Aux Space: O(n)
+//TIme Complexity: Theta(n)

Hashing/13. Intersection Of Arrays.cpp

@@ -0,0 +1,54 @@
+//Naive Solution:
+//Time Complexity: O(m*(m+n))
+#include<bits/stdc++.h>
+int intersection(int a[], int b[], int m , int n)
+{
+    int res=0;
+    for(int i=0;i<m;i++)
+    {
+        bool flag= false;
+        for(int j=0;j<i-1;j++)
+        {
+            if(a[j]==a[i]) { flag= true; break;}
+
+        } 
+
+        if(flag== true)
+        {
+            continue;
+        }
+
+        for(int j=0;j<n;j++)
+        {
+            if(a[i]==b[j]) { res++; break;}
+        }
+    }
+}
+
+
+
+
+//Efficient Solution: 
+//Time Complexity: O(m+n)
+//Aux Space: o(m)
+
+int intersection (int a[], int b[], int m , int n)
+{
+    unordered_set<int> s;
+    for(int i=0; i<m;i++)
+    {
+        s.insert(a[i]);
+    }
+
+    int res=0;
+    for(int j=0;j<n;j++)
+    {
+        if(s.find(b[j])!= s.end())
+        {
+            res++;
+            s.erase(b[i]);
+        }
+    }
+
+    return res;
+}    

Hashing/14. Union of two Unsorted Arrays.cpp

@@ -0,0 +1,44 @@
+//Naive Approach
+//Time Complexity: O((m+n) * (m+n))
+//Aux Space: O(m+n)
+
+int findUnion(int a[], int b[], int m , int n)
+{
+    int c[m+n];
+    for(int i=0; i<m;i++)
+        c[i]=a[i];
+
+    for(int i=0; i<n;i++)
+       c[m+i] = b[i];
+
+    int res=0;
+    for(int i=0; i<m+n; i++)
+    {
+        bool flag= false;
+        for(int j=0; j<i;j++)
+        {
+            if(c[i]==c[j]) { flag= true; break; }
+        }
+
+        if(flag== false) res++;
+    }       
+
+    return res;
+
+}
+
+//Efficient solution 
+//Time Complexity: O(m+n)
+//Aux Space: O(m+n)
+int findUnion(int a[], int b[], int m , int n)
+{
+    unordered_set<int> s;
+
+    for(int i=0; i<m ;i++)
+        s.insert(a[i]);
+
+    for(int j=0;j<n;j++)
+       s.insert(b[i]);
+
+    return s.size();       
+}

Hashing/15. Pair with given sum in an unsorted array.cpp

@@ -0,0 +1,30 @@
+//Pair with given sum in an unsorted array
+
+//Naive Solution
+
+bool isPair(int arr[], int n, int sum)
+{
+    for(int i=0; i<n;i++)
+       for(int j=i+1; j<n;j++)
+          if(arr[i]+arr[j] == sum)
+             return true;
+
+    return false;         
+}
+
+
+//Efficient Solution
+
+bool isPair(int arr[], int n, int sum)
+{
+    unordered_set<int>s;
+    for(int i=0;i<n;i++)
+    {
+        if(s.find(sum-arr[i]) != s.end())
+                return true;
+
+        s.insert(arr[i]);        
+    }
+
+    return false;
+}

Hashing/16. SubArray with Sum 0.cpp

@@ -0,0 +1,46 @@
+// Naive Solution
+// Time Complexity: O(n^2)
+
+bool is0SubArray(int arr[], int n)
+{
+    for(int i=0;i<n;i++)
+    {
+        int curr_sum = 0;
+        for(int j=i; j<n;j++)
+        {
+            curr_sum+= arr[j];
+            if(curr_sum ==0)
+               return true;
+        }
+    }
+
+    return false;
+}
+
+
+//Efficient Solution Idea : Use Prefix Sum and Hashing
+//time complexity: O(n)
+bool is0SubArray(int arr[], int n)
+{
+    unordered_set<int> h;
+
+    int pre_sum=0;
+    for(int i=0;i<n;i++)
+    {
+        pre_sum+=arr[i];
+        if(h.find(pre_sum)!= h.end())
+           return true;
+
+        if(pre_sum == 0)
+           return true;
+
+        h.insert(pre_sum);
+
+    }
+
+    return false;
+}
+
+
+
+ 

Hashing/17. SubArray with given Sum.cpp

@@ -0,0 +1,24 @@
+//Naive Solution : 
+
+bool isSum(int arr[], int n, int sum)
+{
+    unordered_set<int> s;
+
+    int pre_sum=0;
+    for(int i=0; i<n;i++)
+    {
+        if(pre_sum == sum)
+        {
+            return true;
+        }
+
+        if(s.find(pre_sum - sum)!=s.end())
+                return true;
+
+        s.insert(pre_sum);        
+    }
+
+    return false;
+}
+//Time Complexity: O(n)
+//Aux Space: O(n)