new question added

Author: arorarahul

README.md

@@ -133,9 +133,15 @@ max edge or path to be traversed to minimize work.
 used where if an element should be repeating a given number of times, you can check its value at i and then
 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.
+- 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. Also to break the recursion to return result successful condition will be a unique property trait at that index as per algo. Find that trait.
 - 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.
+- 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. Eg: crux of algo if is swapping we do swapping, if comparing we do comparing, if it is applying some formula, we do that.
+- To write the iterative version of a recursive version follow the steps below
+      - Replace the recursion break condition with the while loop which will run
+      - Apply the same conditions and update the value of the variables in that condition. These variables will be a part of the while loop also. Rather than calling the function with updated values, just update the values of the variables and while loop will handle the rest
+      - Make sure to assign both the variable values that are passed into the function in recursion while doing it in while loop as iteration
+      - The false condition (if any false value is to be returned for validation) will come after the end of while loop
+- To write recursive from iterative, replace while loop condition and its opposite should be break condition of recursion and reverse the sub steps
 
 # Topic0: Programming Questions
 
@@ -324,6 +330,11 @@ i+given number of times to see if thats true or not.
 - [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)
+- [Given an array containing 1's and 0's in which all 0's appear before all 1's, count the number of 1's in the array](/divide-and-conquer/question7.c)
+- [Given an array with 2n integer in the formal a1,a2,a3...b1,b2,b3.. Shuffle the array to a1b1 a2b2 a3b3 ...](/divide-and-conquer/question8.c)
+- [Given a sorted array of non repeated integers a[1--n]. Check whether there is an index i for which a[i]=i](/divide-and-conquer/question9.c)
+- [Find the maximum element index in an array which is first increasing and then decreasing](/divide-and-conquer/question10.c)
+- [Search an element in row wise and column wise sorted 2d array](/divide-and-conquer/question11.c)
 
 ## Some important concepts to solve algos better
 

divide-and-conquer/a.exe

@@ -0,0 +1,47 @@
+/*
+Find the maximum element index in an array which is first increasing and then decreasing
+
+It means that there is an increasing sequence till i and then after that i+1 to n is a decreasing
+sequence. We need to find the value of i
+
+METHOD1:
+Linear search
+Time complexity: O(n)
+Space complexity: O(1)
+
+METHOD2:
+Binary search. 
+Here we find middle and if the element at the middle lies in the increasing sequence 
+search the right array else search the left array. Also for successful condition we see the the middle
+element has its immediate right and left lesser than it, then that is the required number.
+Time complexity: O(logn) //because T(n/2) + O(1)
+Space complexity: O(1) or O(logn) //iterative or recursive
+*/
+#include <stdio.h>
+#include <stdlib.h>
+
+int findIndex(int *arr,int start, int end){
+	if(start > end){
+		return -1;
+	}
+	int mid = (start+end)/2;
+	if(arr[mid] > arr[mid-1] && arr[mid] > arr[mid+1]){
+		return mid;
+	}
+	if(arr[mid] < arr[mid+1] && arr[mid] > arr[mid-1]){
+		return findIndex(arr,mid+1,end); //increasing sequence search the right one
+	}
+	return findIndex(arr,start,mid-1);
+}
+
+int main(){
+	int arr[] = {1,2,3,4,5,6,5,4,3,2,1};
+	int size = sizeof(arr)/sizeof(arr[0]);
+	int index = findIndex(arr,0,size-1);
+	if(index < 0){
+		printf("no such element exists\n");
+	}else{
+		printf("index with peak is %d\n", index);
+	}
+	return 0;
+}

divide-and-conquer/question10.c

@@ -0,0 +1,43 @@
+/*
+Search an element in row wise and column wise sorted 2d array
+
+METHOD1:
+Naive approach, searching for an element using for loops
+Time complexity: O(n^2)
+Space complexity: O(1)
+
+METHOD2:
+In this case it can be done in linear time. Since arrays is in sorted order top to bottom and left
+to right. We can start from top right. We can maintain two variable. i will traverse rows and j will
+traverse columns. Initial value of i will be zero and j will be n-1. Now if value to be found is
+lesser than top right decrease j to move towards lesser elements. If its greater increase i.
+Follow this and it will end up at the element required.
+Time complexity: O(m+n) or O(2n) if both n and m are equal
+Space complexity: O(1)
+
+METHOD3:
+Binary search. Now since array is sorted row and column wise, we find the middle of the whole
+2d array. If the element to be found is less than this middle element then it is definately not
+present in the fourth quadrant (if the 2d array is divided into 4 parts).
+If element to be found is greater than x, then it definately cannot be a part of first quadrant.
+Therefore we can narrow our search down to only 3 quadrants each time
+Time complexity: T(k) = 3T(k/4) + O(1) //we search thirce in 3 quadrants. each quadrant has 1/4 
+elements of total elements k. O(1) is the comparison which is done with the middle element.
+By masters theorem and substituting k as n^2 we get n^1.5 as time complexity
+Space complexity: O(1) //iterative
+*/ 
+//METHOD2
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(){
+	int arr[4][4] = {
+		{0,1,2,3},
+		{4,5,6,7},
+		{8,9,10,11},
+		{12,13,14,15}
+	};
+	int size = sizeof(arr)/sizeof(arr[0]);
+	
+	return 0;
+}

divide-and-conquer/question11.c

@@ -48,13 +48,35 @@ struct node *searchMissing(int *arr, int start, int end, int 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);
 }
 
