new question added

Author: arorarahul

README.md

@@ -134,6 +134,8 @@ used where if an element should be repeating a given number of times, you can ch
 i+given number of times to see if thats true or not.
 - In divide and conquer even number of multiplications can be reduced from n to logn to get the same result. Example is the pow function where the base value is square everytime and power is halved everytime to get the same answer in logn multiplications. In case the power value is odd, the result is given the base value such that power value is converted to even and then same operations are applied.
 - In binary search whatever the algo be, always start from the middle and compare values to the left or right. You may even compare the extreme left and the right values to see lower and upper bound or some pattern to solve the algo. But in binary search always start from the middle.
+- Sometimes rather than searching in left array or right array, it is better to divide into two components/groups and apply various operations like comparison, merges etc. Note: since its divide and conquer number of division should be done till the end where we will be left with one element in each group.
+- Sometimes, we apply binary search and on finding the middle element we apply the logic that is the crux of the algo to the middle element to find out whether to search in right array or left array.
 
 # Topic0: Programming Questions
 
@@ -320,7 +322,8 @@ i+given number of times to see if thats true or not.
 - [Nuts and bolts problem](/divide-and-conquer/question2.c)
 - [Write a custom C function to implement a pow function](/divide-and-conquer/question3.c)
 - [Select an element in sorted rotated array](/divide-and-conquer/question4.c)
-
+- [Count inversions in an array](/divide-and-conquer/question5.c)
+- [Find the missing number in arithmetic progression](/divide-and-conquer/question6.c)
 
 ## Some important concepts to solve algos better
 

divide-and-conquer/a.exe

@@ -37,16 +37,31 @@ Space complexity: O(1) or O(logn) //iterative or recursive
 //METHOD2
 #include <stdio.h>
 #include <stdlib.h>
