new question added

Author: arorarahul

README.md

@@ -36,6 +36,7 @@ which has to be returned
 - To make games like snakes & ladders, we can use a linked list with a random pointer, next pointer and data.
 Whenever there is a ladder or snake, the random pointer will point there else it will be NULL.
 - Consider making additional connections (links to the new list or old list) for traversing or reference point of view when there are multiple things involved (random node eg:). New node sometimes can be added in the middle of the two nodes to maintain a connection and so on.
+- In program involving partition or merging always take mid as start+end/2 and not subtraction because this will always give the correct value. Subtraction may not give the correct value as you keep breaking the array into smaller parts
 
 ### For Hashing: (methods that can be applied)
 -  When solving questions divide value with the size of the hashTable. Keep the size of the hash table one
@@ -131,7 +132,7 @@ max edge or path to be traversed to minimize work.
 - In repeating elements with fixed size and ordered array we can use binary search. Also linear search can be
 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.
 
 # Topic0: Programming Questions
 
@@ -315,6 +316,9 @@ i+given number of times to see if thats true or not.
 ### Divide and conquer
 
 - [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)
+
 
 ## Some important concepts to solve algos better
 

arrays/a.exe

@@ -5,7 +5,54 @@ Program to implement binary search in an array
 #include <stdio.h>
 #include <stdlib.h>
 
+int findElmIterative(int *arr, int start, int end, int elm){
+	while(start < end){
+		int mid = (start+end)/2;
+		if(arr[mid] > elm){
+			end = mid - 1;
+		}else if(arr[mid] < elm){
+			start = mid + 1;
+		}else{
+			return mid;
+		}	
+	}
+	return -1;
+}
+
+int findElmRecursive(int *arr, int start, int end, int elm){
+	if(start >= end){
+		return -1;
+	}
+	int mid = (start + end)/2;
+	if(arr[mid] > elm){
+		return findElmRecursive(arr,start,mid-1,elm);
+	}
+	if(arr[mid] < elm){
+		return findElmRecursive(arr,mid+1,end,elm);
+	}
+	return mid;
+}
+
 int main(){
-	int arr[] = {};
+	int arr[] = {2,5,8,12,16,23,38,56,72,91};
+	int size = sizeof(arr)/sizeof(arr[0]);
+	int elm = 23;
+	int step;
+	printf("1. Do Iteration\n");
+	printf("2. Do Recursion\n");
+	scanf("%d",&step);
+	int index;
+	switch(step){
+		case 1: index = findElmIterative(arr,0, size-1, elm);
+			break;
+		case 2: index = findElmRecursive(arr,0,size-1,elm);
+			break;
+	}
+	if(index < 0){
+		printf("no such element is present\n");
+	}else{
+		printf("element is present at index %d\n", index);	
+	}
+	
 	return 0;
 }

arrays/question29.c

@@ -14,8 +14,17 @@ Time complexity: O(n) //but overall time will be lesser still we are scanning ti
 Space complexity: O(1)
 
 METHOD3:
-
-
+We will do a binary search. The thing to note is that the element that is repeating the majority number
+of times n/2, will alway touch the middle part of the array No matter where it starts or end.
+Therefore, if we start from the middle and try to see if the left element ot the middle is equal
+to that element, if yes, then we search in the left array and repeat this exercise, otherwise we assume
+that the middle element is the starting element.
+Once we have the starting element we can just go to index +n/2 to see if the end index is that to finalize
+that the element is repeating n/2 times, otherwise elm is not repeating that many times. If the question says
+that find how many times is the element repeating given it is repeating more than n/2 times, then it will
+definately touch the middle, then we find its end index also using binary search as we did for start index
+Time complexity: O(logn)
+Space complexity: O(logn) //if recursive else O(1) if iterative
 
 */
 //METHOD1
@@ -82,25 +91,18 @@ Space complexity: O(1)
 #include <stdio.h>
 #include <stdlib.h>
 
-int findElm(int *arr, int size){
-	int i=0;
-	while(i<=size/2){
-		if(arr[i] == arr[i+size/2]){
-			return arr[i];
-		}
-		i++;
-	}
-	return -1;
+int findElm(int *arr, int start, int end,int size){
+	
 }
 
 int main(){
-	int arr[] = {1,2,3,4,4,4,4};
+	int arr[] = {1,2,2,2,2,3,4};
 	int size = sizeof(arr)/sizeof(arr[0]);
-	int elm = findElm(arr,size);
-	if(elm < 0){
+	int index = findElm(arr,0,size-1, size);
+	if(index < 0){
 		printf("element is not present\n");
 	}else{
-		printf("element is %d\n", elm);	
+		printf("element is %d\n", arr[index]);	
 	}
 
 	return 0;

code/test1.c

@@ -0,0 +1,12 @@
+/*
+Given two array with nuts and bolts each, and given that each nut only maps to a single bolt and vice
+versa, find each pair
+
+METHOD:
+sort and then compare
+Time complexity: O(nlogn)
+
+METHOD:
+quick sort way??
+http://www.geeksforgeeks.org/nuts-bolts-problem-lock-key-problem/
+*/

code/test2.c

@@ -0,0 +1,66 @@
+/*
+Custom C function to implement a pow function
+*/
+
+/*
+The function is buggy because it can overflow, cannot work for negative value of power. Also it cannot work
+for decimals. It is also slow because it is doing a particular multiplications so many times.
+It also does not handle fractional power
+*/
+
+// #include <stdio.h>
+// #include <stdlib.h>
+
+// int customPow(int base, int power){
+// 	int i;
+// 	int temp = 1;
+// 	for(i=0;i<power;i++){
+// 		temp *= base;
+// 	}
+// 	return temp;
+// }	
+
+// int main(){
+// 	printf("value is %d\n", customPow(10,4));
+// 	return 0;
+// }
+
+/*
+Here is a better function that runs faster and handle all the cases
+In this case each time exp value is converted to half and base value is doubled
+*/
+#include <stdio.h>
+#include <stdlib.h>
+
+//iterative
+int ipow(int base, int exp){
+	int result = 1;
+	while(exp){
+		if(exp & 1){ //will return 0 if number is even and will return 1 if number if odd
+			//therefore odd value is taken out of the bracket and remaning operations are done on
+			//even value
+			result *= base;
+		}
+		exp >>= 1; //used to convert exp value to half
+		base *= base;
+	}
+	return result;
+}
+
+//recursive
+int ipowRecursive(int base, int exp){
+	if(exp == 0){
+		return 1;
+	}
+	int result = ipowRecursive(base,exp/2);
+	if(exp & 1){
+		return result*result*base;
+	}
+	return result*result;
+}
+
+int main(){
+	// int a = 50;
+	printf("value is %d\n", ipowRecursive(10,4));
+	return 0;
+}