Merge https://github.com/Ankitr19/Algorithms-1

Author: Ankitr19

CONTRIBUTORS.md

@@ -6,6 +6,8 @@ Thanks for all your contributions :heart: :octocat:
 
 
 [prateekiiest](https://github.com/prateekiiest) : KWOC Mentor
-
 | Github username      | Pull Request           | Status  |
-| Ankitr19(https://github.com/Ankitr19) | |https://github.com/codeIIEST/Algorithms/pull/203| |Open|
+|[Ankitr19](https://github.com/Ankitr19)| [#203]https://github.com/codeIIEST/Algorithms/pull/203 |OPEN|
+|[Rahul Arulkumaran](https://github.com/rahulkumaran)| [#46](https://github.com/codeIIEST/Algorithms/pull/46), [#66](https://github.com/codeIIEST/Algorithms/pull/66), [#88](https://github.com/codeIIEST/Algorithms/pull/88), [#89](https://github.com/codeIIEST/Algorithms/pull/89), [#90](https://github.com/codeIIEST/Algorithms/pull/90), [#93](https://github.com/codeIIEST/Algorithms/pull/93), [#159](https://github.com/codeIIEST/Algorithms/pull/159) | CLOSED |
+|[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 |

Competitive Coding/Dynamic Programming/cutRod/Readme.md

@@ -0,0 +1,15 @@
+Given a rod of length n inches and an array of prices that contains prices of all pieces of size smaller than n. Determine the maximum value obtainable by cutting up the rod and selling the pieces. For example, if length of the rod is 8 and the values of different pieces are given as following, then the maximum obtainable value is 22 (by cutting in two pieces of lengths 2 and 6)
+
+length   | 1   2   3   4   5   6   7   8  
+--------------------------------------------
+price    | 1   5   8   9  10  17  17  20
+
+1) Optimal Substructure:
+We can get the best price by making a cut at different positions and comparing the values obtained after a cut. We can recursively call the same function for a piece obtained after a cut.
+
+Let cutRoad(n) be the required (best possible price) value for a rod of lenght n. cutRod(n) can be written as following.
+
+cutRod(n) = max(price[i] + cutRod(n-i-1)) for all i in {0, 1 .. n-1}
+
+2) Overlapping Subproblems
+Like other typical Dynamic Programming(DP) problems, recomputations of same subproblems can be avoided by constructing a temporary array val[] in bottom up manner.

Competitive Coding/Dynamic Programming/cutRod/cutRod.c

@@ -0,0 +1,44 @@
+#include<stdio.h>
+#include<limits.h>
+
+// A utility function to get the maximum of two integers
+int max(int a, int b)
+ {
+	 return (a > b)? a : b;
+ }
+
+
+ /* Returns the best obtainable price for a rod of length n and
+    price[] as prices of different pieces */
+int DPcutRod(int price[], int n)
+{
+   int val[n+1];
+   val[0] = 0;
+   int i, j;
+   for (i = 1; i<=n; i++)
+   {
+       int max_val = INT_MIN;
+       // Recursively cut the rod in different pieces and compare different
+  // configurations
+       for (j = 0; j < i; j++)
+         max_val = max(max_val, price[j] + val[i-j-1]);
+       val[i] = max_val;
+   }
+   return val[n];
+}
+
+int main()
+{
+		int n;
+		printf("Enter rod length\n");
+		scanf("%d",&n);
+		int arr[n],i;
+		printf("Enter prices for lengths 1 to n\n");
+		for(i=0;i<n;i++)
+		{
+			scanf("%d",&arr[i]);
+		}
+    printf("Maximum Obtainable Value is %d\n", DPcutRod(arr, n));
+    getchar();
+    return 0;
+}

Competitive Coding/Dynamic Programming/minCostPath/Readme.md

@@ -0,0 +1,20 @@
+Given a cost matrix cost[][] and a position (m, n) in cost[][], write a function that returns cost of minimum cost path to reach (m, n) from (0, 0). Each cell of the matrix represents a cost to traverse through that cell. Total cost of a path to reach (m, n) is sum of all the costs on that path (including both source and destination). You can only traverse down, right and diagonally lower cells from a given cell, i.e., from a given cell (i, j), cells (i+1, j), (i, j+1) and (i+1, j+1) can be traversed.
+
+1) Optimal Substructure
+The path to reach (m, n) must be through one of the 3 cells: (m-1, n-1) or (m-1, n) or (m, n-1). So minimum cost to reach (m, n) can be written as “minimum of the 3 cells plus cost[m][n]”.
+
+minCost(m, n) = min (minCost(m-1, n-1), minCost(m-1, n), minCost(m, n-1)) + cost[m][n]
+
+2) Overlapping Subproblems
+Like other typical Dynamic Programming(DP) problems, recomputations of same subproblems can be
+avoided by constructing a temporary array tc[][] in bottom up manner.
+
+
+Example:
+3 3
+1 2 3
+4 8 2
+1 5 3
+
+Ouptut:
+8

Competitive Coding/Dynamic Programming/minCostPath/minCostPath.cpp

@@ -0,0 +1,55 @@
+#include <iostream>
+#include <algorithm>
+
+using namespace std;
+
+int main(){
+	std::ios::sync_with_stdio(false);
+	/*
+		We can easily observe that the optimum solution of the minimum
+		cost at any row i is only dependent on the cost at row i-1 and
+		the current row elements. Thus if we only store these two arrays
+		of length c, We have reduced space from n*m to 2*m.
+	*/
+
+	int i, j, r, c;
+  printf("Enter no of rows and no of cols\n");
+	cin>>r>>c;     //take input of the rows and columns from user.
+	int cost[c], dp[c];
+	int x;
+	/*
+		Since for the first row the minimum cost is the only cost possible
+		required to get there, we directly calculate it.
+	*/
+  printf("Enter a R X C array\n");
+
+	for(i=0; i<c; i++){
+		cin>>cost[i];
+		if(i>0) cost[i] = cost[i] + cost[i-1];
+	}
+	/*
+		For the subsequent rows, the optimised cost for each cell in the
+		previous row has been stored in the array cost[] and the optimised
+		cost for the present row is stored in the array dp[].
+	*/
+	for(i=1; i<r; i++){
+		for(j=0; j<c; j++){
+			cin>>x;
+			if(j==0)
+				dp[j] = cost[j] + x;
+			else{
+				dp[j] = x + min(dp[j-1], min(cost[j-1], cost[j]));
+			}
+		}
+		/*
+			After dp[] has been found entirely, we copy its elements to
+			cost[] and continue the iteration.
+		*/
+		for(j=0; (j<c && i!=c-1); j++){
+			cost[j] = dp[j];
+		}
+	}
+  printf("The min cost path from 1,1 to r,c is\n");
+	cout<<dp[c-1]<<"\n";
+	return 0;
+}

Competitive Coding/Dynamic Programming/subsetSum/Readme.md

@@ -0,0 +1,21 @@
+Given a set of non-negative integers, and a value sum, determine if there is a subset of the given set with sum equal to given sum.
+
+Examples: set[] = {3, 34, 4, 12, 5, 2}, sum = 9
+Output:  True  //There is a subset (4, 5) with sum 9.
+
+Let isSubSetSum(int set[], int n, int sum) be the function to find whether there is a subset of set[] with sum equal to sum. n is the number of elements in set[].
+
+The isSubsetSum problem can be divided into two subproblems
+…a) Include the last element, recur for n = n-1, sum = sum – set[n-1]
+…b) Exclude the last element, recur for n = n-1.
+If any of the above the above subproblems return true, then return true.
+
+Following is the recursive formula for isSubsetSum() problem.
+
+isSubsetSum(set, n, sum) = isSubsetSum(set, n-1, sum) ||
+                           isSubsetSum(set, n-1, sum-set[n-1])
+Base Cases:
+isSubsetSum(set, n, sum) = false, if sum > 0 and n == 0
+isSubsetSum(set, n, sum) = true, if sum == 0
+
+We can solve the problem in Pseudo-polynomial time using Dynamic programming. We create a boolean 2D table subset[][] and fill it in bottom up manner. The value of subset[i][j] will be true if there is a subset of set[0..j-1] with sum equal to i., otherwise false. Finally, we return subset[sum][n]

