Merge branch 'smv1999:master' into master

Author: simranquirky

2D Arrays/Strassen's_Algo.c

@@ -0,0 +1,75 @@
+// Problem Description: Strassens Algorithm in C Language for Matrix Multiplication
+#include<stdio.h>
+int main(){
+  int mat1[2][2], mat2[2][2], mat3[2][2], i, j;
+  int a, b, c, d , e, f, g;
+ 
+  printf("Enter the elements of first matrix:\n"); //Input elements for matrix 1
+  for(i = 0;i < 2; i++)
+  {
+      for(j = 0;j < 2; j++)
+      {
+           scanf("%d", &mat1[i][j]);
+      }
+  }
+ 
+  printf("Enter the elements of second matrix:\n"); // Input elements for matrix 2
+  for(i = 0; i < 2; i++)
+  {
+      for(j = 0;j < 2; j++)
+      {
+           scanf("%d", &mat2[i][j]);
+      }
+  }
+  //Displaying
+  printf("The Matrix 1:\n"); //Displaying matrix 1 elements
+  for(i = 0; i < 2; i++)
+  {
+      for(j = 0; j < 2; j++)
+      {
+           printf("%d\t", mat1[i][j]);
+      }
+      printf("\n");
+  }
+ 
+  printf("The Matrix 2:\n"); //Displayimg matrix 2 elements
+  for(i = 0;i < 2; i++)
+  {
+      for(j = 0;j < 2; j++)
+      {
+           printf("%d \t", mat2[i][j]);
+      }
+      printf("\n");
+  }
+
+ //reduced eight times Time Complexity  to Seven Times i.e T(N) = 7T(N/2) +  O(N^2)
+ 
+ // Compexity: before O(n^3) when used Standard Matrix Multiplication , now :O(n^2.808) when used Strassen's Algorithm
+ 
+ //Now we can calculate the product of mat1[i][j] and mat2[i][j] with the following formulas:
+  a= (mat1[0][0] + mat1[1][1]) * (mat2[0][0] + mat2[1][1]);  
+  b= (mat1[1][0] + mat1[1][1]) * mat2[0][0];
+  c= mat1[0][0] * (mat2[0][1] - mat2[1][1]);
+  d= mat1[1][1] * (mat2[1][0] - mat2[0][0]);
+  e= (mat1[0][0] + mat1[0][1]) * mat2[1][1];
+  f= (mat1[1][0] - mat1[0][0]) * (mat2[0][0]+mat2[0][1]);
+  g= (mat1[0][1] - mat1[1][1]) * (mat2[1][0]+mat2[1][1]);
+ //Now with a,b,c,d,e,f,g which are the submatrices of size N/2*N/2
+ 
+ //Calculate the elements of matrix 3, The resultant matrix mat3[i][j]
+  mat3[0][0] = a + d- e + g;
+  mat3[0][1] = c + e;
+  mat3[1][0] = b + d;
+  mat3[1][1] = a - b + c + f;
+ 
+   printf("Strassen's algorithm : Matrix Multiplication\n"); //Resultant matrix after applying Strassen's Algo
+   for(i = 0; i < 2 ; i++)
+   {
+      for(j = 0;j < 2; j++)
+      {
+           printf("%d\t", mat3[i][j]); //displaying resultant matrix
+      }
+      printf("\n");
+   }
+   return 0;
+}

DSA 450 GFG/LongestPalindromicSubstring.py

@@ -0,0 +1,39 @@
+#https://leetcode.com/problems/longest-palindromic-substring/
+
+class Solution(object):
+    def longestPalindrome(self, s):
+        """
+        :type s: str
+        :rtype: str
+        """
+        
+        # result to store palindrome
+        res = ""
+
+        for i in range(len(s)):
+
+            # for odd len strings
+            # Eg : "racecar"
+            tmp = self.helper(i, i, s)
+            if len(res) < len(tmp):
+                res = tmp
+
+            # for even len strings
+            # Eg: "aaaabbaa"
+            tmp = self.helper(i, i + 1, s)
+            if len(res) < len(tmp):
+                res = tmp
+
+
+        return res
+
+    def helper(self, l, r, s):
+    # Helper function to check if the left pointer and right pointer are equal 
+    # if inbound and palindrome, move left left and right right
+        
+        while (l >= 0 and r < len(s) and s[l] == s[r]):
+            l -= 1
+            r += 1
+
+ 
+        return s[l + 1: r]

DSA 450 GFG/merge_without_extra_space.cpp

