Added KMP algorithm implementations in Rust and C#

Other Algorithms/KMP/KMP.cs

@@ -0,0 +1,41 @@
+using System;
+
+class KMP {
+    static int[] BuildLPS(string pattern) {
+        int m = pattern.Length;
+        int[] lps = new int[m];
+        int j = 0;
+        for (int i = 1; i < m; i++) {
+            while (j > 0 && pattern[i] != pattern[j])
+                j = lps[j - 1];
+            if (pattern[i] == pattern[j]) {
+                j++;
+                lps[i] = j;
+            }
+        }
+        return lps;
+    }
+
+    static int KMPSearch(string text, string pattern) {
+        int n = text.Length, m = pattern.Length;
+        if (m == 0) return 0;
+        int[] lps = BuildLPS(pattern);
+        int j = 0;
+        for (int i = 0; i < n; i++) {
+            while (j > 0 && text[i] != pattern[j])
+                j = lps[j - 1];
+            if (text[i] == pattern[j])
+                j++;
+            if (j == m)
+                return i - m + 1;
+        }
+        return -1;
+    }
+
+    static void Main() {
+        string text = "ABABDABACDABABCABAB";
+        string pattern = "ABABCABAB";
+        int result = KMPSearch(text, pattern);
+        Console.WriteLine($"Found at index: {result}");
+    }
+}

Other Algorithms/KMP/KMP.rs

@@ -0,0 +1,47 @@
+fn build_lps(pattern: &str) -> Vec<usize> {
+    let m = pattern.len();
+    let mut lps = vec![0; m];
+    let mut j = 0;
+    let chars: Vec<char> = pattern.chars().collect();
+    for i in 1..m {
+        while j > 0 && chars[i] != chars[j] {
+            j = lps[j - 1];
+        }
+        if chars[i] == chars[j] {
+            j += 1;
+            lps[i] = j;
+        }
+    }
+    lps
+}
+
+fn kmp_search(text: &str, pattern: &str) -> Option<usize> {
+    let n = text.len();
+    let m = pattern.len();
+    if m == 0 { return Some(0); }
+    let lps = build_lps(pattern);
+    let tchars: Vec<char> = text.chars().collect();
+    let pchars: Vec<char> = pattern.chars().collect();
+    let mut j = 0;
+    for i in 0..n {
+        while j > 0 && tchars[i] != pchars[j] {
+            j = lps[j - 1];
+        }
+        if tchars[i] == pchars[j] {
+            j += 1;
+        }
+        if j == m {
+            return Some(i - m + 1);
+        }
+    }
+    None
+}
+
+fn main() {
+    let text = "ABABDABACDABABCABAB";
+    let pattern = "ABABCABAB";
+    match kmp_search(text, pattern) {
+        Some(idx) => println!("Found at index: {}", idx),
+        None => println!("Not found"),
+    }
+}