Competitive Coding/Dynamic Programming/subsetSum/subsetSum.cpp

@@ -0,0 +1,45 @@
+#include <stdio.h>
+
+// Returns true if there is a subset of a[] with sun equal to given sum
+bool DP(int set[], int n, int sum)
+{
+  // The value of subset[i][j] will be true if there is a
+// subset of set[0..j-1] with sum equal to i
+    bool subset[n+1][sum+1];
+    // If sum is 0, then answer is true
+    for (int i = 0; i <= n; i++)
+      subset[i][0] = true;
+      // If sum is not 0 and set is empty, then answer is false
+    for (int i = 1; i <= sum; i++)
+      subset[0][i] = false;
+           // Fill the subset table in botton up manner
+    for (int i = 1; i <= n; i++)
+     {
+       for (int j = 1; j <= sum; j++)
+       {
+         if(j<set[i-1])
+         subset[i][j] = subset[i-1][j];
+         if (j >= set[i-1])
+           subset[i][j] = subset[i-1][j] ||
+                                 subset[i - 1][j-set[i-1]];
+       }
+     }
+     return subset[n][sum];
+}
+
+int main()
+{
+  int n;
+  int sum;
+  printf("Enter no of elements of array and desired sum\n");
+  scanf("%d%d",&n,&sum);
+  int i,a[n];
+  printf("Enter the array\n");
+  for(i=0;i<n;i++)
+    scanf("%d",&a[i]);
+  if (DP(a, n+1, sum) == true)
+     printf("Found a subset with given sum\n");
+  else
+     printf("No subset with given sum\n");
+  return 0;
+}

