Add files via upload

Author: 5codeman

Diff for: Lecture 4 - Recursion 2/Binary Search (Recursive).cpp

@@ -0,0 +1,26 @@
+// input - input array
+// size - length of input array
+// element - value to be searched
+int findelement(int input[], int x, int left, int right)
+{
+    if(left > right) return - 1;
+
+    int mid = (left + right) / 2;
+
+    if(input[mid] == x) return mid;
+
+    if(input[mid] > x)
+    {
+        return findelement(input, x, left, mid - 1);
+    }
+
+    else if(input[mid] < x)
+    {
+        return findelement(input, x, mid + 1, right);
+    }
+}
+int binarySearch(int input[], int size, int element) {
+    // Write your code here
+    return findelement(input, element, 0, size - 1);
+
+}

Diff for: Lecture 4 - Recursion 2/Check AB.cpp

@@ -0,0 +1,24 @@
+bool checkInput(char input[], int size, bool check)
+{
+	if(size == 0) return true;
+
+		if(input[0] == 'a')
+		{
+			checkInput(input + 1, size - 1, true);
+		}
+		else if(check == true && input[0]== 'b' && input[1] == 'b')
+		{
+			checkInput(input + 2, size - 2, false);
+		}
+		else return false;
+}
+bool checkAB(char input[]) {
+	// Write your code here
+	int size = 0;
+	for(int i = 0; input[i] != '\0'; i++) size++;
+	if(input[0] != 'a') return false;
+	else checkInput(input + 1, size -1, true);
+}
+
+
+

Diff for: Lecture 4 - Recursion 2/Get All Unique Subsets.cpp

@@ -0,0 +1,38 @@
+map<vector<int>, int> mp;
+
+int getUniqueSubsets(vector<int>& arr, int size, vector<vector<int>>& output)
+{
+    if(size == 0)
+    {
+        vector<int> temp;
+        output.push_back(temp);
+        return 1;
+    }
+   
+    int set1 = getUniqueSubsets(arr, size - 1, output);
+   
+   //copying
+    for(int i = 0; i < set1; i++)
+    {
+        vector<int> temp;
+        for(int j = 0; j < output[i].size(); j++)
+        {
+            temp.push_back(output[i][j]);
+        }
+        temp.push_back(arr[size - 1]);
+         if(mp.count(temp) == 0)
+         {
+            mp[temp] = 1;
+            output.push_back(temp);
+         }
+    }   
+    return output.size(); 
+}
+
+vector<vector<int>> getUniqueSubsets(vector<int>& arr) {
+    // Write Your Code Here    
+    vector<vector<int>>output;
+    int len = arr.size();
+    getUniqueSubsets(arr, len, output);
+    return output;
+}

Diff for: Lecture 4 - Recursion 2/Merge Sort Code.cpp

@@ -0,0 +1,56 @@
+#include<bits/stdc++.h>
+using namespace std;
+void mergeSort(int arr[], int l, int r) {
+    
+    // Write Your Code Here
+    int mid = (l + r) / 2;
+
+    if(l == r) return; 
+
+    mergeSort(arr, l, mid);
+    mergeSort(arr, mid + 1, r);
+
+    vector<int>temp;
+
+    int a1 = l; 
+    int a2 = mid + 1; 
+
+    while(a1 != mid + 1 && a2 != r + 1) 
+    {
+      if (arr[a1] < arr[a2]) 
+      {
+        temp.push_back(arr[a1]);
+        a1++;
+      }
+
+      else if(arr[a1] >= arr[a2]) 
+      {
+        temp.push_back(arr[a2]);
+        a2++;
+      }
+      
+    }
+
+    if(a1 == mid + 1) 
+    {
+        while(a2 != r + 1) 
+        {
+            temp.push_back(arr[a2]);
+            a2++;
+        }
+    }
+
+    if(a2 == r + 1) 
+    {
+        while(a1 != mid + 1) 
+        {
+            temp.push_back(arr[a1]);
+            a1++;
+        }
+    }
+   
+    for(int i = l; i <= r; i++) { 
+        arr[i] = temp[i - l]; 
+    }
+
+}

Diff for: Lecture 4 - Recursion 2/Print Keypad Combinations Code.cpp

@@ -0,0 +1,29 @@
+#include <iostream>
+#include <string>
+using namespace std;
+
+string key[] = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+
+void printAll(int num, string output) 
+{
+    if(num == 0 || num == 1)
+    {
+        cout << output << endl;
+        return;
+    }
+
+    string KEY = key[num % 10];
+
+    for(int i = 0; i < KEY.size(); i++)
+    {
+        printAll(num / 10,  KEY[i] + output);
+    }
+}
+
+void printKeypad(int num){
+    /*
+    Given an integer number print all the possible combinations of the keypad. You do not need to return anything just print them.
+    */
+    string output = "";
+    printAll(num, output);
+}

Diff for: Lecture 4 - Recursion 2/Print Permutations.cpp

