Updated

Author: dexterrxx31

217_Contains_Duplicate_LeetCode.cpp

@@ -0,0 +1,26 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+bool containsDuplicate(vector<int> &nums)
+{
+    sort(nums.begin(), nums.end());
+
+    for (int i = 1; i < nums.size() ; i++)
+    {
+        if (nums[i - 1] == nums[i])
+        {
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+}
+
+int main()
+{
+    vector<int> nums = {5,2,1,6,6,7,0};
+    cout << containsDuplicate(nums);
+    return 0;
+}

Merge_Sort_DSA.cpp

@@ -0,0 +1,73 @@
+#include<iostream>
+#include<bits/stdc++.h>
+
+using namespace std;
+
+void merge(vector<int> &array , int start , int end , int mid)
+{
+    int nn = mid - start + 1 ;
+    int mm = end - mid ;
+    
+    vector<int> temp_nn , temp_mm;
+
+    for (int i = 0; i < nn; i++)
+    {
+        temp_nn[i] = array[start + i];
+    }
+    for (int j = 0; j < mm; j++)
+    {
+        temp_mm[j] = array[mid + 1 + j];
+    }
+
+    int x , y , z ;
+    x = 0 ; 
+    y = 0 ;
+    z = start ;
+
+  while (x < nn && y < mm) {
+    if (temp_nn[x] <= temp_mm[y]) {
+      array[z] = temp_nn[x];
+      x++;
+    } else {
+      array[z] = temp_mm[y];
+      y++;
+    }
+    z++;
+  }
+
+  while (x < nn) {
+    array[z] = temp_nn[x];
+    x++;
+    z++;
+  }
+
+  while (y < mm) {
+    array[z] = temp_mm[y];
+    y++;
+    z++;
+  }
+}
+void mergeSort(vector<int> &array , int start , int end )
+{
+    if(start >= end)
+    {
+        return ;
+    }
+    int mid = ( start + end ) / 2;
+    mergeSort(array , start , mid);
+    mergeSort(array , mid+1 , end);
+    return merge(array, start , end , mid);
+}
+int main()
+{   
+    vector<int> array{10,5,2,0,7,6,4};
+    int start = 0 ;
+    int end = array.size() - 1;
+    mergeSort(array , start , end) ;
+    for(int x : array)
+    {
+        cout<< x << ",";
+    }
+    cout<<endl;
+    return 0 ;
+}

aa.txt

@@ -0,0 +1,11 @@
+5
+1
+O
+3
+XFO
+5
+FFOFF
+10
+FXXFXFOOXF
+13
+XFOFXFOFXFOFX

fb_1A.cpp

@@ -0,0 +1,34 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+using namespace std;
+
+int main()
+{
+    ifstream infile("aa.txt");
+    if (infile.is_open())
+    {
+
+        int num_of_test_cases;
+        infile>>num_of_test_cases;
+        int N;
+        string str;
+        int counter;
+        for (int i = 0; i < num_of_test_cases; i++)
+        {
+            infile >> N;
+            infile >> str;
+            counter = 0;
+            for (int j = 0; j < N; j++)
+            {
+                if ((str[j] == 'X' && str[j + 1] != 'X') || (str[j] == 'O' && str[j + 1] != 'O'))
+                {
+                    counter++;
+                }
+            }
+
+            cout << "Case #" << i + 1 << ":" << counter - 1 << endl;
+        }
+    }
+    return 0;
+}

josephus_problem.cpp

@@ -0,0 +1,20 @@
+#include<iostream>
+using namespace std ;
+
+int josp(int num , int steps)
+{
+     if ( num == 1)
+     {
+         return 0;
+     }
+
+     return (josp(num-1,steps) + steps)%num ;
+}
+
+int main()
+{   
+    int num = 5 ;
+    int steps = 2 ;
+    cout << josp(num,steps) ;
+    return 0 ;
+}

linked_list_new.cpp

@@ -0,0 +1,59 @@
+#include<iostream>
+using namespace std;
+
+struct Node {
+    int data ;
+    struct Node *next ;
+}; 
+
+void traverse_linked_list(struct Node * head)
+{
+    while(head != NULL)
+    {
+        cout << head->data <<"||" ;
+        head = head->next;
+    }
+}
+
+void add_node_to_end(struct Node* head , int data )
+{   struct Node * node_to_be_inserted = new Node ;
+    node_to_be_inserted->data =data ;
+    node_to_be_inserted->next = NULL ;
+    while (head ->next != NULL)
+    {
+        head = head->next;
+    }
+    head->next = node_to_be_inserted ;
+}
+
+struct Node* add_node_to_beginning(struct Node* head , int data )
+{   struct Node * node_to_be_inserted = new Node ;
+    node_to_be_inserted->data =data ;
+    node_to_be_inserted->next = head ;
+    return node_to_be_inserted ;
+    
+}
+
+int main()
+{   
+    struct Node * head ;
+    struct Node * first ;
+    struct Node * second ;
+
+    head = new Node ;
+    first = new Node ;
+    second = new Node ;
+
+    head->data =  67 ;
+    head->next = first ;
+    first->data = 98 ;
+    first->next = second ;
+    second->data =78 ;
+    second->next = NULL ;
+    traverse_linked_list(head);
+    
+    cout<<endl;
+    head = add_node_to_beginning()
+    traverse_linked_list(head);
+    return 0 ; 
+}

min_swap.cpp

@@ -0,0 +1,49 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int minSwaps(int arr[], int n)
+{
+	pair<int, int> ap[n];
+	for (int i = 0; i < n; i++)
+	{
+		ap[i].first = arr[i];
+		ap[i].second = i;
+	}
+
+	sort(ap, ap + n);
+	vector<bool> visited(n, false);
+
+	int result = 0;
+    
+	for (int i = 0; i < n; i++)
+	{
+	
+		if (visited[i] || ap[i].second == i)
+			continue;
+
+		int cycle_size = 0;
+		int node = i;
+		while (!visited[node])
+		{
+			visited[node] = true;
+			node = ap[node].second;
+			cycle_size++;
+		}
+
+		if (cycle_size > 0)
+		{
+			result += (cycle_size - 1);
+		}
+	}
+
+	return result;
+}
+
+
+int main()
+{
+	int arr[] = {4, 5, 1, 3, 2};
+	int n = (sizeof(arr) / sizeof(int));
+	cout << minSwaps(arr, n);
+	return 0;
+}

num_of_matrix_path.cpp

@@ -0,0 +1,20 @@
+#include<iostream>
+
+using namespace std ;
+
+
+int num_path(int rows , int columns )
+{
+    if(rows ==1 || columns == 1)
+    {
+        return 1 ;
+    }
+    return num_path(rows-1 , columns) + num_path(rows , columns -1 ) ;
+}
+int main()
+{   
+    int rows = 4 ;
+    int columns = 5 ;
+    cout<<num_path(rows, columns);
+    return 0 ;
+}

permutaions_of_string.cpp

@@ -0,0 +1,27 @@
+#include <bits/stdc++.h>
+#include <string>
+using namespace std;
+
+
+void permutation_of_string(string st , int left ,int right)
+{
+    if( left == right )
+    {
+        cout<<st<<"||" ;
+        return;
+    }
+    for (int i = left; i <= right; i++)
+    {
+        swap(st[left] , st[i]);
+        permutation_of_string(st , left+1,right);
+        swap(st[left] , st[i]);
+    }
+    
+}
+int main()
+{   
+    string st = "Riyan";
+    int num = st.length();
+    permutation_of_string(st , 0 , num-1);
+    return 0; 
+}

power_set.cpp

@@ -0,0 +1,23 @@
+#include<iostream>
+#include<string>
+using namespace std;
+
+void power_set (string st , int index , string current)
+{
+    if(index == st.length())
+    {
+        cout<<current<<"||";
+        return ;
+    }
+    power_set(st, index + 1 , current + st[index]);
+    power_set(st, index + 1 , current );
+}
+
+int main()
+{   
+    string st = "Monday";
+    int index = 0 ;
+    string current = "";
+    power_set(st, index , current);
+    return 0 ;
+}

rain_water_trap.cpp

@@ -0,0 +1,32 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int trappedWater(vector<int> heights) {
+
+ 	int n = heights.size();
+ 	if(n<=2){
+ 		return 0;
+ 	}
+
+ 	vector<int> left(n,0), right(n,0);
+ 	left[0] = heights[0];
+ 	right[n-1] = heights[n-1];
+
+ 	for(int i=1;i<n;i++){
+ 		left[i] = max(left[i-1],heights[i]);
+ 		right[n-i-1] = max(right[n-i],heights[n-i-1]);
+ 	}
+
+ 	int water = 0;
+ 	for(int i=0;i<n;i++){
+ 		water += min(left[i],right[i]) - heights[i];
+ 	}
+	
+  return water;
+}
+
+int main() {
+    vector<int> water = {0,1,0,2,1,0,1,3,2,1,2,1};
+    cout<<trappedWater(water)<<endl;
+    return 0;
+}