Competitive Coding/Dynamic Programming/uglyNumbers/Readme.md

@@ -0,0 +1,24 @@
+Ugly numbers are numbers whose only prime factors are 2, 3 or 5. The sequence 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, … shows the first 11 ugly numbers. By convention, 1 is included.
+
+Given a number n, the task is to find n’th Ugly number.
+
+Input  : n = 7
+Output : 8
+
+Input  : n = 10
+Output : 12
+
+Input  : n = 15
+Output : 24
+
+Input  : n = 150
+Output : 5832
+
+DP method:
+Here is a time efficient solution with O(n) extra space. The ugly-number sequence is 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, …
+     because every number can only be divided by 2, 3, 5, one way to look at the sequence is to split the sequence to three groups as below:
+     (1) 1×2, 2×2, 3×2, 4×2, 5×2, …
+     (2) 1×3, 2×3, 3×3, 4×3, 5×3, …
+     (3) 1×5, 2×5, 3×5, 4×5, 5×5, …
+
+     We can find that every subsequence is the ugly-sequence itself (1, 2, 3, 4, 5, …) multiply 2, 3, 5. Then we use similar merge method as merge sort, to get every ugly number from the three subsequence. Every step we choose the smallest one, and move one step after.

Competitive Coding/Dynamic Programming/uglyNumbers/uglyNumbers.cpp

@@ -0,0 +1,24 @@
+#include<bits/stdc++.h>
+using namespace std;
+int main()
+{
+	printf("Enter no of test cases\n");
+	int t; cin >> t;
+	int i2, i3, i5;
+	i2 = i3 = i5 = 0;
+	int ugly[500];// To store ugly numbers
+	ugly[0] = 1;
+	for (int i = 1; i < 500; ++i) {
+		ugly[i] = min(ugly[i2]*2, min(ugly[i3]*3, ugly[i5]*5));//get minimum of possible solutions
+		ugly[i] != ugly[i2]*2 ? : i2++;		//      next_mulitple_of_2 = ugly[i2]*2;
+		ugly[i] != ugly[i3]*3? : i3++;		//      next_mulitple_of_3 = ugly[i3]*3
+		ugly[i] != ugly[i5]*5 ? : i5++;   //      next_mulitple_of_5 = ugly[i5]*5;
+	}
+	int n;
+	while(t--) {
+		printf("Enter 'n' for the nth ugly number\n");
+		cin >> n;
+		cout << ugly[n-1] << endl;
+	}
+	return 0;
+}

Competitive Coding/Strings/String Search/Z-algorithm/Readme.md

