Completed Recursion - 2

Author: roydevashish

F19Recursion-2/MergeSort.cpp

@@ -0,0 +1,119 @@
+/*
+Title: Merge Sort
+
+Problem statement
+You are given the starting 'l' and the ending 'r' positions of the array 'ARR'.
+You must sort the elements between 'l' and 'r'.
+
+Note:
+Change in the input array itself. So no need to return or print anything.
+Example:
+Input: ‘N’ = 7,
+'ARR' = [2, 13, 4, 1, 3, 6, 28]
+
+Output: [1 2 3 4 6 13 28]
+
+Detailed explanation ( Input/output format, Notes, Images )
+Input format :
+The first line contains an integer <em>**'N'**</em> representing the size of the array/list.
+The second line contains 'N' single space-separated integers representing the elements in
+the array/list.
+
+Output format :
+You don't need to return anything. In the output, you will see the array after you do the
+modification.
+
+Sample Input 1:
+7
+2 13 4 1 3 6 28
+
+Sample Output 1:
+1 2 3 4 6 13 28
+
+Explanation of Sample Output 1:
+After applying 'merge sort' on the input array, the output is [1 2 3 4 6 13 28].
+
+Sample Input 2:
+5
+9 3 6 2 0
+
+Sample Output 2:
+0 2 3 6 9
+
+Explanation of Sample Output 2:
+After applying 'merge sort' on the input array, the output is [0 2 3 6 9].
+
+Constraints :
+1 <= N <= 10^3
+0 <= ARR[i] <= 10^9
+*/
+
+#include <iostream>
+using namespace std;
+
+void Merge(int array[], int l, int mid, int r) {
+    int left_size = (mid - l) + 1;
+    int right_size = (r - mid);
+
+    int array_left[left_size];
+    int array_right[right_size];
+
+    for (int i = 0; i < left_size; i++) {
+        array_left[i] = array[l + i];
+    }
+
+    for (int i = 0; i < right_size; i++) {
+        array_right[i] = array[mid + 1 + i];
+    }
+
+    int idx_left = 0;
+    int idx_right = 0;
+    int idx_array = l;
+
+    while (idx_left < left_size && idx_right < right_size) {
+        if (array_left[idx_left] <= array_right[idx_right]) {
+            array[idx_array++] = array_left[idx_left++];
+        } else {
+            array[idx_array++] = array_right[idx_right++];
+        }
+    }
+
+    while (idx_left < left_size) {
+        array[idx_array++] = array_left[idx_left++];
+    }
+
+    while (idx_right < right_size) {
+        array[idx_array++] = array_right[idx_right++];
+    }
+}
+
+void MergeSort(int array[], int l, int r) {
+    if (r - l < 1) {
+        return;
+    }
+
+    int mid = (l + r) / 2;
+    MergeSort(array, l, mid);
+    MergeSort(array, mid + 1, r);
+    Merge(array, l, mid, r);
+}
+
+int main() {
+    int n;
+    cin >> n;
+
+    int arr[n];
+    for (int i = 0; i < n; i++) {
+        cin >> arr[i];
+    }
+
+    int arr_size = sizeof(arr) / sizeof(arr[0]);
+
+    MergeSort(arr, 0, arr_size - 1);
+
+    for (int i = 0; i < arr_size; i++) {
+        cout << arr[i] << " ";
+    }
+    cout << endl;
+    return 0;
+}

F19Recursion-2/QuickSort.cpp

