new miscellaneous questions added

Author: arorarahul

Diff for: README.md

@@ -259,6 +259,7 @@ use KMP
 - [question22.c](/general/question22.c)
 - [question23.c](/general/question23.c)
 - [question24.c](/general/question24.c)
+- [Find GCD and LCM of two numbers](/general/question25.c)
 
 ### Arrays
 
@@ -448,7 +449,7 @@ use KMP
 - [Longest non-overlapping repeating sub string](/dynamic-programming/question23.c)
 - [Given two strings X and Y, find the minimum cost to make two strings equal using only delete operations. Cost to delete character in X is S and in Y is P](/dynamic-programming/question24.c)
 - [Count the number of times string occured as the subsequence of the other string](/dynamic-programming/question25.c)
-- [Given an amount and some coints, find out in how many ways can this amount be formed](/dynamic-programming/question26.c)
+- [Given an amount and some coins, find out in how many ways can this amount be formed](/dynamic-programming/question26.c)
 - [Given a 2xn board and tiles of size 2x1, count the number of ways to fill the board using 2x1 tiles](/dynamic-programming/question27.c)
 - [Given a cost matrix mxn having a cost at each cell. Find the min cost that it will take to reach cell (m-1,n-1) from top left corner cell (0,0) if the only allowed directions to move are right, down and diagnal down](/dynamic-programming/question28.c)
 - [Given a string, find out if it becomes a palindrome or not after doing atmost k deletions](/dynamic-programming/question29.c)
@@ -468,7 +469,10 @@ use KMP
 - [Given a 2D boolean matrix, find the number of islands](/graphs/question6.c)
 - [Check whether a given graph is biparite or not](/graphs/question7.c)
 - [Detect a cycle in a directed graph](/graphs/question8.c)
-
+- [Kosaraju algorithm to find SCCs](/graphs/question9.c)
+- [Find if the given directed graph is eulerian](/graphs/question10.c)
+- [Find if the given undirected graph is eulerian](/graphs/question11.c)
+- [Dijkstra algorithm](/graphs/question12.c)
 
 ### Pattern Matching
 
@@ -488,6 +492,11 @@ use KMP
 - [Test whether given two strings are isomorphic or not](/misc/question1.c)
 - [Find the length of the longest suffix which is also a prefix](/misc/question2.c)
 
+### Bit Manipulation
+
+- [Find set bits in an integer](/bit-manipulation/question1.c)
+- [Find if a number is a power of 2](/bit-manipulation/question2.c)
+
 ## Some important concepts to solve algos better
 
 - For extreme values refer to limits.h constants given by C
@@ -580,6 +589,7 @@ Even if there are repetitions, they are going to be same.
 if they dont have edge it is infinity.
 - Travelling salesman problem time complexity O(n^2 ^ 2^n)
 - Ugly number is a one which can be written as a product of 2,3 or 5 or a combination of these numbers. 1 is also considered as ugly number as it is an exception.
+- Whenever highest or lowest power of two is to be found, use log operations
 
 
 # C Programming - Topic1: Introduction

Diff for: back-tracking/question3.c

@@ -58,6 +58,8 @@ void init(int n, int arr[n][n]){
 	}
 }
 
