Merge branch 'master' into master

Author: prateekiiest

CONTRIBUTORS.md

@@ -15,6 +15,9 @@ Thanks for all your contributions :heart: :octocat:
 |[Rahul Arulkumaran](https://github.com/rahulkumaran)| [#94](https://github.com/codeIIEST/Algorithms/pull/94), [#95](https://github.com/codeIIEST/Algorithms/pull/95), [#112](https://github.com/codeIIEST/Algorithms/pull/112), [#151](https://github.com/codeIIEST/Algorithms/pull/151), [#174](https://github.com/codeIIEST/Algorithms/pull/174) | MERGED |
 |[Rahul Arulkumaran](https://github.com/rahulkumaran)| [#206](https://github.com/codeIIEST/Algorithms/pull/206), [#207](https://github.com/codeIIEST/Algorithms/pull/207) | OPEN |
 |[Abhishek Nalla](https://github.com/abhisheknalla)| [#129](https://github.com/codeIIEST/Algorithms/pull/129) ,[#147](https://github.com/codeIIEST/Algorithms/pull/147) [#204](https://github.com/codeIIEST/Algorithms/pull/204)| MERGED |
-| [Zanark ( Debashish Mishra )](https://github.com/Zanark) | [PR #222](https://github.com/codeIIEST/Algorithms/pull/222) , [PR #146](https://github.com/codeIIEST/Algorithms/pull/146) , [PR #135](https://github.com/codeIIEST/Algorithms/pull/135) | OPEN , MERGED , CLOSED|
+| [Zanark ( Debashish Mishra )](https://github.com/Zanark) | [PR #222](https://github.com/codeIIEST/Algorithms/pull/222) , [PR #146](https://github.com/codeIIEST/Algorithms/pull/146) , [PR #225](https://github.com/codeIIEST/Algorithms/pull/225) , [PR #135](https://github.com/codeIIEST/Algorithms/pull/135) | CLOSED , MERGED , MERGED , CLOSED|
 | [d3v3sh5ingh](https://github.com/D3v3sh5ingh) | [PR #126](https://github.com/codeIIEST/Algorithms/pull/126) , [PR #161](https://github.com/codeIIEST/Algorithms/pull/161) | Closed , MERGED|
 |[AdvikEshan( Nitish Kumar Tiwari )](https://github.com/AdvikEshan)| [PR #97](https://github.com/codeIIEST/Algorithms/pull/97),[PR #192](https://github.com/codeIIEST/Algorithms/pull/192), [PR #258](https://github.com/codeIIEST/Algorithms/pull/258)|Merged,Merged,Merged|
+|[imVivekGupta](https://github.com/imVivekGupta)|[#173](https://github.com/codeIIEST/Algorithms/pull/173), [#182](https://github.com/codeIIEST/Algorithms/pull/182), [#218](https://github.com/codeIIEST/Algorithms/pull/218), [#230](https://github.com/codeIIEST/Algorithms/pull/230) | MERGED |
+|[Priyangshuyogi](https://github.com/Priyangshuyogi)| [#188](https://github.com/codeIIEST/Algorithms/pull/188), [#227](https://github.com/codeIIEST/Algorithms/pull/227), [#251](https://github.com/codeIIEST/Algorithms/pull/251)| MERGED , MERGED , OPEN |
+

Competitive Coding/Dynamic Programming/0-1Knapsack/knapsack.java

@@ -0,0 +1,70 @@
+import java.util.*;
+
+
+class Knapsack
+{
+ 
+    // A function to return maximum of two integers
+    static int maximum(int a, int b) 
+      {
+          if(a>b) 
+          return a; 
+          else 
+          return b; 
+
+      }
+      
+   // Returns the maximum value that can be put in a knapsack of capacity W
+    static int  knapSack(int W, int wt[], int val[], int n)
+    {
+         int  i, w;
+     int K[][] = new int[n+1][W+1];
+      
+     // Build table K[][] in bottom up manner
+     for (i = 0; i <= n; i++)
+     {
+         for (w = 0; w <= W; w++)
+         {
+             if (i==0 || w==0)
+                  K[i][w] = 0;
+             else if (wt[i-1] <= w)
+                   K[i][w] = maximum(val[i-1] + K[i-1][w-wt[i-1]] ,  K[i1][w]);
+             else
+                   K[i][w] = K[i-1][w];
+         }
+      }
+      
+      Return  K[n][W];
+    }
+ 
+   
+   
+    public static void main(String args[])
+    {
+		 
+        Scanner s=new Scanner(System.in);
+        System.out.println(“Enter number of objects”);
+        int n=s.nextInt();
+        int val[]=new int[n];
+        int wt[] = new int[n];
+        System.out.println(“Enter values of objects”);
+
+
+        for(int i=0;i<n;i++)
+          {
+            val[i]=s.nextInt();
+          }
+
+        System.out.println(“Enter weights of object”);
+        for(int i=0;i<n;i++)
+          {
+              wt[i]=s.nextInt();
+          }
+
+
+           System.out.println(“Enter the maximum weight”);
+           int  W = s.nextInt();
+           System.out.println(knapSack(W, wt, val, n));
+            }
+}
+

Competitive Coding/Dynamic Programming/0-1Knapsack/readme.md

@@ -0,0 +1,7 @@
+# 0-1 Knapsack
+The knapsack problem or rucksack problem is a problem in combinatorial optimization: Given a set of items, each with a weight and a value, determine the number of each item to include in a collection so that the total weight is less than or equal to a given limit and the total value is as large as possible. It derives its name from the problem faced by someone who is constrained by a fixed-size knapsack and must fill it with the most valuable items.
+
+**Time Complexity**
+Time Complexity: O(nW) where n is the number of items and W is the capacity of knapsack.
+### Applications
+Knapsack problems appear in real-world decision-making processes in a wide variety of fields, such as finding the least wasteful way to cut raw materials,[4] selection of investments and portfolios selection of assets for asset-backed securitization and generating keys for the Merkle–Hellman and other knapsack cryptosystems

Competitive Coding/Dynamic Programming/Coin Change/Coin Change Readme.md

@@ -0,0 +1,28 @@
+Problem :-
+===
+Given a value N and the values of different denomination,find the number of ways to make changes for N cents,if we have infinite supply of all denominations.
+
+Input:-
+---
+Size of an array and all the values in the array and the number of cents.
+
+Output :-
+---
+An integer that denotes the  number of ways to make change.
+
+#### Language : `C++`
+
+#### Algorithm Paradigm : `Dynamic Programming`
+
+#### Time Complexity :  `O(N*M)`
+
+#### Space Complexity : `O(N*M)`
+
+Working :-
+---
+An arr array stores the different currency values.
+Another array temp stores the best values for sub-problems.For eg: `temp[3][4]` stores the optimal value for the number of ways
+to make change if the number of cents(N) were 4 and we only had `arr[0]`,`arr[1]` and `arr[2]` as the different values of currency.
+
+By using dynamic programming we are bringing the time complexity down from exponentional(in case of brute force solution)
+to polynomial.

Competitive Coding/Dynamic Programming/Coin Change/Coin Change.cpp

@@ -0,0 +1,47 @@
+//Coin change problem using dynamic programming in C++.
+#include<bits/stdc++.h>
+
+using namespace std;
+
+int main()
+{
+		int M;//Variable to store the number of different currency values.
+		cout<<"Enter the number of denominations : ";
+		cin>>M;//Inputting the number of different currency value from user.
+		cout<<endl;
+
+		int arr[M];//Array to store different currency values.
+		for(int i=0;i<M;i++)
+		{
+			cout<<"Enter the value of denominaion "<<i+1<<" : ";
+			cin>>arr[i];//Inputting the value of each currency from user.
+		}
+		cout<<endl;
+
+		int N;//Variable to store the number of cents whose number of ways to make change is to be found.
+		cout<<"Enter the number of cents : ";
+		cin>>N;//Inputting the number of cents from user.
+		cout<<endl;
+
+		/*2D array to store the optimal value for sub-cases.*/
+		int temp[M+1][N+1];
+
+		for(int i=0;i<M+1;i++)//Implementing the algorithm.
+		{
+			for(int j=0;j<N+1;j++)
+			{
+				if(i==0 || j==0)
+					temp[i][j]=0;
+				else if(j<arr[i-1])
+					temp[i][j]=temp[i-1][j];
+				else if(j==arr[i-1])
+					temp[i][j]=1+temp[i-1][j];
+				else
+					temp[i][j]=temp[i-1][j]+temp[i][j-arr[i-1]];
+			}
+		}
+
+		cout<<"Number of ways to make change for "<<N<<" cent is "<<temp[M][N]<<endl;//Printing the final answer.
+		
+	return 0;
+}

Competitive Coding/Math/Catalan_Numbers/README.md

@@ -0,0 +1,25 @@
+The two different programs in this folder contain the same implementation!
+The programs basically are a python implementation of the Catalan Numbers.
+They're similar to Fibonacci (very slightly)
+
+The two different implementations vary only in terms of time taken!<br>
+Basically we can implement in 3 different ways!<br>
+
+* Recursively - `Exponential time complexity`<br>
+* Dynamic Programming - `O(n^2)`<br>
+* Binomial Coefficient - `O(n)` <br><br>
+
+Each of the above 3 implementations have a descending order of time complexities from (1) to (3) <br><br>
+
+The Binomial implementation has the best time complexity while the Recursive implementation has the worst time complexity<br>
+In this folder we have the Binomial and Recursive implementations of Catalan Numbers.<br><br>
+
+Catalan Numbers have a lot of applications in Combinatorics. Some of them are listed below:
+* Cn is the number of standard Young tableaux whose diagram is a 2-by-n rectangle. In other words, it is the number of ways the numbers 1, 2, ..., 2n can be arranged in a 2-by-n rectangle so that each row and each column is increasing. As such, the formula can be derived as a special case of the hook-length formula.
+* Cn is the number of ways that the vertices of a convex 2n-gon can be paired so that the line segments joining paired vertices do not intersect. This is precisely the condition that guarantees that the paired edges can be identified (sewn together) to form a closed surface of genus zero (a topological 2-sphere).
+* Cn is the number of semiorders on n unlabeled items.
+* In chemical engineering Cn-1 is the number of possible separation sequences which can separate a mixture of n components.<br><br>
+
+### Sources :
+(1) Click [here](https://www.geeksforgeeks.org/program-nth-catalan-number/) to know more about Catalan number implementations and its theory.<br>
+(2) Click [here](https://en.wikipedia.org/wiki/Catalan_number) to know more about the applicatations of Catalan Numbers in Combinatorics

Competitive Coding/Math/Catalan_Numbers/catalan_binomial.py

@@ -0,0 +1,15 @@
+def binCoeff(n, k):	#Finds the binomial coefficient
+    if (k > n - k):	#As binCoeff(n,k)=binCoeff(n,n-k)
+        k = n - k
+    res = 1		#Initialising Result
+    for i in range(k):
+        res = res * (n - i)
+        res = res / (i + 1)
+    return res		#The binomial coefficient is returned
+
+def catalan(n):		#Function that finds catalan numbers
+    c = binCoeff(2*n, n)	#Finding value of c by calling the binCoeff function
+    return c/(n + 1)		#This is the final catalan number
+
+if __name__=='__main__':
+	print "The 10th catalan number is:",catalan(9)

Competitive Coding/Math/Catalan_Numbers/catalan_recursive.py

@@ -0,0 +1,10 @@
+def catalan_numbers(n):
+    if n <=1 :		#The result will be 1, if the function takes an argument that's equal to or less than 1
+        return 1
+    res = 0		#Result has been initialised to 0
+    for i in range(n):
+        res += catalan_numbers(i) * catalan_numbers(n-i-1)	#The recursive function call
+    return res
+
+if __name__=='__main__':
+	print "The 10th catalan number is:",catalan(9)

Competitive Coding/Math/Project_Euler/Problem_21/P21.class

@@ -0,0 +1,48 @@
+package problem_21;
+class P21
+{ //Begin class
+
+
+	/***** Function to calculate the sum of proper divisors or factors *****/
+	public static int sumFactors(int num)
+	{ //Begin sumFactors()
+		int sum = 0;
+		
+		for(int i = 1; i<num; i++)
+		{ //Begin for
+			if(num % i == 0)
+				sum += i;
+		} //End for
+		
+		return sum;
+	} //End sumFactors()
+	
+	
+	
+	
+	public static void main(String args[])
+	{ //Begin main()
+		int sum_amicable = 0; 
+		int x = 0; 
+		int y = 0;
+		
+		
+		for(int n = 1; n<=10000; n++)
+		{ //Begin for
+			
+			x = sumFactors(n); //Sum of factors or divisors of n
+			y = sumFactors(x); //Sum of factors or divisors of x
+												
+			/*** 
+			1. Checking if the number is not equal to sum of its factors and if the number is equal to y(sum of factors of x) then the number is added to the sum of amicable numbers
+			
+			2. The other number of the amicable pair is added when it appears in the loop later and checking is done for it		***/
+			
+			if((n != x) && (n == y))  
+				sum_amicable += n;
+
+		} //End for
+		
+		System.out.println("Sum of amicable numbers less than 10000 is:\t"+sum_amicable);
+	} //End main()
+} //End class

Competitive Coding/Math/Project_Euler/Problem_21/P21.java

@@ -0,0 +1,12 @@
+# Amicable numbers
+
+----------------------------------------------------------------------------------------------
+
+### Problem 21
+
+Let d(n) be defined as the sum of proper divisors of n (numbers less than n which divide evenly into n).
+If d(a) = b and d(b) = a, where a ≠ b, then a and b are an amicable pair and each of a and b are called amicable numbers.
+
+For example, the proper divisors of 220 are 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 and 110; therefore d(220) = 284. The proper divisors of 284 are 1, 2, 4, 71 and 142; so d(284) = 220.
+
+Evaluate the sum of all the amicable numbers under 10000.

Competitive Coding/Math/Project_Euler/Problem_21/README.md

@@ -0,0 +1,12 @@
+# Project Euler
+
+----------------------------------------------------------------------------------------------
+
+### What is Project Euler?
+
+Project Euler is a series of challenging mathematical/computer programming problems that will require more than just mathematical insights to solve. Although mathematics will help you arrive at elegant and efficient methods, the use of a computer and programming skills will be required to solve most problems.
+
+The motivation for starting Project Euler, and its continuation, is to provide a platform for the inquiring mind to delve into unfamiliar areas and learn new concepts in a fun and recreational context.
+
+
+Click here to check out the problems: [Project Euler] (https://projecteuler.net/)

Competitive Coding/Math/Project_Euler/README.md

@@ -0,0 +1,49 @@
+package Euler
+class P21
+{ //Begin class
+
+
+	/***** Function to calculate the sum of proper divisors or factors *****/
+	public static int sumFactors(int num)
+	{ //Begin sumFactors()
+		int sum = 0;
+		
+		for(int i = 1; i<num; i++)
+		{ //Begin for
+			if(num % i == 0)
+				sum += i;
+		} //End for
+		
+		return sum;
+	} //End sumFactors()
+	
+	
+	
+	
+	public static void main(String args[])
+	{ //Begin main()
+		int sum_amicable = 0; 
+		int x = 0; 
+		int y = 0;
+		
+		
+		for(int n = 1; n<=10000; n++)
+		{ //Begin for
+			
+			x = sumFactors(n); //Sum of factors or divisors of n
+			y = sumFactors(x); //Sum of factors or divisors of x
+						
+						
+			/*** 
+			1. Checking if the number is not equal to sum of its factors and if the number is equal to y(sum of factors of x) then the number is added to the sum of amicable numbers
+			
+			2. The other number of the amicable pair is added when it appears in the loop later and checking is done for it		***/
+			
+			if((n != x) && (n == y))  
+				sum_amicable += n;
+
+		} //End for
+		
+		System.out.println("Sum of amicable numbers less than 10000 is:\t"+sum_amicable);
+	} //End main()
+} //End class

Competitive Coding/Math/Project_Euler/amicable_pair(prob 21).java

@@ -0,0 +1 @@
+GFG link