recursion

Author: Mohit Jain

2048Recursion.cpp

@@ -0,0 +1,33 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+// Problem 
+// Number to spellings
+// 2048 -----> two zero four eight
+
+char words[][10] = {"zero","one", "two", "three", "four", 
+                    "five", "six", "seven", "eight", "nine"};
+
+void printSpellings(int n){
+   if(n ==0) return;
+
+   printSpellings(n/10);
+   int digit = n%10;
+
+   cout<< words[digit]<<" ";
+
+   return;
+
+}
+
+int main() {
+   
+   int n;
+
+   cin>>n;
+
+   printSpellings(n);
+
+	return 0;
+}

BubbleSortRecursion.cpp

@@ -0,0 +1,45 @@
+#include <bits/stdc+.h>
+
+using namespace std;
+
+
+// Bubble Sort Recursively
+
+void bubble_sort(int a[], int n){
+   
+   if(n == 1) return;
+
+   for(int j =0; j <n-1; j ++) {
+   	if(a[j]>a[j+1]){
+   		swap(a[j],a[j+1]);
+   	}
+   }
+
+   bubble_sort(a,n-1);
+
+
+}
+
+void bubble_sort_recursive(int a[], int j, int n) {
+	// base case
+	if(n == 1) return;
+
+	if(j == n-1) {
+		return bubble_sort_recursive(a, 0, n-1);
+	}
+	if(a[j]>a[j+1]) {
+		swap(a[j],a[j+1]);
+	}
+
+	bubble_sort_recursive(a,j+1,n);
+
+	return;
+}
+
+int main() {
+
+  int a[] = {5,4,3,2,1};
+  int n=  5;
+
+	return 0;
+}

Fast_power.cpp

@@ -0,0 +1,38 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+
+
+int power(int a, int n) {
+
+	if(n == 0 ) return 1;
+
+	return a*power(a,n-1);
+}
+
+int fast_power(int a, int n) {
+
+   if (n == 0) return 1;
+
+
+   int subAns = fast_power(a, n/2);
+
+   subAns *= subAns;
+
+   if(n&1) return  subAns*a;
+
+   return subAns;
+
+}
+
+int main() {
+
+	int a,n;
+
+	cin>>a>>n;
+   
+      fast_power(a,n);
+
+	return 0;
+}

input.txt

@@ -1,2 +1 @@
-1
-132
+1234

inversionCount.cpp

@@ -0,0 +1,75 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+
+int merge(int *a, int s, int e) {
+
+	int mid = (s+e) / 2;
+
+	int i =s;
+	int j = (mid+1);
+
+	int k =s;
+
+	int temp[100000];
+
+	int cnt = 0;
+
+	while(i <=mid and j<=e) {
+       
+       if(a[i]<= a[j]){
+       	temp[k++] = a[i++];
+       }
+
+       else {
+       	temp[k++] = a[j++];
+       	cnt+= mid-i+1;
+       }
+
+
+	}
+	while(i<=mid){
+		temp[k++] = a[i++];
+	}
+
+		while(j<=e){
+		temp[k++] = a[j++];
+	}
+
+		for(int i = s;i<=e; i++) {
+		a[i] = temp[i];
+	}
+
+	return cnt;
+}
+
+
+int inversion_count(int *arr, int s, int e) {
+
+	if(s>=e){
+		return 0;
+	}
+
+	int mid = (s+e)/2;
+
+	int x = inversion_count(a,s,mid);
+	int y = inversion_count(a,mid+1,e);
+
+	int z = merge(a,s,e);
+
+	return x+y+z;
+
+
+
+}
+
+int main() {
+
+   int arr[] = {1,5,2,6,3,0};
+
+   int n = sizeof(arr)/ sizeof(int);
+
+  
+	return 0;
+}

mergeSortRecursive.cpp

@@ -0,0 +1,81 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+
+void merge(int *a, int s, int e) {
+
+	int mid = (s+e)/2;
+
+	int i= s;
+
+	int j = mid+1;
+
+	int k = s;
+	int temp[100];
+
+	while(i<=mid && j<=e) {
+		if(a[i] <a[j]) {
+			temp[k++] = a[i++];
+
+		}
+		else {
+			temp[k++] = a[j++];
+		}
+	}
+
+	while(i <= mid) {
+		temp[k++] = a[i++];
+	}
+
+	while(j <=e) {
+		temp[k++] = a[j++];
+	}
+
+	for(int i = s;i<=e; i++) {
+		a[i] = temp[i];
+	}
+}
+
+void mergeSort(int a[], int s , int e) {
+    
+
+    //Base Case
+     if (s >=e) {
+     	return;
+     }  
+
+     int mid = (s+e) /2;
+
+     mergeSort(a,s,mid);
+
+     mergeSort(a,mid+1,e);
+
+     merge(a,s,e);
+
+
+
+
+
+
+
+
+}
+
+
+int main() {
+
+  int a[100];
+
+  int n;
+
+  cin>>n;
+
+for(int i=0; i<n; i++) {
+	cin>>a[i];
+}
+   mergeSort(a,0,n-1);
+
+
+	return 0;
+}

output.txt

@@ -1,3 +1 @@
-2 
-3 
-11 
+1234

quickSort

@@ -0,0 +1,51 @@
+#include<bits/stdc++.h>
+
+using namespace std;
+
+int  partitiona(int *a, int s, int e) {
+
+
+	int i = s - 1; 
+	int j = s;
+   int pivot = a[e];
+	for(;j <=e-1;){
+      if(a[j]<=pivot) {
+
+      	i = i+1;
+      	swap(a[i],a[j]);
+      }
+      j= j+1;
+	}
+
+	swap(a[i+1], a[e]);
+
+	return i +1;
+}
+
+void quicksort(int *arr, int s, int e) {
+
+
+	if(s>=e) return; 
+
+	int p =  partitiona(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(int);
+
+    quicksort(arr,0,n-1);
+
+
+
+return 0;
+
+}