@@ -0,0 +1,117 @@
+/*
+Title: Quick Sort
+
+Problem statement
+Given the 'start' and the 'end'' positions of the array 'input'. Your task is to sort the elements
+between 'start' and 'end' using quick sort.
+
+Note : Make changes in the input array itself.
+
+Detailed explanation ( Input/output format, Notes, Images )
+Input format :
+Line 1 : Integer N i.e. Array size
+Line 2 : Array elements (separated by space)
+
+Output format :
+Array elements in increasing order (separated by space)
+
+Sample Input 1 :
+6
+2 6 8 5 4 3
+
+Sample Output 1 :
+2 3 4 5 6 8
+
+Sample Input 2 :
+5
+1 2 3 5 7
+
+Sample Output 2 :
+1 2 3 5 7
+
+Constraints :
+1 <= N <= 10^3
+0 <= input[i] <= 10^9
+*/
+
+#include<iostream>
+#include<vector>
+using namespace std;
+
+int Partition(int arr[], int low, int high) {
+    int idxPivot = high;
+    int idxSmallerElement = low-1;
+
+    for(int i = low; i <= high; i++) {
+        if(arr[i] < arr[idxPivot]) {
+            idxSmallerElement++;
+
+            int temp = arr[i];
+            arr[i] = arr[idxSmallerElement];
+            arr[idxSmallerElement] = temp;
+        }
+    }
+
+    idxSmallerElement++;
+    int temp = arr[idxSmallerElement];
+    arr[idxSmallerElement] = arr[idxPivot];
+    arr[idxPivot] = temp;
+
+    return idxSmallerElement;
+}
+
+void QuickSort(int arr[], int low, int high) {
+    if(low <= high) {
+        int idxPartition = Partition(arr, low, high);
+        QuickSort(arr, low, idxPartition-1);
+        QuickSort(arr, idxPartition+1, high);
+    }
+}
+
+class Runner {
+    vector<int> v;
+
+    public:
+        void takeInput() {
+            int n;
+            cin >> n;
+            v.resize(n);
+            for (int i = 0; i < n; i++)
+                cin >> v[i];
+        }
+
+        void execute() {
+            int n = (int)v.size();
+
+            int* input = new int[n];
+            for (int i = 0; i < n; i++)
+                input[i] = v[i];
+
+            QuickSort(input, 0, n - 1);
+
+            free(input);
+        }
+
+        void executeAndPrintOutput() {
+            int n = (int)v.size();
+
+            int* input = new int[n];
+            for (int i = 0; i < n; i++)
+                input[i] = v[i];
+
+            QuickSort(input, 0, n - 1);
+
+            for (int i = 0; i < n; i++)
+                cout << input[i] << ' ';
+            cout << '\n';
+
+            free(input);
+        }
+};
+
+int main() {
+    Runner runner;
+    runner.takeInput();
+    runner.executeAndPrintOutput();
+    return 0;
+}

F19Recursion-2/RemoveDuplicatesRecursively.cpp

@@ -0,0 +1,57 @@
+/*
+Title: Remove duplicates
+
+Problem statement
+Given a string S, remove consecutive duplicates from it recursively.
+
+Detailed explanation ( Input/output format, Notes, Images )
+Input Format :
+String S
+
+Output Format :
+Output string
+
+Constraints :
+1 <= |S| <= 10^3
+where |S| represents the length of string
+
+Sample Input 1 :
+aabccba
+
+Sample Output 1 :
+abcba
+
+Sample Input 2 :
+xxxyyyzwwzzz
+
+Sample Output 2 :
+xyzwz
+*/
+
+#include<iostream>
+using namespace std;
+
+void RemoveConsecutiveDuplicates(char s[]) {
+    if(s[0] == '\0') {
+        return;
+    }
+
+    RemoveConsecutiveDuplicates(&s[1]);
+
+    if(s[0] == s[1]) {
+        int idx = 0;
+        while(s[idx] != '\0') {
+            s[idx] = s[idx+1];
+            idx++;
+        }
+    }
+
+    return;
+}
+
+int main() {
+    char s[100000];
+    cin >> s;
+    RemoveConsecutiveDuplicates(s);
+    cout << s << endl;
+}

F19Recursion-2/RemoveX.cpp

@@ -0,0 +1,63 @@
+/*
+Title: Remove X
+
+Problem statement
+Given a string, compute recursively a new string where all 'x' chars have been removed.
+
+Detailed explanation ( Input/output format, Notes, Images )
+Input format :
+String S
+
+Output format :
+Modified String
+
+Constraints :
+1 <= |S| <= 10^3
+where |S| represents the length of string S.
+
+Sample Input 1 :
+xaxb
+
+Sample Output 1:
+ab
+
+Sample Input 2 :
+abc
+
+Sample Output 2:
+abc
+
+Sample Input 3 :
+xx
+
+Sample Output 3:
+*/
+
+#include<iostream>
+#include<typeinfo>
+using namespace std;
+
+void RemoveX(char * input) {
+    if(input[0] == '\0') {
+        return;
+    }
+
+    RemoveX(&input[1]);
+
+    if(input[0] == 'x') {
+        int i = 0;
+        while(input[i] != '\0') {
+            input[i] = input[i+1];
+            i++;
+        }
+    }
+
+    return;
+}
+
+int main() {
+    char input[100];
+    cin.getline(input, 100);
+    RemoveX(input);
+    cout << input << endl;
+}