Merge pull request #584 from syndax9/main

Array DSA codes

Author: Sirajmolla

Array/AlternatePnN.cpp

@@ -0,0 +1,46 @@
+using namespace std;
+#include <iostream> 
+#include <vector>
+
+void rearrange(int arr[], int n){
+    vector <int> pos;
+    vector <int> neg;
+    for(int i=0;i<n;i++){
+        if(arr[i]>=0){
+            pos.push_back(arr[i]);
+        }
+        else{
+            neg.push_back(arr[i]);
+        }
+    }
+    int posindex=0;
+    int negindex=0;
+    for(int i=0;i<n;i++){
+        if(posindex<pos.size() && posindex==negindex){
+            arr[i]=pos[posindex];
+            posindex++;
+        }
+        else if(negindex<neg.size() && posindex>negindex){
+            arr[i]=neg[negindex];
+            negindex++;
+        }
+        else if(negindex==neg.size() && posindex<pos.size()){
+            arr[i]=pos[posindex];
+            posindex++;
+        }
+        else if(posindex==pos.size() && negindex<neg.size()){
+            arr[i]=neg[negindex];
+            negindex++;
+        }
+    }
+}
+
+int main(){
+    int arr[9] = {9, 4, -2, -1, 5, 0, -5, -3, 2};
+    rearrange(arr,9);
+    for (int i = 0; i < 9; i++)
+    {
+        cout<<arr[i]<<" ";
+    }
+    
+}

Array/DeleteofDuplicate.cpp

@@ -0,0 +1,20 @@
+using namespace std;
+#include <iostream> 
+
+int dup(int arr[], int n){
+    int a = 1;
+    for (int i = 1; i < n; i++)
+    {
+        if (arr[i] != arr[a-1])
+        {
+            arr[a] = arr[i];
+            a++;
+        }
+    }
+    return a;
+}
+
+int main(){
+    int arr[] = {10,20,20,30,30,30,30}, n = 7;
+    cout<<dup(arr, n);
+}

Array/Duplicate.cpp

@@ -0,0 +1,17 @@
+using namespace std;
+#include <iostream> 
+
+int duplicate(int arr[], int n){
+   for(int i = 0; i < n; i++){
+       arr[arr[i]%n] += n;
+   }
+   for(int i = 0; i < n; i++){
+       if(arr[i]/n > 1) cout<<i<<" ";
+   }
+   return -1;
+}
+
+int main(){
+    int arr[] = {1,2,3,3,2,3}, n = 6;
+    duplicate(arr,n);
+}

Array/MaxArray.cpp

@@ -0,0 +1,19 @@
+using namespace std;
+#include <iostream> 
+
+int max(int arr[], int n){
+    int res=0;
+    for (int i = 0; i < n; i++)
+    {
+       if ( arr[i] > arr[res])
+       {
+           res = i;
+       } 
+    }  
+    return res;
+}    
+
+int main(){
+    int arr[] = {2,5,8,4}, n = 4;
+    cout<<max(arr,n);
+}

Array/ReverseArray.cpp

@@ -0,0 +1,23 @@
+using namespace std;
+#include <iostream> 
+
+void reverse(int arr[], int n){
+    int first = 0, last = n-1;
+    while(first < last){
+        int a = arr[first];
+        arr[first] = arr[last];
+        arr[last]= a;
+        first++;
+        last--;
+    }
+    for (int i = 0; i < n; i++)
+    {
+        cout<<arr[i]<<" ";
+    }
+    
+}
+
+int main(){
+    int arr[] = {10, 5, 7, 30}, n = 4;
+    reverse(arr, n);
+}

Array/check.cpp

@@ -0,0 +1,18 @@
+using namespace std;
+#include <iostream> 
+#include <unordered_set> 
+
+void intersection(int a[], int b[], int n, int m){
+    unordered_set<int> s;
+    for(int i = 0; i < n; i++){
+        s.insert(a[i]);
+    }
+    for(int i = 0; i < m; i++){
+        if(s.find(b[i])!=s.end()) cout<<b[i]<<" ";
+    }
+}
+
+int main(){
+    int a[] = {1,6,3,8,2}, b[] = {2,6,8,5,9,3};
+    intersection(a,b,5,6);
+}

Array/check.exe

@@ -0,0 +1,19 @@
+using namespace std;
+#include <iostream>
+#include <vector> 
+
+vector<int> duplicate(int arr[], int n){
+    for (int i = 0; i < n; i++)
+    {
+        arr[arr[i]%n] += n;
+    }
+    for (int i = 0; i < n; i++)
+    {
+        
+    }
+    
+}
+
+int main(){
+ 
+}

Array/findingDuplicate.cpp