+struct node *searchMissingIterative(int *arr, int start, int end, int cd){
+	struct node *temp = NULL;
+	while(start <= end){
+		int mid = (start + end)/2;
+		int tmid = arr[0] + mid*cd;
+		if(mid > 0 && arr[mid] - arr[mid-1] != cd){
+			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;
+		}
+		if(arr[mid] == tmid){
+			start = mid + 1;
+			end = end;
+		}else{
+			start = start;
+			end = mid-1;
+		}
+	}
+}
+
 int findDifference(int *arr, int size){
 	int temp = (arr[size-1]-arr[0])/(size-1);
 }
@@ -65,7 +87,7 @@ int main(){
 
 	int cd = findDifference(arr,size);
 
-	struct node *missing = searchMissing(arr,0,size-1,cd);
+	struct node *missing = searchMissingIterative(arr,0,size-1,cd);
 	if(missing){
 		printf("missing element is %d should be at index %d\n", missing->elm,missing->index);
 	}else{

divide-and-conquer/question6.c

@@ -0,0 +1,58 @@
+/*
+Given an array containing 1's and 0's in which all 0's appear before all 1's, count the number of 1's in 
+the array
+
+METHOD1:
+linear search and sum
+Time complexity: O(n)
+Space complexity: O(1)
+
+METHOD2:
+Binary search to find where 1 starts
+Time complexity: O(logn)
+Space complexity: o(1)  or O(logn) //iterative or recursive
+*/
+#include <stdio.h>
+#include <stdlib.h>
+
+int countOnes(int *arr, int start, int end,int size){
+	if(start > end){
+		return -1;
+	}
+	int mid = (start + end)/2;
+	if(arr[mid] && !arr[mid-1]){
+		return (size-mid);
+	}
+	if(arr[mid] && arr[mid-1]){
+		return countOnes(arr,start,mid-1, size);
+	}
+	return countOnes(arr,mid+1,end,size);
+}
+
+int countOnesIterative(int *arr, int start, int end, int size){
+	while(start <= end){
+		int mid = (start + end)/2;
+		if(arr[mid] && !arr[mid-1]){
+			return (size-mid);
+		}
+		if(arr[mid] && arr[mid-1]){
+			start = start;
+			end = mid-1;
+		}else{
+			start = mid + 1;
+			end = end;
+		}
+	}
+}
+
+int main(){
+	int arr[] = {0,0,0,0,1,1,1,1,1};
+	int size = sizeof(arr)/sizeof(arr[0]);
+	int count = countOnesIterative(arr,0,size-1, size);
+	if(count < 0){
+		printf("there are no 1s in the array\n");
+	}else{
+		printf("number of 1s are %d\n", count);
+	}
+	return 0;
+}

divide-and-conquer/question7.c

@@ -0,0 +1,75 @@
+/*
+Given an array with 2n integer in the formal a1,a2,a3...b1,b2,b3.. 
+Shuffle the array to a1b1 a2b2 a3b3 ...
+
+Lets say the array is 1 2 3 4 | 5 6 7 8
+outout should be 15 26 37 48
+
+METHOD1:
+Simply maintain two pointers, one at start and one at mid+1, and make a new array of equal size
+and write to that array these values one by one and increment them.
+Time complexity: O(n)
+Space complexity: O(n)
+
+METHOD2:
+Using binary search. Here we break the solutions into two parts and take the second half of the
+first part and first half of the second part and swap them. Then we divide the left and right halves
+again into two parts, and repeat the above steps till our size goes to 2 we keep doing that.
+One it is 2 we will have the desired solution.
+Time complexity: O(nlogn) //same as merge sort because at each step work done will be equal to
+dividing the array into two parts T(n/2) + swapping O(n)
+Space complexity: O(logn) //height of the binary tree formed, which will be the space occupied by
+the stack
+*/
+//METHOD1 is too simple
+//METHOD2
+#include <stdio.h>
+#include <stdlib.h>
+
+void swap(int *a, int *b){
+	int temp = *a;
+	*a = *b;
+	*b = temp;
+}
+
+void combineArrays(int *arr, int start, int end, int size){
+	if(end-start+1 <= 2){
+		return;
+	}
+	int mid = (start + end)/2;
+	int i=(start+mid+1)/2,j=mid+1;
+	while(i<=mid && j<=(mid+end)/2){
+		swap(&arr[i],&arr[j]);
+		for(int i=0; i<size;i++){
+			printf("%d\t", arr[i]);
+		}
+		i++;j++;
+	}
+	combineArrays(arr,start,mid, size);
+	combineArrays(arr,mid+1,end, size);
+}
+
+// void combineArraysIterative(int *arr, int start, int end, int size){
+// 	while(end-start+1>2){
+// 		int mid = (start+end)/2;
+// 		int i=(start+mid+1)/2,j=mid+1;
+// 		while(i<=mid && j<=(mid+end)/2){
+// 			printf("swapping %d and %d\n", arr[i], arr[j]);
+// 			swap(&arr[i],&arr[j]);
+// 			i++;j++;
+// 		}
+// 		start = start;
+// 		end=mid;
+// 	}
+// }
+
+int main(){
+	int arr[] = {1,2,3,4,5,6,7,8};
+	int size = sizeof(arr)/sizeof(arr[0]);
+	combineArraysIterative(arr,0,size-1,size);
+
+	for(int i=0; i<size;i++){
+		printf("%d\n", arr[i]);
+	}	
+	return 0;
+}

divide-and-conquer/question8.c

@@ -0,0 +1,65 @@
+/*
+Given a sorted array of non repeated integers a[1--n].
+Check whether there is an index i for which a[i]=i
+
+METHOD1:
+Linear search
+Time complexity: O(n)
+Space complexity: O(1)
+
+METHOD2:
+Ideally this question is not valid, if the numbers are starting from 1 and indexes are starting
+from zero, there cannot exist a case where a[i]=i because numbers cannot repeat also and they
+will atleast have to increase by one as they are sorted.
+
+Just in case an example of repitition is taken, the way to solve the problem is using binary search
+We take the middle element and see if its value is greater than index, if yes then we search on left
+because it cannot exist in right as value atleast will increase by 1 each time and so does the index.
+So it can never catchup. In case value is lesser then index we will search right because value
+can atleast increase by one and can catch up.
+Time complexity: o(logn)
+Space complexity: O(logn) or O(1) //recursive or iterative
+*/
+#include <stdio.h>
+#include <stdlib.h>
+
+int checkIndex(int *arr, int start, int end){
+	if(start > end){
+		return -1;
+	}
+	int mid = (start+end)/2;
+	if(arr[mid]==mid){
+		return mid;
+	}
+	if(arr[mid] > mid){
+		return checkIndex(arr,start,mid-1);
+	}
+	return checkIndex(arr,mid+1,end);
+}
+
+int checkIndexIterative(int *arr, int start, int end){
+	while(start <= end){
+		int mid = (start+end)/2;
+		if(arr[mid] == mid){
+			return mid;
+		}
+		if(arr[mid]>mid){
+			end = mid-1;
+		}else{
+			start = mid+1;
+		}
+	}
+	return -1;
+}
+
+int main(){
+	int arr[] = {0,0,1,2,2,3,4,7,8};
+	int size = sizeof(arr)/sizeof(arr[0]);
+	int index = checkIndexIterative(arr,0,size-1);
+	if(index < 0){
+		printf("such an element does not exist\n");
+	}else{
+		printf("index at which such element exists is %d\n", index);
+	}
+	return 0;
+}

divide-and-conquer/question9.c

@@ -68,4 +68,6 @@ TODO:
 - greedy question12 implementation
 - divide and conquer question1, method3 to be done
 - divide and conquer quick sort way for question2 not able to understand
-- divide and conquer question5 to be done
+- divide and conquer question5 to be done
+- make the iterative version for question8
+- last question of divide and conquer to be done (2d array)