@@ -0,0 +1,124 @@
+//Link to the Problem:
+//https://practice.geeksforgeeks.org/problems/merge-two-sorted-arrays-1587115620/1
+ 
+//Sample Test Case
+ 
+/*
+ 
+Input: 
+n = 4, arr1[] = [1 3 5 7] 
+m = 5, arr2[] = [0 2 6 8 9]
+ 
+ 
+Output: 
+arr1[] = [0 1 2 3]
+arr2[] = [5 6 7 8 9]
+ 
+ 
+we start from end of first array and start of second array
+i.e i points to index 3 of first array and j points to index 0 of second array
+ 
+i=3
+j=0
+ 
+since 7>0, we swap both of them, now array becomes
+ 
+arr1[] = [1 3 5 0] 
+arr2[] = [7 2 6 8 9]
+ 
+i=2
+j=1
+ 
+since 5>2
+ 
+arr1[] = [1 3 2 0] 
+arr2[] = [7 5 6 8 9]
+ 
+i=1
+j=2
+ 
+3 is not greater than 6, for loop breaks and we come out of the loop
+ 
+ 
+Now we sort  the arrays and get the o/p as follows:
+ 
+arr1[] = [0 1 2 3]
+arr2[] = [5 6 7 8 9]
+ 
+*/
+ 
+#include <bits/stdc++.h>
+using namespace std;
+ 
+class Solution
+{
+public:
+    void merge(int arr1[], int arr2[], int n, int m)
+    {
+ 
+        // Starting from last index of first array and first index of second arary
+        int i = n - 1;
+        int j = 0;
+ 
+        //iterating till the small array is traversed [Note that AND operator is
+        //used]
+        while (i >= 0 && j < m)
+        {
+            if (arr1[i] > arr2[j])
+            {
+                swap(arr1[i], arr2[j]);
+                i--;
+                j++;
+            }
+            else
+            {
+                break;
+            }
+        }
+ 
+        //Sorting both the arrays as the order in which element occured would
+        //have changed
+        sort(arr1, arr1 + n);
+        sort(arr2, arr2 + m);
+    }
+};
+ 
+int main()
+{
+    int t;
+    cin >> t;
+    while (t--)
+    {
+ 
+        //n -> Size of first Array
+        //m -> Size of Second Array
+        //i -> Iterator
+        //arr1 -> First Array
+        //arr2 ->Second Array
+        int n, m, i;
+        cin >> n >> m;
+        int arr1[n], arr2[m];
+        for (i = 0; i < n; i++)
+        {
+            cin >> arr1[i];
+        }
+        for (i = 0; i < m; i++)
+        {
+            cin >> arr2[i];
+        }
+ 
+        //Creating an instance of class
+        Solution ob;
+        ob.merge(arr1, arr2, n, m);
+        for (i = 0; i < n; i++)
+        {
+            cout << arr1[i] << " ";
+        }
+        for (i = 0; i < m; i++)
+        {
+            cout << arr2[i] << " ";
+        }
+        cout << "\n";
+    }
+    return 0;
+}

Data Structures/Stacks/Next_Greater_Element.cpp

@@ -0,0 +1,97 @@
+/*
+Implementation of Next Greater Element problem using stack
+
+Given an array, print the Next Greater Element (NGE) for every element. 
+The Next greater Element for an element x is the first greater element on 
+the right side of x in array. Elements for which no greater element exist, 
+consider next greater element as -1.
+
+For the input array [4, 5, 2, 25}, the next greater elements for each element are as follows.
+
+Element --> NGE
+
+4 --> 5
+5 --> 25
+2 --> 25
+25 --> -1    */
+
+#include <cmath>
+#include <cstdio>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+#include <stack>
+#include <bits/stdc++.h>
+using namespace std;
+
+vector<int> NGE(vector<int> v)
+{
+    vector<int> nge(v.size());
+    stack<int> stk;
+    for(int i=0;i<v.size(); i++)
+    {
+        while(!stk.empty() && v[i] > v[stk.top()])
+		{
+            nge[stk.top()]=i;
+            stk.pop();
+        }
+        stk.push(i);
+    }
+    while(!stk.empty())
+    {
+        nge[stk.top()]=-1;
+            stk.pop();
+    }
+    return nge;
+}
+
+int main() 
+{
+    int n;
+    cin >> n;
+    vector<int> v(n);
+    
+    for(int i=0;i<n;i++)
+        cin >> v[i];
+        
+    vector<int> nge= NGE(v);
+    
+    for(int i=0; i<n; i++)
+        cout<< v[i] << " " << (nge[i]== -1 ? -1 : v[nge[i]]) << endl;
+        
+    return 0;
+}
+
+/*
+
+Test case 1:
+
+Sample Input
+
+4
+4 5 2 25
+
+Sample Output
+
+4 5
+5 25
+2 25
+25 -1
+
+Test case 2:
+
+Sample Input
+
+4
+13 7 6 12
+
+Sample Output
+
+13 -1
+7 12
+6 12
+12 -1
+
+Time Complexity: O(n)
+Space Complexity: O(n)
+*/

Data Structures/Stacks/balanced_parentheses.py

@@ -0,0 +1,28 @@
+## Python code to Check for 
+# balanced parentheses in an expression
+
+
+#Function to check parentheses
+def validparentheses(s):
+    open_brace=["{","[","("]
+    closed_brace=["}","]",")"]
+    stack=[]
+    for i in s:
+        if i in open_brace:
+            stack.append(i)
+        elif i in closed_brace:
+            p=closed_brace.index(i)
+            if len(stack)>0 and open_brace[p]==stack[len(stack)-1]:
+                stack.pop()
+            else:
+                return False
+    if(len(stack)==0): #return true if given expression is balanced
+        return True
+    else:
+        return False   #return false is not balanced
+    
+s=input("Enter the Expression to be evaluated:")
+if(validparentheses(s)):
+    print("Expression is Balanced")
+else:
+    print("Expression is Unbalanced")