🚀 02-Sep-2020

Author: sureshmangs

competitive programming/leetcode/14. Longest Common Prefix.cpp

@@ -24,7 +24,7 @@ All given inputs are in lowercase letters a-z.
 
 
 
-
+// word by word matching   O(n2)
 
 class Solution {
 public:
@@ -44,3 +44,85 @@ class Solution {
         return res;
     }
 };
+
+
+
+
+// character by character by matching O(n2)
+
+class Solution {
+public:
+
+
+    int findMinLen(vector<string> &strs){
+        int n=strs.size();
+        int minLen=INT_MAX;
+        for(int i=0;i<n;i++){
+            if(strs[i].length()<minLen) minLen=strs[i].length();
+        }
+        return minLen;
+    }
+
+    string longestCommonPrefix(vector<string>& strs) {
+        int n=strs.size();
+        if(n==0) return "";
+
+        int minLen=findMinLen(strs);
+
+        string res="";
+
+        for(int i=0;i<minLen;i++){
+            char current=strs[0][i];
+            for(int j=1;j<n;j++){
+                if(strs[j][i]!=current)
+                    return res;
+            }
+            res+=current;
+        }
+
+        return res;
+    }
+};
+
+/*
+Suppose you have the input strings as- “geeksforgeeks”, “geeks”, “geek”, “geezer”, “x”
+
+better than word by word
+*/
+
+
+
+
+
+
+// Sorting O(max* nlogn)
+
+class Solution {
+public:
+    string longestCommonPrefix(vector<string>& strs) {
+        int n=strs.size();
+        if(n == 0) return "";
+
+        if(n == 1) return strs[0];
+
+        // Sort the given array (lexiographically ascending order)
+        sort(strs.begin(), strs.end());
+
+        // Find the minimum length from first and last string
+        int minLen = min(strs[0].length(), strs[n - 1].length());
+
+        // Now the common prefix in first and
+        // last string is the longest common prefix
+        string first = strs[0], last = strs[n - 1];
+        int i = 0;
+        while (i < minLen && first[i] == last[i])
+            i++;
+
+        return first.substr(0, i);
+    }
+};
+
+
+
+
+// Other Approaches Divide and Conquer, Binary Search, Trie

competitive programming/leetcode/5. Longest Palindromic Substring.cpp

@@ -0,0 +1,77 @@
+Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.
+
+Example 1:
+
+Input: "babad"
+Output: "bab"
+Note: "aba" is also a valid answer.
+Example 2:
+
+Input: "cbbd"
+Output: "bb"
+
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    string longestPalindrome(string s) {
+        int n=s.length();
+
+        vector<vector<bool> >dp(n, vector<bool> (n, 0));
+
+        int start=0;  // start of lps
+        int maxLen=1;
+
+        // All substrings of length 1 are palindromes
+        for(int i=0;i<n;i++) dp[i][i]=true;
+
+        // check for sub-string of length 2
+        for(int i=0;i<n-1;i++){
+            if(s[i]==s[i+1]){
+                dp[i][i+1]=true;
+                start=i;
+                maxLen=2;
+            }
+        }
+
+        // Check for lengths greater than 2, k is length of substring
+        for(int k=3;k<=n;k++){
+            for(int i=0;i<n-k+1;i++){
+                int j=i+k-1;
+                if(s[i]==s[j] && dp[i+1][j-1]){
+                    dp[i][j]=true;
+                    start=i;
+                    maxLen=k;
+                }
+            }
+        }
+
+        return s.substr(start, maxLen);
+    }
+};
+
+
+/*
+dp[i][j] will be false if substring  str[i..j] is not palindrome.
+Else dp[i][j] will be true
+
+
+
+Time complexity: O(n^2).
+Auxiliary Space: O(n^2).
+*/
+
+
+
+/*
+Brute Force Approach
+The simple approach is to check each substring whether the substring is a palindrome or not
+*/

string/rabin_karp.cpp

@@ -0,0 +1,57 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+// d is the number of characters in the input alphabet
+#define d 256
+
+void rabinKarp(string pat, string txt, int q){
+	int m = pat.length();
+	int n = txt.length();
+	int i, j;
+	int ph = 0; // hash value for pattern
+	int th = 0; // hash value for txt
+	int h = 1;
+
+	// The value of h would be "pow(d, m-1)%q"
+	for(i = 0; i < m - 1; i++)
+		h = (h * d) % q;
+
+	// Calculate the hash value of pattern and first window of text
+	for (i = 0; i < m; i++){
+		ph = (d * ph + pat[i]) % q;
+		th = (d * th + txt[i]) % q;
+	}
+
+	// Slide the pattern over text one by one
+	for (i = 0; i <= n - m; i++){
+		// Check the hash values of current window of text and pattern.
+		//If the hash values matches then only we check for characters on by one
+		if( ph == th ){
+			// Check for characters one by one
+			for(j = 0; j < m; j++){
+				if (txt[i+j] != pat[j])
+					break;
+			}
+
+			// if ph == th and pat[0...m-1] = txt[i, i+1, ...i+m-1]
+			if (j == m)
+				cout<<"Pattern found at index "<< i<<endl;
+		}
+
+		// Calculate hash value for next window of text: removing last digit and adding next digit
+        th = (d*(th - txt[i]*h) + txt[i+m])%q;
+
+        // We might get negative value of t, converting it to positive
+        if(th < 0)
+            th = th + q;
+	}
+}
+
+
+int main(){
+	string txt = "THIS TEXT IS A RANDOM TEXT";
+	string pat = "TEXT";
+	int q = 101; // A prime number
+	rabinKarp(pat, txt, q);
+	return 0;
+}

string/z_algorithm_string_matching.cpp

@@ -0,0 +1,65 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+void z_algo(string str, int Z[]){
+	int n = str.length();
+	int L, R, idx;
+
+	// [L,R] make a window which matches with prefix of s
+	L = R = 0;
+	for(int i = 1; i < n; ++i){
+		// if i>R nothing matches so we will calculate Z[i] using naive way.
+		if(i > R){
+			L = R = i;
+
+			// R-L = 0 in starting, so it will start checking from 0'th index.
+			// For example, for "ababab" and i = 1, the value of R
+			// remains 0 and Z[i] becomes 0.
+			//For string "aaaaaa" and i = 1, Z[i] and R become 5
+			while (R<n && str[R-L] == str[R])
+				R++;
+			Z[i] = R-L;
+			R--;
+		}
+		else {
+			// idx = i-L so idx corresponds to number which matches in [L,R] interval
+			idx = i-L;
+
+			// if Z[idx] is less than remaining interval
+			// then Z[i] will be equal to Z[idx].
+			// For example, str = "ababab", i = 3, R = 5
+			// and L = 2
+			if (i+Z[idx] <= R)
+				Z[i] = Z[idx];
+
+			// For example str = "aaaaaa" and i = 2, R is 5, L is 0
+			else
+			{
+				// else start from R and check manually
+				L = i;
+				while (R<n && str[R-L] == str[R])
+					R++;
+				Z[i] = R-L;
+				R--;
+			}
+		}
+	}
+}
+
+
+int main(){
+	string text = "GEEKS FOR GEEKS";
+	string pattern = "GEEK";
+
+	string str = pattern + "$" + text;
+	int n = str.length();
+
+	int Z[n];   // z array
+	z_algo(str, Z); // construct z array
+
+	for(int i = 0; i < n; ++i){
+		if (Z[i] == pattern.length())
+			cout<<"Pattern found at index "<< i - pattern.length() - 1 << endl;
+	}
+	return 0;
+}