@@ -0,0 +1,24 @@
+using namespace std;
+#include <iostream> 
+
+void count(int arr[], int n){
+   int f = 1;
+   int i = 1;
+   while(i < n){
+       while(i < n && arr[i] == arr[i-1]){
+           f++;
+           i++;
+       }
+       cout<<arr[i-1]<<" "<<f<<endl;
+       i++;
+       f = 1;
+    if (n ==1 || arr[n-1] != arr[n-2]){
+       cout<<arr[n-1]<<" "<<f;
+   }
+   }
+}
+
+int main(){
+    int arr[] = {10, 10, 10, 25, 30, 30}, n = 6;
+    count(arr, n);
+}

Array/frequency.cpp

@@ -0,0 +1,34 @@
+using namespace std;
+#include <iostream>
+
+#include <unordered_set>
+int firstRepeated(int arr[], int n)
+{
+    unordered_set<int> s, p;
+    for (int i = 0; i < n; i++)
+    {
+        if (p.find(arr[i]) != p.end())
+        {
+            s.insert(arr[i]);
+        }
+        else
+        {
+            p.insert(arr[i]);
+        }
+    }
+    for (int i = 0; i < n; i++)
+    {
+        if (s.find(arr[i]) != s.end())
+        {
+            return i + 1;
+        }
+    }
+    return -1;
+}
+
+
+int main()
+{
+    int arr[7] = {1,5,3,4,3,5,6}, n = 7;
+    cout<<firstRepeated(arr,n);
+}

Array/hashing/FirstRepeating.cpp

@@ -0,0 +1,26 @@
+using namespace std;
+#include <iostream> 
+#include <unordered_map> 
+
+int longSubArrsum(int arr[], int n, int x){
+    unordered_map<int,int> m;
+    int pre_sum = 0, res = 0;
+    for (int i = 0; i < n; i++){
+        pre_sum += arr[i];
+        if(pre_sum == x){
+            res = i+1;
+        }
+        if(m.find(pre_sum) == m.end()){
+            m.insert({pre_sum,i});        
+        }
+        if (m.find(pre_sum - x) != m.end()){
+            res = max(res, i - m[pre_sum-x]);
+        }
+    }
+    return res;
+}
+
+int main(){
+    int arr[] = {4,3,8,1,2,5};
+    cout<<longSubArrsum(arr,6,8);
+}

Array/hashing/LongSubArray.cpp

@@ -0,0 +1,27 @@
+#include <iostream>
+#include <unordered_set>
+using namespace std;
+
+bool ZeroSumSubarray(int arr[], int n)
+{
+    unordered_set<int> s;
+    int curr_sum = 0;
+    s.insert(0);
+    for(int i = 0; i < n; i++)
+    {
+        curr_sum += arr[i];
+        if(s.find(curr_sum) != s.end()){
+          return true;
+        }
+          s.insert(curr_sum);
+    }
+    return false;
+}
+
+int main()
+{
+    int arr[] = {3,4,-3,-1,1};
+    int n = 5;
+    
+    cout << ZeroSumSubarray(arr, n);
+}

Array/hashing/LongSubArray.exe

@@ -0,0 +1,21 @@
+using namespace std;
+#include <iostream> 
+#include <unordered_set>
+
+int intersection(int a[], int m, int b[], int n){
+    int z = 0;
+    unordered_set<int> set(a, a+m);  
+    for (int i = 0; i < n; i++)
+    {
+        if(set.find(b[i]) != set.end()){
+            z++;
+            set.erase(b[i]);
+        }
+    }
+  return z;  
+}
+
+int main(){
+    int a[] = {5,10,15,5,10}, b[] = {15,5,5,10,4};
+    cout<<intersection(a,5,b,5);
+}

Array/hashing/SubbarraySum0.cpp

@@ -0,0 +1,42 @@
+using namespace std;
+#include <iostream> 
+#include <unordered_map> 
+
+int longSubArrsum(int arr[], int n, int x){
+    unordered_map<int,int> m;
+    int curr = 0, res = 0;
+    for (int i = 0; i < n; i++)
+    {
+        curr += arr[i];
+        if (curr == x)
+        {
+            res = i+1;
+        }
+        if (m.find(curr) == m.end())
+        {
+            m.insert({curr,i});
+        }
+        if (m.find(curr-x) != m.end())
+        {
+            res = max(res, i-m[curr-x]);
+        }
+    }
+    return res;
+}
+
+int subArray0(int arr[], int n){
+    unordered_map<int,int> m;
+    int res = 0;
+    for (int i = 0; i < n; i++)
+    {
+        if(arr[i] == 0){
+            arr[i] = -1;
+        }
+    }
+    return longSubArrsum(arr,n,0);
+}
+
+int main(){
+    int arr[] = {1,1,0,1,1,0,0}; int n = 7;
+    cout<<subArray0(arr,n);
+}