Added recursion

README.md

@@ -8,5 +8,6 @@ Sections
 - Getting started with C++
 - Programming Fundamentals
 - Programming Fundamentals-II
+- Recursion
 
 

Recursion/1. Basics/Modular exponentiation/power or exponentiation.cpp

@@ -0,0 +1,25 @@
+// exponentiation using recursion
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int power(int a, int b){
+	// Base case 
+	if(b==0) return 1;
+	return a*power(a,b-1);
+}
+
+int powerFast(int a, int b){
+	// Base case
+	if(b==0) return 1;
+	if(b&1) return a*power(a, b/2)*power(a, b/2);
+	else return power(a, b/2)*power(a, b/2);
+}
+
+int main(){
+	int a, b; cin>>a>>b;
+	cout<<power(a,b)<<endl;
+	cout<<powerFast(a,b)<<endl;
+}
+
+

Recursion/1. Basics/firstOcc/firstOcc.cpp

@@ -0,0 +1,40 @@
+// first Occurence of key in an array
+
+#include<bits/stdc++.h>
+#include<climits>
+#include<algorithm>
+#include<math.h>
+#define ll long long
+#define MAX 100000
+using namespace std;
+
+int firstOcc(int arr[], int s, int e, int key){
+	// Base case
+	if(s==e) return -1;
+	if(arr[s]==key) return s;
+
+	return firstOcc(arr, s+1, e, key);
+}
+
+void allOcc(int arr[], int s, int e, int key){
+	// Base case
+	if(s==e) return;
+	else if(arr[s]==key){
+		cout<<s<<" ";
+		allOcc(arr, s+1, e, key);
+	}
+	else{
+		allOcc(arr, s+1, e, key);
+	}
+}
+
+
+int main(){
+	int arr[]={1,2,3,7,4,5,6,7,10};
+	int key=7;
+	int n=sizeof(arr)/sizeof(arr[0]);
+	cout<<firstOcc(arr, 0, n, key)<<endl;
+	allOcc(arr, 0, n, key);
+}
+
+

Recursion/1. Basics/inc dec order/print rec.cpp

@@ -0,0 +1,44 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+void printDec(int n){
+	cout<<n<<" ";
+	// Base Case 
+	if(n==1) return;
+	printDec(n-1);
+}
+
+//void printDec(int n){
+//	// Base Case 
+//	if(n==0) return;
+//	
+//	cout<<n<<" ";
+//	printDec(n-1);
+//}
+
+
+void printInc(int n){
+	// Base Case
+	if(n==1){
+		cout<<n<<" ";
+		return;
+	}
+	printInc(n-1);
+	cout<<n<<" ";
+}
+
+//void printInc(int n){
+//	// Base Case
+//	if(n==0){
+//		return;
+//	}
+//	printInc(n-1);
+//	cout<<n<<" ";
+//}
+
+int main(){
+	printDec(5); cout<<endl;
+	printInc(5);
+}
+
+

Recursion/2. Implementation based/bubble sort rec/bubble sort rec.cpp

@@ -0,0 +1,49 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+bool compare(int a, int b){
+	return a<b;
+}
+
+void bubbleSort(int arr[], int n){
+	//Base case
+	if(n==1){
+		return;
+	}
+
+	for(int i=0; i<n-1; i++){
+		if(compare(arr[i+1], arr[i])){
+			swap(arr[i+1], arr[i]);
+		}
+	}
+
+	bubbleSort(arr, n-1);
+
+}
+
+// fully recursive
+void bubbleSortRec(int arr[], int i, int n){
+	// Base case
+	if(n==1) return;
+	if(i==n-1){
+		//single pass of the current array has been done
+		return bubbleSortRec(arr, 0, n-1);
+	}
+
+	if(compare(arr[i+1], arr[i])){
+		swap(arr[i+1], arr[i]);
+	}
+	bubbleSortRec(arr, i+1, n);
+}
+
+
+int main(){
+	int arr[]={1,4,7,3,9,10,6};
+	int n=sizeof(arr)/sizeof(arr[0]);
+	bubbleSortRec(arr,0, n);
+	for(int i=0; i<n; i++){
+		cout<<arr[i]<<" ";
+	}
+}
+
+

Recursion/2. Implementation based/inv count/inv count.cpp

