Practise 10-Jun-2020

Author: sureshmangs

competitive programming/leetcode/2020-June-Challenge/Day-09-Is Subsequence.cpp

@@ -0,0 +1,55 @@
+Given a string s and a string t, check if s is subsequence of t.
+
+A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, "ace" is a subsequence of "abcde" while "aec" is not).
+
+Follow up:
+If there are lots of incoming S, say S1, S2, ... , Sk where k >= 1B, and you want to check one by one to see if T has its subsequence. In this scenario, how would you change your code?
+
+Credits:
+Special thanks to @pbrother for adding this problem and creating all test cases.
+
+
+
+Example 1:
+
+Input: s = "abc", t = "ahbgdc"
+Output: true
+Example 2:
+
+Input: s = "axc", t = "ahbgdc"
+Output: false
+
+
+Constraints:
+
+0 <= s.length <= 100
+0 <= t.length <= 10^4
+Both strings consists only of lowercase characters.
+
+
+
+
+
+
+
+class Solution {
+public:
+    bool isSubsequence(string s, string t) {
+        int tlen=t.length();
+        int slen=s.length();
+
+        if(slen>tlen) return 0;
+
+        int j=0;
+
+        for(int i=0;i<tlen;i++){
+            if(t[i]==s[j]){
+                j++;
+                if(j==slen) break;
+            }
+        }
+
+        if(j==slen) return true;
+        else return false;
+    }
+};

competitive programming/leetcode/322. Coin Change.cpp

@@ -0,0 +1,37 @@
+You are given coins of different denominations and a total amount of money amount. Write a function to compute the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return -1.
+
+Example 1:
+
+Input: coins = [1, 2, 5], amount = 11
+Output: 3
+Explanation: 11 = 5 + 5 + 1
+Example 2:
+
+Input: coins = [2], amount = 3
+Output: -1
+Note:
+You may assume that you have an infinite number of each kind of coin.
+
+
+
+
+class Solution {
+public:
+    int coinChange(vector<int>& coins, int amt) {
+        int n=coins.size();
+        int dp[n+1][amt+1];
+
+        for(int i=0;i<n+1;i++) dp[i][0]=0;
+        for(int j=1;j<amt+1;j++) dp[0][j]=INT_MAX-1;
+
+        for(int i=1;i<n+1;i++){
+            for(int j=1;j<amt+1;j++){
+                if(coins[i-1]<=j)
+                    dp[i][j]=min(dp[i][j-coins[i-1]]+1, dp[i-1][j]);
+                else dp[i][j]=dp[i-1][j];
+            }
+        }
+
+        return dp[n][amt]==INT_MAX-1 ? -1: dp[n][amt];
+    }
+};

competitive programming/leetcode/392. Is Subsequence.cpp

@@ -0,0 +1,57 @@
+Given a string s and a string t, check if s is subsequence of t.
+
+A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, "ace" is a subsequence of "abcde" while "aec" is not).
+
+Follow up:
+If there are lots of incoming S, say S1, S2, ... , Sk where k >= 1B, and you want to check one by one to see if T has its subsequence. In this scenario, how would you change your code?
+
+Credits:
+Special thanks to @pbrother for adding this problem and creating all test cases.
+
+
+
+Example 1:
+
+Input: s = "abc", t = "ahbgdc"
+Output: true
+Example 2:
+
+Input: s = "axc", t = "ahbgdc"
+Output: false
+
+
+Constraints:
+
+0 <= s.length <= 100
+0 <= t.length <= 10^4
+Both strings consists only of lowercase characters.
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    bool isSubsequence(string s, string t) {
+        int tlen=t.length();
+        int slen=s.length();
+
+        if(slen>tlen) return 0;
+
+        int j=0;
+
+        for(int i=0;i<tlen;i++){
+            if(t[i]==s[j]){
+                j++;
+                if(j==slen) break;
+            }
+        }
+
+        if(j==slen) return true;
+        else return false;
+    }
+};

dynamic programming/coin_change_min_num_of_ways.cpp

@@ -0,0 +1,81 @@
+/*
+Given a value V. You have to make change for V cents, given that you have infinite supply of each of C{ C1, C2, .. , Cm} valued coins. Find the minimum number of coins to make the change.
+
+Input:
+The first line of input contains an integer T denoting the number of test cases. The first line of each test case is V and N, V is the value of cents and N is the number of coins. The second line of each test case contains N input C[i], value of available coins.
+
+Output:
+Print the minimum number of coins to make the change, if not possible print "-1".
+
+Constraints:
+1 ≤ T ≤ 100
+1 ≤ V ≤ 106
+1 ≤ N ≤ 106
+1 ≤ C[i] ≤ 106
+
+Example:
+Input:
+1
+7 2
+2 1
+
+Output:
+4
+
+Explanation :
+Testcase 1: We can use coin with value 2 three times, and coin with value 1 one times to change a total of 7.
+*/
+
+
+
+
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+
+int minCoinChange(int coins[], int n, int amt){
+    int dp[n+1][amt+1];
+
+    for(int i=0;i<n+1;i++) dp[i][0]=0;
+    for(int j=1;j<amt+1;j++) dp[0][j]=INT_MAX-1;
+
+    for(int i=1;i<n+1;i++){
+        for(int j=1;j<amt+1;j++){
+            if(coins[i-1]<=j)
+                dp[i][j]=min(dp[i][j-coins[i-1]]+1, dp[i-1][j]);
+            else dp[i][j]=dp[i-1][j];
+        }
+    }
+
+
+
+    return dp[n][amt]==INT_MAX-1 ? -1: dp[n][amt];
+}
+
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    cout.tie(NULL);
+
+    int t;
+    cin>>t;
+    while(t--){
+        int v, n;
+        cin>>v>>n;
+
+        int coins[n];
+        for(int i=0;i<n;i++) cin>>coins[i];
+
+        cout<<minCoinChange(coins, n, v)<<endl;
+    }
+
+
+return 0;
+}
+

