new question added

Author: arorarahul

README.md

@@ -133,6 +133,7 @@ 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.
 
 # Topic0: Programming Questions
 
@@ -318,6 +319,7 @@ i+given number of times to see if thats true or not.
 - [Find a majority element using linear search that occurs more than n/2 times](/divide-and-conquer/question1.c)
 - [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)
 
 
 ## Some important concepts to solve algos better

divide-and-conquer/a.exe

@@ -0,0 +1,68 @@
+/*
+Select an element in sorted rotated array
+
+sorted rotated array means, the array was sorted and then some elements were picked and rotated.
+eg: 1 2 3 4 5 6 7 8 9 10 became
+7 8 9 10 1 2 3 4 5 6
+
+and we need to search for some element in this array.
+
+Linear search can be done. But binary search can also be applied as given below.
+
+METHOD1:
+First using binary search we need to find the place where max element is placed. (given the rotation order)
+assume in the question and max number as well. Therefore we need to locate 10 as per the above eg.
+Now we start from middle element and see left bound which is 7 and right bound which is 6. Now middle
+element being 2 it is clear that the sequence is increasing from middle to right, hence 10 cannot be there.
+Now if we see towards left, there is a higher number instead of lesser. Therefore we need to search the left
+array. Therefore, again we will apply the same method on the left array. Now once 10 is located. We will have
+two different increasing components with uppper and lower bounds, and we will clearly know where to search any
+element using binary search again.
+
+Time complexity: O(2logn) =  O(logn) //twice binary search will be applied 
+Space complexity: O(logn) or O(1) //recursive or iterative
+
+METHOD2:
+Using binary search only but there is no need to divide the array into two components.
+Therefore there will be a single array (in the question it will be mentioned whether its a increasing sequence
+or not). Therefore from the middle element, one side has to be sorted and the other will not be sorted 
+no matter at whatstage in the recursion we are. Always from the middle element, one side will be in the right 
+order and one will be increasing to a point and then decreasing. Therefore we can find the range of middle
+to right if it falls in that it exists there otherwise it exists in the other part. It can be done for 
+all the sub problems.
+
+Time complexity: O(logn) //binary search
+Space complexity: O(1) or O(logn) //iterative or recursive
+*/
+//METHOD2
+#include <stdio.h>
+#include <stdlib.h>
+
+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);
+}
+
+int main(){
+	int arr[] = {8,9,10,1,2,3,4,5,6,7};
+	int size = sizeof(arr)/sizeof(arr[0]);
+	int elm;
+	while(1){
+		printf("enter the element to be searched\n");
+		scanf("%d",&elm);
+		int index = search(arr,0,size-1,elm);
+		if(index < 0){
+			printf("element does not exist\n");
+		}else{
+			printf("element exists at %d\n", index);
+		}
+	}
+
+	return 0;
+}