aa

Author: uttamsaha

arithmetic-expression-validity-checking.cpp

@@ -0,0 +1,38 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main()
+{
+    cout << "Enter your expression:\n ";
+    string expression;
+    cin >> expression;
+    stack<int> Stack;
+    int length = expression.size();
+    bool result = false;
+
+    for(int i = 0; i<length; i++){
+        char character = expression[i];
+        if(character=='(' || character=='{' || character=='['){
+            Stack.push(character);
+        }
+        else if (character==')' || character=='}' || character==']'){
+            if(Stack.empty()) {
+                result = true;
+                break;
+            }
+            else if((character==')'&&Stack.top()=='(') || (character=='}'&&Stack.top()=='{') || (character==']'&&Stack.top()=='[') ){
+                Stack.pop();
+            }
+        }
+    }
+    if(result==true) {
+        cout << "Opening bracket missing. Invalid arithmetic expression \n";
+    }
+    else if(!Stack.empty()) {
+        cout << "Closing bracket missing. Invalid arithmetic expression \n";
+    }
+    else {
+        cout << "Valid arithmetic expression \n";
+    }
+    return 0;
+}

coin-change-problem-using-dynamic-programming.cpp

@@ -0,0 +1,37 @@
+#include <stdio.h>
+
+int coin_change(int coins[], int size, int sum)
+{
+    int dp[size + 1][sum + 1];
+
+    for (int i = 0; i <= size; i++)
+    {
+        for (int j = 0; j <= sum; j++)
+        {
+            if (i == 0) {
+                dp[0][j] = 0;
+            }
+            else if (j == 0) {
+                dp[i][0] = 1;
+            }
+            else if (coins[i - 1] > j) {
+                dp[i][j] = dp[i - 1][j];
+            }
+            else {
+                dp[i][j] = dp[i - 1][j] + dp[i][j - coins[i - 1]];
+            }
+        }
+    }
+
+    return dp[size][sum];
+}
+
+int main()
+{
+    int coins[] = { 1, 2, 3, 4, 5, 7};
+    int size = sizeof(coins) / sizeof(coins[0]);
+    int sum = 12;
+    int result = coin_change(coins, size, sum);
+    printf("Number of ways are :  %d",result);
+    return 0;
+}

gold-mine-problem.cpp

@@ -0,0 +1,49 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+const int MAX = 100;
+
+int getMaxGold(int gold[][MAX], int m, int n)
+{
+    int goldTable[m][n];
+    memset(goldTable, 0, sizeof(goldTable));
+
+    for (int col=n-1; col>=0; col--)
+    {
+        for (int row=0; row<m; row++)
+        {
+            int right = (col==n-1)? 0: goldTable[row][col+1];
+
+            int right_up = (row==0 || col==n-1)? 0:
+                            goldTable[row-1][col+1];
+
+
+            int right_down = (row==m-1 || col==n-1)? 0:
+                             goldTable[row+1][col+1];
+
+
+            goldTable[row][col] = gold[row][col] +
+                              max(right, max(right_up, right_down));
+
+        }
+    }
+
+
+    int res = goldTable[0][0];
+    for (int i=1; i<m; i++)
+        res = max(res, goldTable[i][0]);
+    return res;
+}
+
+
+int main()
+{
+    int gold[MAX][MAX]= { {1, 3, 1, 5},
+        {2, 2, 4, 1},
+        {5, 0, 2, 3},
+        {0, 6, 1, 2}
+    };
+    int m = 4, n = 4;
+    cout <<"Maximum " << getMaxGold(gold, m, n) << " amount of gold can be collected.";
+    return 0;
+}

kmp-string-searching.cpp

@@ -0,0 +1,61 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+void lpstable(int* lps, string pat, int m) {
+    int i = 1, j = 0;
+    while(i<m) {
+        if(pat[i]==pat[j]) {
+            lps[i] = ++j;
+            i++;
+        }
+        else{
+            if(j!=0){
+                j = lps[j-1];
+            }
+            else {
+                lps[i] = 0; i++;
+            }
+        }
+    }
+}
+
+void KMP(string text, string pat, int n, int m) {
+    int lps[m];
+    lps[0] = 0;
+    lpstable(lps, pat, m);
+    cout << "LPS Table of " << pat << " is: ";
+    for(int i = 0; i<m; i++) {
+        cout << lps[i] << " ";
+    }
+    cout << endl;
+    int i = 0, j = 0;
+    while(i<n) {
+        if( text[i]==pat[j]) {
+            i++,j++;
+            if(j==m) {
+                cout << "Pattern Found at Index: " << i - j << endl;
+                j = lps[j-1];
+            }
+        }
+        else{
+            if(j!=0) {
+                j = lps[j-1];
+            }
+            else i++;
+        }
+    }
+}
+
+int main() {
+    //freopen("in.txt", "r", stdin);
+    string text, pat;
+    cout << "Enter the Text: ";
+    getline(cin,text);
+    cout << "Enter the Pattern: ";
+    getline(cin, pat);
+    int n = text.size(), m = pat.size();
+    cout << "The length of the text: " << n << endl;
+    cout << "The length of the pattern: " << m << endl;
+    KMP(text, pat, n, m);
+    return 0;
+}