dynamic programming/coin_change_num_of_ways.cpp

@@ -0,0 +1,80 @@
+/*
+Given a value N, find the number of ways to make change for N cents, if we have infinite supply of each of S = { S1, S2, .. , Sm} valued coins. The order of coins doesn’t matter. For example, for N = 4 and S = {1,2,3}, there are four solutions: {1,1,1,1},{1,1,2},{2,2},{1,3}. So output should be 4. For N = 10 and S = {2, 5, 3, 6}, there are five solutions: {2,2,2,2,2}, {2,2,3,3}, {2,2,6}, {2,3,5} and {5,5}. So the output should be 5.
+
+Input:
+The first line contains an integer 'T' denoting the total number of test cases. In each test cases, the first line contains an integer 'M' denoting the size of array. The second line contains M space-separated integers A1, A2, ..., AN denoting the elements of the array. The third line contains an integer 'N' denoting the cents.
+
+Output:
+Print number of possible ways to make change for N cents.
+
+Constraints:
+1 ≤ T ≤ 50
+1 ≤ N ≤ 300
+1 ≤ A[i] ≤ 300
+
+Example:
+Input:
+2
+3
+1 2 3
+4
+4
+2 5 3 6
+10
+
+Output:
+4
+5
+
+Explanation:
+Testcase 1: The possiblities are as such: {1, 1, 1, 1}, {1, 1, 2}, {1, 3}, {2, 2}.
+*/
+
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int coinChange(int coins[], int n, int amt){
+    int dp[n+1][amt+1];
+
+    for(int i=0;i<n+1;i++) dp[i][0]=1;
+    for(int j=1;j<amt+1;j++) dp[0][j]=0;
+
+    for(int i=1;i<n+1;i++){
+        for(int j=1;j<amt+1;j++){
+            if(coins[i-1]<=j)
+                dp[i][j]=dp[i][j-coins[i-1]] + dp[i-1][j];
+            else dp[i][j]=dp[i-1][j];
+        }
+    }
+    return dp[n][amt];
+}
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    cout.tie(NULL);
+    int t;
+    cin>>t;
+    while(t--){
+        int n;
+        cin>>n;
+
+        int coins[n];
+        for(int i=0;i<n;i++) cin>>coins[i];
+
+        int amt;
+        cin>>amt;
+
+        cout<<coinChange(coins, n, amt)<<endl;
+
+    }
+
+
+
+return 0;
+}

dynamic programming/longest_common_subsequence_memoization.cpp

@@ -0,0 +1,70 @@
+/*
+Given two sequences, find the length of longest subsequence present in both of them. Both the strings are of uppercase.
+
+Input:
+First line of the input contains no of test cases  T,the T test cases follow.
+Each test case consist of 2 space separated integers A and B denoting the size of string str1 and str2 respectively
+The next two lines contains the 2 string str1 and str2 .
+
+Output:
+For each test case print the length of longest  common subsequence of the two strings .
+
+Constraints:
+1<=T<=200
+1<=size(str1),size(str2)<=100
+
+Example:
+Input:
+2
+6 6
+ABCDGH
+AEDFHR
+3 2
+ABC
+AC
+
+Output:
+3
+2
+
+Explanation
+LCS for input Sequences “ABCDGH” and “AEDFHR” is “ADH” of length 3.
+
+LCS of "ABC" and "AC" is "AC" of length 2
+*/
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int dp[102][102];     // set according to constraints
+
+int LCS(string s1, string s2, int n, int m){
+    if(n==0 || m==0) return 0;
+    if(dp[n][m]!=-1) return dp[n][m];
+    if(s1[n-1]==s2[m-1])
+        return dp[n][m]=1 + LCS(s1,s2,n-1,m-1);
+    else return dp[n][m]=max(LCS(s1,s2,n,m-1), LCS(s1,s2,n-1,m));
+}
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    cout.tie(NULL);
+
+    int t;
+    cin>>t;
+    while(t--){
+        int n,m;
+        cin>>n>>m;
+        string s1,s2;
+        cin>>s1>>s2;
+        memset(dp, -1, sizeof(dp));
+        cout<<LCS(s1,s2,n,m)<<endl;
+    }
+
+return 0;
+}