@@ -0,0 +1,37 @@
+# Z Algorithm
+
+This algorithm finds all occurrences of a pattern in a text in linear time. Let length of text be n and of pattern be m, then total time taken is O(m + n) with linear space complexity. Now we can see that both time and space complexity is same as KMP algorithm but this algorithm is Simpler to understand.
+
+In this algorithm, we construct a Z array.
+
+# What is Z array?
+
+For a string str[0..n-1], Z array is of same length as string. An element Z[i] of Z array stores length of the longest substring starting from str[i] which is also a prefix of str[0..n-1]. The first entry of Z array is meaning less as complete string is always prefix of itself.
+Example:
+Index            0   1   2   3   4   5   6   7   8   9  10  11 
+Text             a   a   b   c   a   a   b   x   a   a   a   z
+Z values         X   1   0   0   3   1   0   0   2   2   1   0 
+
+# How to construct Z array?
+
+The idea is to maintain an interval [L, R] which is the interval with max R
+such that [L,R] is prefix substring (substring which is also prefix). 
+
+Steps for maintaining this interval are as follows – 
+
+1) If i > R then there is no prefix substring that starts before i and 
+   ends after i, so we reset L and R and compute new [L,R] by comparing 
+   str[0..] to str[i..] and get Z[i] (= R-L+1). 
+
+2) If i <= R then let K = i-L,  now Z[i] >= min(Z[K], R-i+1)  because 
+   str[i..] matches with str[K..] for atleast R-i+1 characters (they are in
+   [L,R] interval which we know is a prefix substring).      
+   Now two sub cases arise – 
+      a) If Z[K] < R-i+1  then there is no prefix substring starting at 
+         str[i] (otherwise Z[K] would be larger)  so  Z[i] = Z[K]  and 
+         interval [L,R] remains same.
+      b) If Z[K] >= R-i+1 then it is possible to extend the [L,R] interval
+         thus we will set L as i and start matching from str[R]  onwards  and
+         get new R then we will update interval [L,R] and calculate Z[i] (=R-L+1)
+
+The algorithm runs in linear time because we never compare character less than R and with matching we increase R by one so there are at most T comparisons. In mismatch case, mismatch happen only once for each i (because of which R stops), that’s another at most T comparison making overall linear complexity.

Competitive Coding/Strings/String Search/Z-algorithm/z-algorithm.cpp

@@ -0,0 +1,84 @@
+#include<bits/stdc++.h>
+using namespace std;
+#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
+#define md 1000000007
+#define ll long long int
+#define vi vector<int>
+#define vll vector<i64>
+#define pb push_back
+#define all(c) (c).begin(),(c).end()
+template< class T > T max2(const T &a,const T &b) {return (a < b ? b : a);}
+template< class T > T min2(const T &a,const T &b) {return (a > b ? b : a);}
+template< class T > T max3(const T &a, const T &b, const T &c) { return max2(a, max2(b, c)); }
+template< class T > T min3(const T &a, const T &b, const T &c) { return min2(a, min2(b, c)); }
+template< class T > T gcd(const T a, const T b) { return (b ? gcd<T>(b, a%b) : a); }
+template< class T > T lcm(const T a, const T b) { return (a / gcd<T>(a, b) * b); }
+template< class T > T mod(const T &a, const T &b) { return (a < b ? a : a % b); }
+typedef pair<ll,ll> pi;
+int main()
+{
+    fastio;
+    string txt;
+    string pat;
+    getline(cin,txt);//getline() reads the complete line in contrary to the traditional cin function which reads just the string before any spaces
+    getline(cin,pat);
+    int n = txt.length();
+    int pat_len = pat.length();
+    string str = pat + "$" + txt;//This is the new string that is formed after merging the pattern, '$' and txt string . we can use any other symbol instead of '$'.I have used dollar sign because it occurs rarely in the txt string
+
+    int len = n+pat_len +1;//length of the total output string
+    int z_val[len]={0};
+    int left =0;//left index of the z box
+    int right =0;//right index of the z box
+    int count=0;//count of the match
+    for(int i=1;i<len;i++)
+    {
+        int curr = i;
+        if(count>1)
+        {
+            left =i;
+            right = i + count-2;
+        }
+
+
+        if(count<=1)
+        {
+            count=0;
+        for(int j=0;j<curr && j<len;j++)
+        {
+            if(str[j]==str[curr])
+            {
+                count++;
+                curr++;
+            }
+            else
+            {
+                z_val[i]=count;
+                break;
+
+            }
+        }
+        }
+        else
+        {
+            for(int j=left;j<=right; j++)
+            {
+                if(z_val[j-left]+j<right)//looks for the edge cases when the string index + the assigned z value surpasses the right index..this is not possible.So we need to check the match for given letter saperately.
+                    z_val[j]=z_val[j-left];
+                else
+                {
+                    count=0;
+                    i=j-1;
+                    break;
+                }
+            }
+        }
+    }
+    for(int i=0;i<len;i++)
+    {
+        if(z_val[i]==pat_len)//This indicates the index where the string occurence takes place
+            cout<<i-pat_len<<endl;
+    }
+
+
+}