new question added

Author: arorarahul

README.md

@@ -2,7 +2,8 @@
 
 ### For Arrays: (methods that can be applied)
 
-- sorting and then doing something, hashtable, two pointers in a loop are some of the operations that are popular to solve algos
+- sorting and then doing something, hashtable, two pointers in a loop are some of the operations that are popular to solve algos.
+Hash table can also be made for storing sum etc.
 - to find all combinations use nested for loops (worst algos)
 - another way is to stop at an element and traverse all its previous elements
 - fixing one number and having two pointers one at start and one at end to make some operation
@@ -13,13 +14,17 @@ only if there is one number that repeats odd number of times
 - If element in an array is to be found, and length is known apply binary search. Will complete the search in O(logn) times. If binary search cant be applied look in sizes of k at a time to limit the search set.
 - We cannot find time complexity of something whose input size is unknown.
 
+# General hash functions
+- take mod with number of elements present
+
 #Topic0: Programming Questions
 
 TODO: 
 - question14.c (general), 
 - question17.c (arrays), to be done after trees and linkedlist is done
 - question18.c (arrays), to be done after linkedlist is done 
 - question19.c (arrays): to be done after trees is done
+- question20.c (arrays): to be done after hashing (approach 2 and 3)
 
 ## Note:
 **Questions statements are included in the file itself**
@@ -79,10 +84,11 @@ TODO:
 - [Given an array A, find two elements whose sum is closest to zero](/arrays/question14.c) 
 - [Find the triplet in given array that sum to given value 'x'](/arrays/question15.c)
 - [Find the equilibrium index of an array](/arrays/question16.c)
-- [In an array of unknown size having all 0s at one side and all 1s at other, find the index where 1st 1 exists.](/arrays/question17.c) - STILL TO BE DONE
+- [In an array of unknown size having all 0s at one side and all 1s at other, find the index where 1st 1 exists.](/arrays/question17.c)
 - [Given an array and an integer K, find max element for each and every contiguous subarray of size k](/arrays/question18.c)
 - [Count number of smaller elements on the right of each element in an array](/arrays/question19.c)
 - [Find the subarray with the given sum](/arrays/question20.c) 
+- [Consider and array which contains only 0's and 1's. Find largest sub array which contains only 0's and 1's](/arrays/question21.c) 
 
 ## Some important concepts to solve algos better
 

arrays/question19.c

@@ -13,23 +13,23 @@ Time complexity: O(n^2)
 Time complexity: O(1)
 */
 
-// //METHOD1
-// #include <stdio.h>
-// int main(){
-// 	int a[] = {10,3,4,5,7,1,3,2};
-// 	int length = sizeof(a)/sizeof(a[0]);
-// 	int elm1, counter;
-// 	for(int i=0; i<length; i++){
-// 		elm1 = a[i];
-// 		counter = 0;
-// 		for(int j=i+1;j<length;j++){
-// 			if(elm1 > a[j]){
-// 				counter++;
-// 			}
-// 		}
-// 		printf("%d ", counter);
-// 	}
-// }
+//METHOD1
+#include <stdio.h>
+int main(){
+	int a[] = {10,3,4,5,7,1,3,2};
+	int length = sizeof(a)/sizeof(a[0]);
+	int elm1, counter;
+	for(int i=0; i<length; i++){
+		elm1 = a[i];
+		counter = 0;
+		for(int j=i+1;j<length;j++){
+			if(elm1 > a[j]){
+				counter++;
+			}
+		}
+		printf("%d ", counter);
+	}
+}
 
 //METHOD2
 #include <stdio.h>

arrays/question20.c

@@ -1,5 +1,96 @@
 /*
 Find the subarray with the given sum
 
+SUBARRAY: part of the array which is contiguous and satisfied the given condition
+
+METHOD1
+Take all possible combos
+Time complexity: O(n^2)
+Space complexity: O(1)
+
+METHOD2 (only for positive numbers)
+Taking two pointers and scanning. Moving start index if sum is more, more end index if sum is less
+Array in worst case will be traversed twice
+Time complexity: O(n)
+Space complexity: O(1)
+
+METHOD3(for both negative and positive)
+Maintaining a hash for sum so far and subtracting given sum each time to see if the result is present in the hash table
+If present that means sub array exists which if subtracted can give a subarray which has the req sum
+Time complexity: O(n)
+Space complexity: O(n)
 
 */
+
+//METHOD1
+#include <stdio.h>
+#include <stdlib.h>
+
+void printSubArray(int *arr,int start, int end){
+	for(int i=start; i<=end;i++){
+		printf("%d", arr[i]);
+	}
+}
+
+int main(){
+	int a[] = {5,4,6,7,9,8,3,1,2};
+	int length = sizeof(a)/sizeof(a[0]);
+	int start, end, sum;
+	for(int i=0; i<length; i++){
+		sum = 0;
+		start = a[i];
+		sum += start;
+		for(int j=i+1; j<length; j++){
+			end = a[j];
+			sum += end;
+			if(sum == 21){
+				printSubArray(a,i,j);
+			}
+		}
+	}
+}
+
+//METHOD2
+#include <stdio.h>
+#include <stdlib.h>
+
+void printSubArray(int *arr,int start, int end){
+	for(int i=start; i<=end;i++){
+		printf("%d", arr[i]);
+	}
+}
+
+int main(){
+	int a[] = {5,4,6,7,9,8,3,1,2};
+	int length = sizeof(a)/sizeof(a[0]);
+	int reqSum = 27;
+	int leftIndex = 0, rightIndex = 0, sum=0;
+
+	if(a[leftIndex] == reqSum){
+		printf("%d\n", a[leftIndex]);
+		return 1;
+	}else{
+		rightIndex++;
+		sum = a[leftIndex] + a[rightIndex];	
+	}
+	
+	while(rightIndex<=length){
+
+		if(sum == reqSum){
+			printSubArray(a, leftIndex, rightIndex);
+			break;
+		}
+		if(sum < reqSum){
+			rightIndex++;
+			sum += a[rightIndex];
+		}else{
+			int temp = leftIndex;
+			leftIndex++;
+			sum = sum - a[temp];
+		}
+	}
+	if(sum != reqSum){
+		printf("sub array could not be found with sum given\n");
+	}
+
+}

arrays/question21.c

@@ -0,0 +1,10 @@
+/*
+Consider and array which contains only 0's and 1's. Find largest sub array which contains only 0's and 1's
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(){
+	
+}