+
+
 int main(){
 	int n;
 	printf("enter the value of n\n");
@@ -67,7 +69,7 @@ int main(){
 
 	init(n,arr);
 
-	findNQueen()
+	findNQueen(n, arr);
 
 	return 0;
 }

Diff for: bit-manipulation/question1.c

@@ -0,0 +1,42 @@
+/*
+Count the number of set bits in an integer
+
+If number is given, simply divide it by 2 in a loop and incremenet count if rem is 1
+TC: logn
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int setBits(int num){
+	int rem;
+	
+	int count = 0;
+	while(num){
+
+
+		rem = num%2;
+		if(rem){
+			count++;
+		}
+	
+		num = num/2;
+		
+
+
+	}
+	
+	return count;
+}
+
+
+int main(){
+
+	int n;
+	printf("enter the number\n");
+	scanf("%d",&n);
+
+	printf("num set bits are: %d\n", setBits(n));
+
+}

Diff for: bit-manipulation/question2.c

@@ -0,0 +1,32 @@
+/*
+find if a number if power of 2
+
+If we subtract a power of 2 numbers by 1 then all unset bits after the only set bit become set; 
+and the set bit become unset.
+
+So, if a number n is a power of 2 then bitwise & of n and n-1 will be zero. 
+We can say n is a power of 2 or not based on value of n&(n-1). 
+The expression n&(n-1) will not work when n is 0. 
+To handle this case also, our expression will become n && (!n&(n-1))
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int isPowerOfTwo(int n){
+	return n && !(n & (n-1));
+}
+
+int main(){
+	int n;
+	printf("enter the number\n");
+	scanf("%d",&n);
+
+	if(isPowerOfTwo(n)){
+		printf("number is pwr\n");
+	}else{
+		printf("no.\n");
+	}
+	return 0;
+}
+

Diff for: complex-datastructures/making-a-graph.c

@@ -0,0 +1,76 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+struct adjListNode{
+	int data;
+	struct adjListNode *next;
+};	
+
+struct adjList{
+	struct adjListNode *head;
+};
+
+struct graph{
+	int vertices;
+	struct adjList *arr;
+};
+
+struct adjListNode  *newNode(int data){
+	struct adjListNode *temp = (struct adjListNode *)malloc(sizeof(struct adjListNode));
+	temp->data = data;
+	temp->next = NULL;
+	return temp;
+}
+
+void addEdge(struct graph *newGraph,int start, int end){
+	struct adjListNode *temp = newNode(start);
+	
+	if(newGraph->arr[end].head){
+		temp->next = newGraph->arr[end].head;
+		newGraph->arr[end].head = temp;
+
+	}else{
+		newGraph->arr[end].head = temp;
+	}
+
+	temp = newNode(end);
+	
+	if(newGraph->arr[start].head){
+		temp->next = newGraph->arr[start].head;
+		newGraph->arr[start].head = temp;
+	}else{
+		newGraph->arr[start].head = temp;
+	}
+}
+
+void display(struct graph *newGraph){
+	int i;
+	struct adjListNode *temp;
+	for(i=0;i<newGraph->vertices;i++){
+		temp = newGraph->arr[i].head;
+		printf("%d --> ", i);
+		while(temp){
+			printf("%d ", temp->data);
+			temp = temp->next;
+		}
+		printf("\n");
+	}
+}
+
+int main(){
+
+	struct graph *newGraph = (struct graph *)malloc(sizeof(struct graph));
+	int vertices = 4;
+	newGraph->vertices = 4;
+
+	newGraph->arr = (struct adjList *)calloc(vertices,sizeof(struct adjList));	
+
+	addEdge(newGraph, 0, 1);
+	addEdge(newGraph, 0, 2);
+	addEdge(newGraph, 1, 3);
+	addEdge(newGraph, 2, 3);
+
+	display(newGraph);
+
+	return 0;
+}

Diff for: complex-datastructures/making-a-tree.c

@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+struct node{
+	int data;
+	struct node *left;
+	struct node *right;
+};
+
+struct node *newNode(int data){
+	struct node *temp = (struct node *)malloc(sizeof(struct node));
+	temp->data = data;
+	temp->left = NULL;
+	temp->right = NULL;
+	return temp;
+}
+
+void inorder(struct node *root){
+	if(root){
+		inorder(root->left);
+		printf("%d ", root->data);
+		inorder(root->right);
+	}
+}
+
+void displayTree(struct node *root){
+	struct node *temp = root;
+	inorder(temp);
+}
+
+int main(){
+
+	struct node *root = newNode(10);
+
+	root->left = newNode(20);
+	root->right = newNode(30);
+	root->left->left = newNode(40);
+	root->left->right = newNode(50);
+
+	root->right->left = newNode(60);
+	root->right->right = newNode(70);
+
+	displayTree(root);
+
+	return 0;
+}

Diff for: divide-and-conquer/question3.c

@@ -27,7 +27,7 @@ It also does not handle fractional power
 
 /*
 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
+In this case each time exp value is converted to half and base value is squared
 */
 #include <stdio.h>
 #include <stdlib.h>

Diff for: dynamic-programming/question13.c

@@ -41,49 +41,80 @@ Therefore answer here is 4. (longest possible subsequence)
 Time complexity: Since each element will be compared with its all prev elements in the newly formed
 array O(n^2)
 Space complexity: O(n) //table size is reduced here as compared to method1
+
+METHOD3: 
+Just like a deck of cards
+http://www.geeksforgeeks.org/longest-monotonically-increasing-subsequence-size-n-log-n/
+
+Time complexity: O(nlogn)
+Space complexity: O(1)
+
 */
 
 //METHOD2
+// #include <stdio.h>
+// #include <stdlib.h>
+
+// void longestIncreasingSub(int *arr, int size){
+// 	int sol[size];
+// 	int i,j;
+// 	sol[0] = 1; //base solution cannot be greater than 1.
+// 	int maxLength = 1;
+// 	int start = 0, end = 0;
+// 	int overallMax = 1;
+// 	for(i=1;i<size;i++){
+// 		int currentMax = 1;
+// 		for(j=i-1;j>=0;j--){
+// 			int key = 1;
+// 			if(arr[i] > arr[j]){
+// 				key = key + sol[j];
+// 				if(currentMax < key){
+// 					currentMax = key;
+// 				}
+// 			}
+// 			sol[i] = currentMax;
+// 		}
+// 		if(overallMax < sol[i]){
+// 			overallMax = sol[i];
+// 			end = i;
+// 		}
+// 	}
+
+// 	printf("total length of subsequence is: %d\n", overallMax);
+// 	printf("subsequence is:\n");
+
+// 	//for printing maybe a struct can be taken and element index for which current max
+// 	//is computed is noted down. That will be the answer Iterate like this backwards for all		
+
+// }
+
+// int main(){
+// 	int arr[] = {2,3,1,5,12,10,11};
+// 	int size = sizeof(arr)/sizeof(arr[0]);
+
+// 	longestIncreasingSub(arr,size);
+// 	return 0;
+// }
+
 #include <stdio.h>
 #include <stdlib.h>
 
-void longestIncreasingSub(int *arr, int size){
-	int sol[size];
-	int i,j;
-	sol[0] = 1; //base solution cannot be greater than 1.
-	int maxLength = 1;
-	int start = 0, end = 0;
-	int overallMax = 1;
-	for(i=1;i<size;i++){
-		int currentMax = 1;
-		for(j=i-1;j>=0;j--){
-			int key = 1;
-			if(arr[i] > arr[j]){
-				key = key + sol[j];
-				if(currentMax < key){
-					currentMax = key;
-				}
-			}
-			sol[i] = currentMax;
-		}
-		if(overallMax < sol[i]){
-			overallMax = sol[i];
-			end = i;
-		}
-	}
+int longestIncreasingSub(int *arr, int size){
+	int aux[size];
 
-	printf("total length of subsequence is: %d\n", overallMax);
-	printf("subsequence is:\n");
+	int i;
+	for(i=0;i<size;i++){
+		aux[i] = -1;
+	}
 
-	//for printing maybe a struct can be taken and element index for which current max
-	//is computed is noted down. That will be the answer Iterate like this backwards for all		
+	
 
 }
 
 int main(){
 	int arr[] = {2,3,1,5,12,10,11};
-	int size = sizeof(arr)/sizeof(arr[0]);
+	int size =sizeof(arr)/sizeof(arr[0]);
 
-	longestIncreasingSub(arr,size);
+	longestIncreasingSub(arr, size);
 	return 0;
 }