Add z-block substring search algorithm (TheAlgorithms#360)

Co-authored-by: Kalkwst <[email protected]>

Author: damiansikora85

Algorithms.Tests/Strings/ZblockSubstringSearchTest.cs

@@ -0,0 +1,23 @@
+using Algorithms.Strings;
+using NUnit.Framework;
+
+namespace Algorithms.Tests.Strings
+{
+    public class ZblockSubstringSearchTest
+    {
+        [TestCase("abc", "abcdef", 1)]
+        [TestCase("xxx", "abxxxcdexxxf", 2)]
+        [TestCase("aa", "waapaaxcdaalaabb", 4)]
+        [TestCase("ABC", "ABAAABCDBBABCDDEBCABC", 3)]
+        [TestCase("xxx", "abcdefghij", 0)]
+        [TestCase("aab", "caabxaaaz", 1)]
+        [TestCase("abc", "xababaxbabcdabx", 1)]
+        [TestCase("GEEK", "GEEKS FOR GEEKS", 2)]
+        [TestCase("ground", "Hello, playground!", 1)]
+        public void Test(string pattern, string text, int expectedOccurences)
+        {
+            var occurencesFound = ZblockSubstringSearch.FindSubstring(pattern, text);
+            Assert.AreEqual(expectedOccurences, occurencesFound);
+        }
+    }
+}

Algorithms/Strings/ZblockSubstringSearch.cs

@@ -0,0 +1,69 @@
+namespace Algorithms.Strings
+{
+    /// <summary>Implementation Z-block substring search.
+    /// </summary>
+    public static class ZblockSubstringSearch
+    {
+        /// <summary>
+        ///     This algorithm finds all occurrences of a pattern in a text in linear time - O(m+n).
+        /// </summary>
+        public static int FindSubstring(string pattern, string text)
+        {
+            var concatStr = $"{pattern}${text}";
+            var patternLength = pattern.Length;
+            var n = concatStr.Length;
+            var zArray = new int[n];
+
+            var left = 0;
+            var right = 0;
+
+            for(var i = 1; i < n; i++)
+            {
+                if(i > right)
+                {
+                    left = i;
+                    right = ComputeNewRightValue(concatStr, n, left, i);
+
+                    zArray[i] = right - left;
+                    right--;
+                }
+                else
+                {
+                    var k = i - left;
+                    if (zArray[k] < (right - i + 1))
+                    {
+                        zArray[i] = zArray[k];
+                    }
+                    else
+                    {
+                        left = i;
+                        right = ComputeNewRightValue(concatStr, n, left, right);
+                        zArray[i] = right - left;
+                        right--;
+                    }
+                }
+            }
+
+            var found = 0;
+            foreach(var z_value in zArray)
+            {
+                if(z_value == patternLength)
+                {
+                    found++;
+                }
+            }
+
+            return found;
+        }
+
+        private static int ComputeNewRightValue(string concatStr, int n, int left, int right)
+        {
+            while (right < n && concatStr[right - left].Equals(concatStr[right]))
+            {
+                right++;
+            }
+
+            return right;
+        }
+    }
+}

README.md

@@ -172,6 +172,7 @@ find more than one implementation for the same objective but using different alg
     * [Hamming Distance](./Algorithms/Strings/HammingDistance.cs)
     * [Jaro Similarity](./Algorithms/Strings/JaroSimilarity.cs)
     * [Jaro-Winkler Distance](./Algorithms/Strings/JaroWinklerDistance.cs)
+    * [Z-block substring search](./Algorithms/Strings/ZblockSubstringSearch.cs)
   * [Other](./Algorithms/Other)
     * [Fermat Prime Checker](./Algorithms/Other/FermatPrimeChecker.cs)
     * [Sieve of Eratosthenes](./Algorithms/Other/SieveOfEratosthenes.cs)