Merge pull request Dijkstra-Edu#95 from AmanDeol7/aman/sol-3

Solution #1392 - Aman Deol - 02/09/2025

Author: JRS296

Arrays & Strings/#1392 - Longest Happy Prefix - Hard/Explanation.md

@@ -0,0 +1,92 @@
+# Longest Happy Prefix
+
+**Difficulty:** Hard  
+**Category:** String, KMP, Rolling Hash  
+**Leetcode Link:** [Problem Link](https://leetcode.com/problems/longest-happy-prefix/)  
+
+---
+
+## 📝 Introduction
+
+We are given a string `s`.  
+We need to find the **longest prefix** which is also a **suffix** (excluding the entire string itself).  
+This is sometimes referred to as a **happy prefix**.  
+
+Example:
+s = "level"
+Happy prefix = "l" (prefix "l", suffix "l")
+
+
+If no happy prefix exists, return the empty string `""`.
+
+---
+
+## 💡 Approach & Key Insights
+
+1. **Brute Force (Naive)**  
+   - Try all prefix lengths and check if equal to suffix.  
+   - Very slow: O(n²).
+
+2. **KMP Prefix Function (Optimal)**  
+   - Use the prefix-function (a.k.a. failure function in KMP).  
+   - It gives us the longest border of the string (prefix = suffix).  
+   - Time: O(n), Space: O(n).
+
+3. **Rolling Hash (Alternative)**  
+   - Maintain hash of prefix and suffix.  
+   - Compare hashes for each possible length.  
+   - Time: O(n), Space: O(1).
+
+👉 In interviews, **KMP prefix-function** is the cleanest and most accepted solution.
+
+---
+
+## 🛠️ Breakdown of Approaches
+
+### 1️⃣ Brute Force
+- Generate all prefixes and check with suffix.
+- Time: O(n²).
+
+### 2️⃣ KMP Prefix Function
+- Compute LPS array (`lps[i]` = longest border for substring `s[0..i]`).
+- Final value gives the happy prefix length.
+- Time: O(n).
+
+### 3️⃣ Rolling Hash
+- Compute rolling hash from left and right.
+- Compare prefix-hash and suffix-hash at each step.
+- Time: O(n).
+
+---
+
+## 📊 Complexity Analysis
+
+| Approach        | Time Complexity | Space Complexity |
+|-----------------|-----------------|------------------|
+| Brute Force     | O(n²)           | O(1)             |
+| KMP (Optimal)   | O(n)            | O(n)             |
+| Rolling Hash    | O(n)            | O(1)             |
+
+---
+
+## 📌 Example Walkthroughs
+
+Example 1:
+Input: s = "level"
+Prefixes: ["l", "le", "lev", "leve"]
+Suffixes: ["evel", "vel", "el", "l"]
+Longest common = "l"
+
+Output: "l"
+
+Example 2:
+
+---
+
+## 🔗 Additional Resources
+- [Prefix Function Explanation (CP-Algorithms)](https://cp-algorithms.com/string/prefix-function.html)  
+
+---
+
+Author: Aman Deol  
+Date: 02/09/2025  

Arrays & Strings/#1392 - Longest Happy Prefix - Hard/Solution.cpp

@@ -0,0 +1,49 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+// Approach 1: Brute Force
+class SolutionBruteForce {
+public:
+    string longestPrefix(string s) {
+        int n = s.size();
+        for (int i = n-1; i > 0; i--) {
+            if (s.substr(0,i) == s.substr(n-i,i)) {
+                return s.substr(0,i);
+            }
+        }
+        return "";
+    }
+};
+
+// Approach 2: KMP Prefix Function
+class SolutionKMP {
+public:
+    string longestPrefix(string s) {
+        int n = s.size();
+        vector<int> lps(n, 0);
+        int j = 0;
+        for (int i = 1; i < n; i++) {
+            while (j > 0 && s[i] != s[j]) j = lps[j-1];
+            if (s[i] == s[j]) lps[i] = ++j;
+        }
+        return s.substr(0, lps[n-1]);
+    }
+};
+
+// Approach 3: Rolling Hash
+class SolutionRollingHash {
+public:
+    string longestPrefix(string s) {
+        int n = s.size();
+        long long mod = 1e9+7, base = 31;
+        long long prefix = 0, suffix = 0, power = 1;
+        int res = 0;
+        for (int i = 0; i < n-1; i++) {
+            prefix = (prefix * base + (s[i]-'a'+1)) % mod;
+            suffix = (suffix + (s[n-1-i]-'a'+1) * power) % mod;
+            power = (power * base) % mod;
+            if (prefix == suffix) res = i+1;
+        }
+        return s.substr(0, res);
+    }
+};

Arrays & Strings/#1392 - Longest Happy Prefix - Hard/Solution.java

@@ -0,0 +1,47 @@
+// Approach 1: Brute Force
+class SolutionBruteForce {
+    public String longestPrefix(String s) {
+        int n = s.length();
+        for (int i = n-1; i > 0; i--) {
+            if (s.substring(0,i).equals(s.substring(n-i))) {
+                return s.substring(0,i);
+            }
+        }
+        return "";
+    }
+}
+
+// Approach 2: KMP Prefix Function
+class SolutionKMP {
+    public String longestPrefix(String s) {
+        int n = s.length();
+        int[] lps = new int[n];
+        int j = 0;
+        for (int i = 1; i < n; i++) {
+            while (j > 0 && s.charAt(i) != s.charAt(j)) {
+                j = lps[j-1];
+            }
+            if (s.charAt(i) == s.charAt(j)) {
+                lps[i] = ++j;
+            }
+        }
+        return s.substring(0, lps[n-1]);
+    }
+}
+
+// Approach 3: Rolling Hash
+class SolutionRollingHash {
+    public String longestPrefix(String s) {
+        int n = s.length();
+        long mod = 1000000007, base = 31;
+        long prefix = 0, suffix = 0, power = 1;
+        int res = 0;
+        for (int i = 0; i < n-1; i++) {
+            prefix = (prefix * base + (s.charAt(i)-'a'+1)) % mod;
+            suffix = (suffix + (s.charAt(n-1-i)-'a'+1) * power) % mod;
+            power = (power * base) % mod;
+            if (prefix == suffix) res = i+1;
+        }
+        return s.substring(0, res);
+    }
+}

Arrays & Strings/#1392 - Longest Happy Prefix - Hard/Solution.py

@@ -0,0 +1,39 @@
+# Approach 1: Brute Force
+class SolutionBruteForce:
+    def longestPrefix(self, s: str) -> str:
+        for i in range(len(s)-1, 0, -1):
+            if s[:i] == s[-i:]:
+                return s[:i]
+        return ""
+
+
+# Approach 2: KMP Prefix Function
+class SolutionKMP:
+    def longestPrefix(self, s: str) -> str:
+        n = len(s)
+        lps = [0] * n
+        j = 0
+        for i in range(1, n):
+            while j > 0 and s[i] != s[j]:
+                j = lps[j-1]
+            if s[i] == s[j]:
+                j += 1
+                lps[i] = j
+        return s[:lps[-1]]
+
+
+# Approach 3: Rolling Hash
+class SolutionRollingHash:
+    def longestPrefix(self, s: str) -> str:
+        n = len(s)
+        mod, base = 10**9 + 7, 31
+        prefix_hash, suffix_hash = 0, 0
+        power = 1
+        res = 0
+        for i in range(n-1):
+            prefix_hash = (prefix_hash * base + ord(s[i]) - ord('a') + 1) % mod
+            suffix_hash = (suffix_hash + (ord(s[n-1-i]) - ord('a') + 1) * power) % mod
+            power = (power * base) % mod
+            if prefix_hash == suffix_hash:
+                res = i+1
+        return s[:res]