@@ -0,0 +1,26 @@
+#include <iostream>
+#include <string>
+using namespace std;
+
+void Permutations(string input, string output)
+{
+	if(input.length() == 0)
+	{
+		cout << output << endl;
+		return;
+	}
+
+	for(int i = 0; i <= output.length(); i++)
+	{
+		Permutations(input.substr(1),  output.substr(0, i) + input[0] + output.substr(i));
+	}
+}
+
+void printPermutations(string input){
+
+    	/* Don't write main() function.
+	 * Don't read input, it is passed as function argument.
+	 * Print output as specified in the question
+	*/
+	Permutations(input, "");
+}

Diff for: Lecture 4 - Recursion 2/Print Subset Sum to K.cpp

@@ -0,0 +1,33 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+void printSubset(int input[], int size, int k, vector<int> arr) {
+    if(size == 0)
+    {
+        int sum = 0;
+        for (int i = 0; i < arr.size(); i++) 
+        {
+            sum += arr[i];
+        }
+        if(sum == k) 
+        {
+            for(int i = 0; i < arr.size(); i++)
+            {
+                cout << arr[i] << " ";
+            }
+            cout << endl;
+            //return;
+        }
+        return;
+    }
+
+    printSubset(input + 1, size - 1, k, arr);
+    arr.push_back(input[0]);
+    printSubset(input + 1, size - 1, k, arr);
+}
+
+void printSubsetSumToK(int input[], int size, int k) {
+    // Write your code here
+    vector<int> arr;
+    printSubset(input, size, k, arr);
+}

Diff for: Lecture 4 - Recursion 2/Print all Codes - String.cpp

@@ -0,0 +1,33 @@
+#include <string.h>
+using namespace std;
+
+void printAllCodes(string input, string output) 
+{
+    if(input.length() == 0)
+    {
+        cout << output <<endl;
+        return;
+    }
+
+    int integer = input[0] - '0';
+    char cr = (integer - 1) + 'a';
+
+    printAllCodes(input.substr(1, input.size() - 1), output + cr);
+
+    int integer1 = integer * 10 + input[1] - '0'; 
+    char cr1 = (integer1 - 1) + 'a';
+    
+    if(input.size() >= 2 && integer1 <= 26)
+    {
+        printAllCodes(input.substr(2, input.size() - 2), output + cr1);
+    }
+}
+
+void printAllPossibleCodes(string input) {
+    /*
+    Given the input as a string, print all its possible combinations. You do not need to return anything.
+    */
+    string output = "";
+    printAllCodes(input, output);
+}
+

Diff for: Lecture 4 - Recursion 2/Quick Sort Code.cpp

@@ -0,0 +1,51 @@
+/*
+	The function is called with the parameters:
+	quickSort(input, 0, size - 1);
+
+*/
+
+int partitionArray(int input[], int start, int end) {
+	// Write your code here
+	int pivot_element = input[start];
+	int count = 0;
+	int x = start;
+	for(int i = start + 1; i <= end; i++)
+	{
+		if(input[i] <= pivot_element) count++;
+	}
+
+	//keep pivot element at their correct index
+	input[start] = input[start + count];
+	input[start + count] = pivot_element;
+	
+	while (start < end) 
+	{
+		if(input[start] > pivot_element && input[end] <= pivot_element)
+		{
+			int temp = input[start];
+			input[start] = input[end];
+			input[end] = temp;
+			start++;
+			end--;
+		}
+		else if(input[start] <= pivot_element) start++;
+
+		else if(input[end] > pivot_element) end--;
+	}
+	return x + count;
+}
+
+void quickSort(int input[], int start, int end) {
+	/*
+		Don't write main().
+		Don't read input, it is passed as function argument.
+		Change in the given array itself.
+		Taking input and printing output is handled automatically.
+	*/
+	if(start >= end) return;
+
+	int pivot =  partitionArray(input, start, end);
+
+	quickSort(input, start, pivot - 1);
+	quickSort(input, pivot + 1, end);
+}

Diff for: Lecture 4 - Recursion 2/Remove Duplicates Recursively.cpp

@@ -0,0 +1,24 @@
+void removeConsecutiveDuplicates(char *input) {
+	/* Don't write main().
+	* Don't read input, it is passed as function argument.    
+	* Change in the given string itself.
+	* No need to return or print anything
+	* Taking input and printing output is handled automatically.
+	*/
+
+	if(input[0] == '\0') return;
+
+	if(input[0] == input[1])
+	{
+		//left shift
+		int i = 1;
+		while(input[i] != '\0')
+		{
+			input[i - 1] = input[i];
+			i++;
+		}
+		input[i - 1] = '\0';
+		return removeConsecutiveDuplicates(input);
+	}
+	return removeConsecutiveDuplicates(input + 1);
+}

Diff for: Lecture 4 - Recursion 2/Replace Character Recursively.cpp

@@ -0,0 +1,17 @@
+void replaceCharacter(char input[], char c1, char c2) {
+    /* Don't write main().
+     * Don't read input, it is passed as function argument.
+     * No need to print or return the output. 
+     * Change in the given input string itself.
+     * Taking input and printing output is handled automatically.
+     */
+
+     if(input[0] == '\0') return;
+
+     if (input[0] == c1) 
+     {
+       input[0] = c2;
+       return replaceCharacter(input + 1, c1, c2);
+     }
+     return replaceCharacter(input + 1, c1, c2);
+}