matrix-chain-multiplication-problem.cpp

@@ -0,0 +1,51 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+
+int MatrixChainOrder(int p[], int n)
+{
+  int m[n][n];
+
+  int i, j, k, L, q;
+
+  for (i=0; i<n; i++)
+    m[i][i] = 0;
+
+  for (L=2; L<n; L++)
+  {
+    for (i=1; i<n-L+1; i++)
+    {
+      j = i+L-1;
+        m[i][j] = INT_MAX;
+      for (k=i; k<j; k++)
+      {
+        q = m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j];
+        if (q < m[i][j])
+
+          m[i][j] = q;
+      }
+    }
+
+  }
+  for(int i = 1; i <n; i++){
+    for(int j = 1; j <n; j++){
+       if(j >= i){
+        cout << m[i][j] << "\t";
+       }
+       else {
+        cout << "\t";
+       }
+
+    }
+    cout << endl;
+  }
+  return m[1][n-1];
+}
+
+int main()
+{
+  int arr[] = {4,10,3,12,20,7};
+  int size = sizeof(arr)/sizeof(arr[0]);
+    cout<< MatrixChainOrder(arr,size)<<" Minimum scalar operations";
+
+}

minimum-cost-path-problem.cpp

@@ -0,0 +1,42 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+const int Size = 100;
+int minimumPath(int dp_table[Size][Size], int row, int col){
+    int minPath[row][col];
+    for(int i = 0; i<row; i++) {
+        for(int j = 0; j<col; j++) {
+            if(i==0 && j==0) {
+                minPath[i][j] = dp_table[0][0];
+            }
+            else if(j==0) {
+                minPath[i][j] = minPath[i-1][j] + dp_table[i][j];
+            }
+            else if(i==0){
+                minPath[i][j] = minPath[i][j-1] + dp_table[i][j];
+            }
+            else {
+                minPath[i][j] = (minPath[i][j-1]>minPath[i-1][j] ? minPath[i-1][j]: minPath[i][j-1]) + dp_table[i][j];
+            }
+        }
+    }
+    return minPath[row-1][col-1];
+}
+
+int main() {
+    int row, col;
+    cout << "Enter number of rows: ";
+    scanf("%d",&row);
+    cout << "Enter number of columns: ";
+    scanf("%d",&col);
+
+    int dp_table[Size][Size];
+    cout << "Enter table value:\n";
+    for(int i=0; i<row; i++) {
+        for(int j=0; j<col; j++) {
+            scanf("%d", &dp_table[i][j]);
+        }
+    }
+    printf("The Minimum cost value is: %d\n", minimumPath(dp_table, row, col));
+    return 0;
+}

subset-sum-problem-dynamic-programming.cpp

@@ -0,0 +1,32 @@
+#include<bits/stdc++.h>
+using namespace std;
+int subset_sum(int set[], int size, int sum)
+{
+    int i, j, dp_table[size+1][sum+1];
+    for(i = 0; i <= size; i++){
+        for(j = 0; j <= sum; j++){
+            if(i == 0 && j == 0)
+                dp_table[i][j] = 1;
+            else if(i == 0 && j!= 0)
+                dp_table[i][j] = 0;
+            else if(set[i-1] > j)
+                dp_table[i][j] = dp_table[i-1][j];
+            else dp_table[i][j] = dp_table[i-1][j] || dp_table[i-1][j-set[i-1]];
+        }
+    }
+    return dp_table[size][sum];
+}
+
+int main()
+{
+    int set[]={2,3,4}, sum = 8, size, status;
+    size = sizeof(set)/sizeof(set[0]);
+    status = subset_sum(set, size, sum);
+    if(status == 1){
+        cout << "There exist a subset for the given set";
+    }
+    else {
+        cout << "Not subset exist for the given set";
+    }
+    return 0;
+}