@@ -0,0 +1,58 @@
+#include<bits/stdc++.h>
+#include<vector>
+#define MAX 100000
+using namespace std;
+int inv=0;
+
+void merge(vector<int> &a, vector<int> &b, vector<int> &toreturn){ //You are given two sorted arrays A and B. You want to merge these arrays and return a sorted vector will elements from both arrays.
+    int apointer = 0, bpointer = 0; //point to the first element in the vectors
+    //That hasn't been taken yet
+    while(apointer<a.size() && bpointer<b.size()){
+        if(a[apointer]<=b[bpointer]){
+            toreturn.push_back(a[apointer++]);
+        }
+        else{ //b[bpointer] < a[apointer]
+            inv += (a.size() - apointer);
+            toreturn.push_back(b[bpointer++]);
+        }
+    }
+    while(apointer<a.size()) toreturn.push_back(a[apointer++]);
+    while(bpointer<b.size()) toreturn.push_back(b[bpointer++]);
+}
+
+void ms(int arr[], int s, int e){
+//	cout<<s<<" "<<e<<endl;
+	if(s==e){// there is only one or no element
+		return;
+	}
+	int mid = (s+e)/2;
+	ms(arr, s, mid);
+	ms(arr, mid+1, e);
+
+	// Now arr[] has two sorted parts inside it. 
+	// We have to take them out, merge the two parts and 
+	// then resassign the values to arr[]
+	vector<int> a,b;
+	for(int i=s; i<=mid; i++) a.push_back(arr[i]);
+	for(int i=mid+1; i<=e; i++) b.push_back(arr[i]);  
+
+	vector<int> temp;
+	merge(a,b, temp);
+	for(int i=0; i<temp.size(); i++){
+		arr[s+i] = temp[i];
+	}
+}
+
+
+
+int main(){
+	int n; cin>>n; 
+	int arr[n];
+	for(int i=0; i<n; i++) cin>>arr[i];
+	ms(arr, 0, n-1);
+	for(int i=0; i<n; i++) cout<<arr[i]<<" ";
+	cout<<endl;
+	cout<<"Inv = "<<inv<<endl;
+}
+
+

Recursion/2. Implementation based/quick sort/quick sort.cpp

@@ -0,0 +1,51 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int partition(int arr[], int s, int e){
+	// inplace partition
+	int pivot = e;
+	int i=s-1;
+
+	for(int j=s; j<e; j++){
+
+		if(arr[j]<=arr[pivot]){
+			i++;
+			swap(arr[i], arr[j]);
+		}
+		if(arr[j]>arr[pivot]){
+			// j already increases
+		}
+
+	}
+	// Placing pivot element at correct place
+	swap(arr[i+1], arr[pivot]);
+
+	return i+1;
+
+}
+
+void quicksort(int arr[], int s, int e){
+	// Base Case
+	if(s>=e){
+		// One or no element is present in the array.
+		// So it is sorted.
+		return;
+	}
+	int p=partition(arr, s, e);
+
+	quicksort(arr, s, p-1);
+	quicksort(arr, p+1, e);
+}
+
+int main(){
+	int arr[]={2,7,8,6,1,5,4};
+	int n = sizeof(arr)/sizeof(arr[0]);
+
+	quicksort(arr, 0, n-1);
+
+	for(int i=0; i<n; i++){
+		cout<<arr[i]<<" ";
+	}
+}
+
+

Recursion/3. Quick Thinking/2048 problem recursion/2048 problem recursion.cpp

@@ -0,0 +1,39 @@
+#include<bits/stdc++.h>
+#include<climits>
+#include<algorithm>
+#include<math.h>
+#define ll long long
+#define MAX 100000
+using namespace std;
+
+void print(int n){
+
+	switch(n){
+		case 0: cout<<"zero"; break;
+		case 1: cout<<"one"; break;
+		case 2: cout<<"two"; break;
+		case 3: cout<<"three"; break;
+		case 4: cout<<"four"; break;
+		case 5: cout<<"five"; break;
+		case 6: cout<<"six"; break;
+		case 7: cout<<"seven"; break;
+		case 8: cout<<"eight"; break;
+		case 9: cout<<"nine"; break;
+		default: cout<<"error"; 
+	}
+}
+
+void fun(int n){
+	// Base case
+	if(n==0) return;
+
+	fun(n/10);
+	print(n%10); cout<<" ";
+}
+
+int main(){
+	int n=204478;
+	fun(n);
+}
+
+

Recursion/3. Quick Thinking/Friends pairing problem/friends pairing problem.cpp

@@ -0,0 +1,36 @@
+// Friends pairing problem
+
+// Given N, frinds who want to go to a party on bikes.
+// Each person can go single, or as a couple. Find the number of ways in which N friends can go to the party.
+
+#include<bits/stdc++.h>
+#define MAX 100000
+using namespace std;
+
+int noOfWays(int n){
+	// Base Case
+	if(n==1 || n==0) return 1;
+	if(n==2) return 2;
+
+	return noOfWays(n-1)+(n-1)*noOfWays(n-2);
+}
+
+int topDown(int n, int dp[]){
+	// Lookup
+	if(dp[n]!=-1){
+		return dp[n];
+	}
+
+	return dp[n]=topDown(n-1, dp) + (n-1)*topDown(n-2, dp);
+}
+
+int main(){
+	int dp[MAX];
+	std::fill_n(dp, MAX, -1);
+	dp[0]=1; dp[1]=1; dp[2]=2;
+	int n; cin>>n;
+	cout<<noOfWays(n)<<endl;
+	cout<<topDown(n, dp);
+}
+
+

Recursion/3. Quick Thinking/Ladder problem/Ladder problem.cpp

@@ -0,0 +1,25 @@
+//Total n steps to be taken.
+// at one time, we can take 1,2,3 steps. How many ways?
+
+#include<bits/stdc++.h>
+#include<climits>
+#include<algorithm>
+#include<math.h>
+#define ll long long
+#define MAX 100000
+using namespace std;
+
+int main(){
+	int dp[MAX]{0};
+	dp[1]=1; dp[2]=2; dp[3]=4;
+
+	for(int i=4; i<MAX; i++){
+		dp[i] = dp[i-1] + dp[i-2] + dp[i-3];
+	}
+
+	int n; cin>>n;
+	cout<<dp[n];
+
+}
+
+