-
+//recursion
 int search(int *arr,int start,int end, int elm){
 	if(start > end) return -1;
 	int mid = (start + end)/2;
 	if(arr[mid] == elm) return mid;
 
-	if(arr[start] <= arr[mid]){
-		return (elm >= arr[start] && elm <=arr[mid])?search(arr,start,mid-1,elm):search(arr,mid+1,end,elm);
-	}	
-	return (elm >= arr[mid] && elm <= arr[end])?search(arr,mid+1,end,elm):search(arr,start,mid-1,elm);
+	if(arr[mid] <= arr[end]){
+		return (elm >= arr[mid] && elm <=arr[end])?search(arr,mid+1,end,elm):search(arr,start, mid-1,elm);	
+	}
+	return (elm >= arr[start] && elm <= arr[mid])?search(arr,start,mid-1,elm):search(arr,mid+1,end,elm);
+}
+//iteration
+int searchIterative(int *arr, int start, int end, int elm){
+	while(start <= end){
+		int mid = (start + end)/2;
+		if(arr[mid] == elm) return mid;
+		if(arr[mid] <= arr[end]){
+			start = (elm >= arr[mid] && elm <= arr[end])?mid+1:start;
+			end = (elm >= arr[mid] && elm <= arr[end])?end:mid-1;
+		}else{
+			end = (elm >= arr[start] && elm <=arr[mid])?mid-1:end;
+			start = (elm >= arr[start] && elm <=arr[mid])?start:mid+1;
+		}
+	}
+	return -1;
 }
 
 int main(){
@@ -56,7 +71,7 @@ int main(){
 	while(1){
 		printf("enter the element to be searched\n");
 		scanf("%d",&elm);
-		int index = search(arr,0,size-1,elm);
+		int index = searchIterative(arr,0,size-1,elm);
 		if(index < 0){
 			printf("element does not exist\n");
 		}else{

divide-and-conquer/question4.c

@@ -0,0 +1,80 @@
+/*
+Count inversions in an array
+
+Eg: inversion means if an array is in increasing order and there is  a number somewhere towards the right
+of which there are 3 numbers lesser than that (rather than greater than that), then it equals 3 inversions.
+Like this we need to check for each element
+Eg: 7 5 1 3 4 6 has 8 inversions 
+
+METHOD1:
+Search for each element by comparing elements towards its right
+Time complexity: O(n^2)
+Space complexity: O(1)
+
+METHOD2:
+By divide and conquer
+We take the middle element and divide the array into two parts start to mid and mid+1 to end. Keep doing
+this till the end until we have 1 element each in the leaf. Now we will compare components one by one and
+merge as we did in the merge sort. Also we will increment the number of inversion if the elm in the left
+component is greater than element in right component. Merging will be done in the sorted order.
+Like this we merge all the components. Since elements are sorted while merging if first element of a component
+is greater than first element of second component then it will result in inversions equal to the number of 
+elements present in the first component as they are sorted and all will be greater then the first element of
+second component.
+Time complexity T(n)= 2T(n/2)+O(n) = O(nlogn) //same as merge sort, just that merge procedure is a bit modified
+Space complexity: O(logn)//size of recursion stack
+*/
+
+//merge sort implementation
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+void merge(int *arr, int start, int mid,int end){
+	int n1 = mid-start+1; //includes mid
+	int n2 = end-mid;
+	int left[n1+1],right[n2+1];
+	int i,j;
+	for(i=0;i<n1;i++){
+		left[i]=arr[i+start];
+	}
+	left[n1] = INT_MAX;
+	for(j=0;j<n2;j++){
+		right[j] = arr[j+mid+1];
+	}
+	right[n2] = INT_MAX;
+
+	int k;
+	i=0;j=0;
+	for(k=start;k<=end;k++){
+		if(left[i] <= right[j]){
+			arr[k] = left[i];	
+			i++;
+		}else{
+			arr[k] = right[j];
+			j++;
+		}
+	}	
+}
+
+void mergeSort(int *arr, int start, int end){
+	if(start < end){
+		int mid = (start + end)/2;
+		mergeSort(arr,start,mid);
+		mergeSort(arr,mid+1,end);
+		merge(arr,start,mid,end);	
+	}
+}
+
+int main(){
+	int arr[] = {7,5,1,3,4,6};
+	int size = sizeof(arr)/sizeof(arr[0]);
+	
+	mergeSort(arr,0,size-1);
+
+	for(int i=0;i<size;i++){
+		printf("%d\n", arr[i]);
+	}
+
+	return 0;
+}

divide-and-conquer/question5.c

@@ -0,0 +1,76 @@
+/*
+Find the missing number in arithmetic progression
+
+METHOD1:
+we need to find the common difference first. For that a reliable approach is, we have the size of array
+and the last term available to us and the first term also is there. Therefore by applying
+a+(n-1)d we can find the cd.
+Once we have cd, we can simply do a linear search by increment with cd and see which element is missing
+Time complexity: O(n) //finding cd is a constant time operation.
+Space complexity: O(1)
+
+METHOD2:
+We find the cd as stated in the above method. Now, we apply binary search. We find the middle element. its
+index is known. BY a+(n-1)d we see whether middle element is equal to what it should be or not. If equal
+search in the right array else search in the left array. Keep doing this. At one point if left array if 
+no longer there then middle element index is the culprit.
+Time complexity: O(logn)
+Space complexity :O(1) or O(logn) //iterative or recursive
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+struct node{
+	int index;
+	int elm;
+};
+
+struct node *newNode(int index, int elm){
+	struct node *temp = (struct node *)malloc(sizeof(struct node));
+	temp->index = index;
+	temp->elm = elm;
+	return temp;
+}
+
+struct node *searchMissing(int *arr, int start, int end, int cd){
+	if(start > end){
+		return NULL;
+	}
+	int mid = (start + end)/2;
+	int tmid = arr[0] + mid*cd;
+	struct node *temp = NULL;
+	if(mid>0 && arr[mid]-arr[mid-1] != cd){ //checking to the left and right of
+		temp = newNode(mid, arr[mid-1]+cd);
+		return temp;
+	}
+	if(arr[mid+1]-arr[mid] != cd){
+		temp = newNode(mid+1,arr[mid]+cd);
+		return temp;
+	}
+	struct node *left = NULL; struct node *right= NULL;
+	if(arr[mid] == tmid){
+		return searchMissing(arr,mid+1,end,cd);
+	}
+	return searchMissing(arr,start,mid-1,cd);
+}
+
+int findDifference(int *arr, int size){
+	int temp = (arr[size-1]-arr[0])/(size-1);
+}
+
+int main(){
+	int arr[] = {-2,0,4,6,8,10,12,14,16,18,20};
+	int size = sizeof(arr)/sizeof(arr[0]);
+
+	int cd = findDifference(arr,size);
+	
+	struct node *missing = searchMissing(arr,0,size-1,cd);
+	if(missing){
+		printf("missing element is %d should be at index %d\n", missing->elm,missing->index);
+	}else{
+		printf("no element is missing");
+	}
+	return 0;
+}
+

divide-and-conquer/question6.c

@@ -68,4 +68,4 @@ TODO:
 - greedy question12 implementation
 - divide and conquer question1, method3 to be done
 - divide and conquer quick sort way for question2 not able to understand
-- better way to implement a pow function
+- divide and conquer question5 to be done