From 94fce4658d46385483974d031674a767ca37fc72 Mon Sep 17 00:00:00 2001 From: Mrinal Chauhan Date: Thu, 24 Oct 2024 02:16:08 +0530 Subject: [PATCH 01/17] Z Algorithm --- .../com/thealgorithms/strings/Zalgorithm.java | 61 +++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 src/main/java/com/thealgorithms/strings/Zalgorithm.java diff --git a/src/main/java/com/thealgorithms/strings/Zalgorithm.java b/src/main/java/com/thealgorithms/strings/Zalgorithm.java new file mode 100644 index 000000000000..878a82da6670 --- /dev/null +++ b/src/main/java/com/thealgorithms/strings/Zalgorithm.java @@ -0,0 +1,61 @@ +package com.thealgorithms.strings; + +import java.util.ArrayList; +import java.util.List; + +/** + * Class to implement the Z Algorithm for pattern matching in strings. + * The Z Algorithm finds all occurrences of a pattern within a text. + */ +public final class Zalgorithm { + private Zalgorithm() { + } + + /** + * Calculates the Z array for a given string. + * + * @param s the input string + * @return the Z array where Z[i] indicates the length of the longest substring + * starting from s[i] that is also a prefix of s + */ + public static int[] calculateZ(String s) { + int n = s.length(); + int[] Z = new int[n]; + int left = 0, right = 0; + + for (int i = 1; i < n; i++) { + if (i <= right) { + Z[i] = Math.min(right - i + 1, Z[i - left]); + } + while (i + Z[i] < n && s.charAt(Z[i]) == s.charAt(i + Z[i])) { + Z[i]++; + } + if (i + Z[i] - 1 > right) { + left = i; + right = i + Z[i] - 1; + } + } + return Z; + } + + /** + * Finds all occurrences of a pattern in the text using the Z Algorithm. + * + * @param text the text in which to search for the pattern + * @param pattern the pattern to search for + * @return a list of starting indices of occurrences of the pattern in the text + */ + public static List findPatternOccurrences(String text, String pattern) { + String combined = pattern + "$" + text; + int[] Z = calculateZ(combined); + List occurrences = new ArrayList<>(); + int patternLength = pattern.length(); + + for (int i = 0; i < Z.length; i++) { + if (Z[i] == patternLength) { + occurrences.add(i - patternLength - 1); + } + } + return occurrences; + } +} From 56a96c7565c30765cc2522d69c2f8f3b69568108 Mon Sep 17 00:00:00 2001 From: Mrinal Chauhan Date: Thu, 24 Oct 2024 02:18:36 +0530 Subject: [PATCH 02/17] test: added test cases for Z Algorithm --- .../thealgorithms/strings/ZalgorithmTest.java | 60 +++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 src/test/java/com/thealgorithms/strings/ZalgorithmTest.java diff --git a/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java b/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java new file mode 100644 index 000000000000..932a3120d85b --- /dev/null +++ b/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java @@ -0,0 +1,60 @@ +package com.thealgorithms.strings; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.Arrays; +import java.util.List; +import org.junit.jupiter.api.Test; + +public class ZalgorithmTest { + /** + * Test 1: + * Input: text = "ababcababcabc", pattern = "abc" + * Output: [2, 7, 10] + * Explanation: The pattern "abc" occurs at indices 2, 7, and 10. + */ + @Test + public void testFindPatternOccurrences() { + String text = "ababcababcabc"; + String pattern = "abc"; + List expected = Arrays.asList(2, 7, 10); + + List actual = Zalgorithm.findPatternOccurrences(text, pattern); + + assertEquals(expected, actual); + } + + /** + * Test 2: + * Input: text = "abcdefg", pattern = "xyz" + * Output: [] + * Explanation: The pattern "xyz" does not occur in the text. + */ + @Test + public void testFindPatternOccurrencesNoMatch() { + String text = "abcdefg"; + String pattern = "xyz"; + List expected = Arrays.asList(); + + List actual = Zalgorithm.findPatternOccurrences(text, pattern); + + assertEquals(expected, actual); + } + + /** + * Test 3: + * Input: text = "aabbaabbaaa", pattern = "a" + * Output: [0, 3, 5, 9] + * Explanation: The pattern "a" occurs at indices 0, 3, 5, and 9. + */ + @Test + public void testFindPatternOccurrencesSingleCharacter() { + String text = "aabbaabbaaa"; + String pattern = "a"; + List expected = Arrays.asList(0, 3, 5, 9); + + List actual = Zalgorithm.findPatternOccurrences(text, pattern); + + assertEquals(expected, actual); + } +} From e528b62ad3e78003c6c01926aa26c43ab409e2b3 Mon Sep 17 00:00:00 2001 From: Mrinal Chauhan Date: Thu, 24 Oct 2024 05:01:04 +0530 Subject: [PATCH 03/17] test: added test cases for Z Algorithm --- .../thealgorithms/strings/ZalgorithmTest.java | 56 ++++++++----------- 1 file changed, 22 insertions(+), 34 deletions(-) diff --git a/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java b/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java index 932a3120d85b..40c04389e72f 100644 --- a/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java +++ b/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java @@ -7,54 +7,42 @@ import org.junit.jupiter.api.Test; public class ZalgorithmTest { + /** * Test 1: - * Input: text = "ababcababcabc", pattern = "abc" - * Output: [2, 7, 10] - * Explanation: The pattern "abc" occurs at indices 2, 7, and 10. + * Pattern: "a", Text: "aabaaabaa" + * Expected: [0, 1, 4, 5, 8] */ @Test - public void testFindPatternOccurrences() { - String text = "ababcababcabc"; - String pattern = "abc"; - List expected = Arrays.asList(2, 7, 10); - - List actual = Zalgorithm.findPatternOccurrences(text, pattern); - - assertEquals(expected, actual); + public void testFindPatternOccurrencesSingleCharacter() { + String text = "aabaaabaa"; + String pattern = "a"; + List expected = Arrays.asList(0, 1, 4, 5, 8); + assertEquals(expected, Zalgorithm.findPatternOccurrences(text, pattern)); } /** * Test 2: - * Input: text = "abcdefg", pattern = "xyz" - * Output: [] - * Explanation: The pattern "xyz" does not occur in the text. + * Pattern: "abc", Text: "ababcabcabc" + * Expected: [2, 5, 8] */ @Test - public void testFindPatternOccurrencesNoMatch() { - String text = "abcdefg"; - String pattern = "xyz"; - List expected = Arrays.asList(); - - List actual = Zalgorithm.findPatternOccurrences(text, pattern); - - assertEquals(expected, actual); + public void testFindPatternOccurrences() { + String text = "ababcabcabc"; + String pattern = "abc"; + List expected = Arrays.asList(2, 5, 8); + assertEquals(expected, Zalgorithm.findPatternOccurrences(text, pattern)); } - /** * Test 3: - * Input: text = "aabbaabbaaa", pattern = "a" - * Output: [0, 3, 5, 9] - * Explanation: The pattern "a" occurs at indices 0, 3, 5, and 9. + * Pattern: "aa", Text: "aaaaaa" + * Expected: [0, 1, 2, 3, 4] */ @Test - public void testFindPatternOccurrencesSingleCharacter() { - String text = "aabbaabbaaa"; - String pattern = "a"; - List expected = Arrays.asList(0, 3, 5, 9); - - List actual = Zalgorithm.findPatternOccurrences(text, pattern); - - assertEquals(expected, actual); + public void testFindPatternOccurrencesRepeated() { + String text = "aaaaaa"; + String pattern = "aa"; + List expected = Arrays.asList(0, 1, 2, 3, 4); + assertEquals(expected, Zalgorithm.findPatternOccurrences(text, pattern)); } } From 3c54c1dcc93610dd1bf4cd4c505dd6e18398d660 Mon Sep 17 00:00:00 2001 From: Mrinal Chauhan Date: Thu, 24 Oct 2024 05:03:00 +0530 Subject: [PATCH 04/17] feat: added new algorithm Z Algorithm --- .../com/thealgorithms/strings/Zalgorithm.java | 67 +++++++++---------- 1 file changed, 33 insertions(+), 34 deletions(-) diff --git a/src/main/java/com/thealgorithms/strings/Zalgorithm.java b/src/main/java/com/thealgorithms/strings/Zalgorithm.java index 878a82da6670..4c0fc5e20aac 100644 --- a/src/main/java/com/thealgorithms/strings/Zalgorithm.java +++ b/src/main/java/com/thealgorithms/strings/Zalgorithm.java @@ -4,58 +4,57 @@ import java.util.List; /** - * Class to implement the Z Algorithm for pattern matching in strings. - * The Z Algorithm finds all occurrences of a pattern within a text. + * Z-algorithm implementation to find all occurrences of a pattern in a text. */ public final class Zalgorithm { private Zalgorithm() { } /** - * Calculates the Z array for a given string. + * Finds the occurrences of a pattern in a text using Z-algorithm. * - * @param s the input string - * @return the Z array where Z[i] indicates the length of the longest substring - * starting from s[i] that is also a prefix of s + * @param text the input text in which we are searching the pattern + * @param pattern the pattern to search for + * @return a list of indices where the pattern occurs in the text */ - public static int[] calculateZ(String s) { - int n = s.length(); - int[] Z = new int[n]; - int left = 0, right = 0; + public static List findPatternOccurrences(String text, String pattern) { + String combined = pattern + "$" + text; + int[] zArray = calculateZ(combined); + List occurrences = new ArrayList<>(); + int patternLength = pattern.length(); - for (int i = 1; i < n; i++) { - if (i <= right) { - Z[i] = Math.min(right - i + 1, Z[i - left]); - } - while (i + Z[i] < n && s.charAt(Z[i]) == s.charAt(i + Z[i])) { - Z[i]++; - } - if (i + Z[i] - 1 > right) { - left = i; - right = i + Z[i] - 1; + for (int i = 0; i < zArray.length; i++) { + if (zArray[i] == patternLength) { + occurrences.add(i - patternLength - 1); } } - return Z; + return occurrences; } /** - * Finds all occurrences of a pattern in the text using the Z Algorithm. + * Helper method to calculate Z-array for a given string. * - * @param text the text in which to search for the pattern - * @param pattern the pattern to search for - * @return a list of starting indices of occurrences of the pattern in the text + * @param s the input string + * @return the Z-array where Z[i] is the length of the longest substring + * starting from i that is also a prefix of s */ - public static List findPatternOccurrences(String text, String pattern) { - String combined = pattern + "$" + text; - int[] Z = calculateZ(combined); - List occurrences = new ArrayList<>(); - int patternLength = pattern.length(); + private static int[] calculateZ(String s) { + int n = s.length(); + int[] z = new int[n]; + int l = 0, r = 0; - for (int i = 0; i < Z.length; i++) { - if (Z[i] == patternLength) { - occurrences.add(i - patternLength - 1); + for (int i = 1; i < n; i++) { + if (i <= r) { + z[i] = Math.min(r - i + 1, z[i - l]); + } + while (i + z[i] < n && s.charAt(z[i]) == s.charAt(i + z[i])) { + z[i]++; + } + if (i + z[i] - 1 > r) { + l = i; + r = i + z[i] - 1; } } - return occurrences; + return z; } } From f4f0a398da3937b347438fad771d65587fbe579b Mon Sep 17 00:00:00 2001 From: Mrinal Chauhan Date: Fri, 25 Oct 2024 13:15:08 +0530 Subject: [PATCH 05/17] fix: updated code to fix errors --- src/main/java/com/thealgorithms/strings/Zalgorithm.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/thealgorithms/strings/Zalgorithm.java b/src/main/java/com/thealgorithms/strings/Zalgorithm.java index 4c0fc5e20aac..ed7e16d09469 100644 --- a/src/main/java/com/thealgorithms/strings/Zalgorithm.java +++ b/src/main/java/com/thealgorithms/strings/Zalgorithm.java @@ -22,9 +22,9 @@ public static List findPatternOccurrences(String text, String pattern) int[] zArray = calculateZ(combined); List occurrences = new ArrayList<>(); int patternLength = pattern.length(); - - for (int i = 0; i < zArray.length; i++) { - if (zArray[i] == patternLength) { + //performing z algorithm + for (int i = patternLength + 1; i < zArray.length; i++) { + if (zArray[i] >= patternLength) { occurrences.add(i - patternLength - 1); } } From ecedd076262d9fb8584cc6f5e74f0b1d7f80b59c Mon Sep 17 00:00:00 2001 From: Mrinal Chauhan Date: Fri, 25 Oct 2024 13:16:48 +0530 Subject: [PATCH 06/17] fix: updated code to fix errors --- src/main/java/com/thealgorithms/strings/Zalgorithm.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/strings/Zalgorithm.java b/src/main/java/com/thealgorithms/strings/Zalgorithm.java index ed7e16d09469..8c79c0a8139e 100644 --- a/src/main/java/com/thealgorithms/strings/Zalgorithm.java +++ b/src/main/java/com/thealgorithms/strings/Zalgorithm.java @@ -22,7 +22,7 @@ public static List findPatternOccurrences(String text, String pattern) int[] zArray = calculateZ(combined); List occurrences = new ArrayList<>(); int patternLength = pattern.length(); - //performing z algorithm + // performing z algorithm for (int i = patternLength + 1; i < zArray.length; i++) { if (zArray[i] >= patternLength) { occurrences.add(i - patternLength - 1); From 704035da76ade56ce66333dfc89015d8146990e0 Mon Sep 17 00:00:00 2001 From: Mrinal Chauhan Date: Fri, 25 Oct 2024 13:21:58 +0530 Subject: [PATCH 07/17] fix: updated code to fix errors --- src/main/java/com/thealgorithms/strings/Zalgorithm.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/strings/Zalgorithm.java b/src/main/java/com/thealgorithms/strings/Zalgorithm.java index 8c79c0a8139e..8f2cbb43f20c 100644 --- a/src/main/java/com/thealgorithms/strings/Zalgorithm.java +++ b/src/main/java/com/thealgorithms/strings/Zalgorithm.java @@ -24,8 +24,9 @@ public static List findPatternOccurrences(String text, String pattern) int patternLength = pattern.length(); // performing z algorithm for (int i = patternLength + 1; i < zArray.length; i++) { - if (zArray[i] >= patternLength) { + if (zArray[i] == patternLength) { occurrences.add(i - patternLength - 1); + i += patternLength - 1; } } return occurrences; From 199b96b780006dc1d3509c8bc7de43fb7187fc29 Mon Sep 17 00:00:00 2001 From: Mrinal Chauhan Date: Fri, 25 Oct 2024 13:38:46 +0530 Subject: [PATCH 08/17] fix: updated code to fix run_infer errors --- .../java/com/thealgorithms/strings/Zalgorithm.java | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/thealgorithms/strings/Zalgorithm.java b/src/main/java/com/thealgorithms/strings/Zalgorithm.java index 8f2cbb43f20c..43bacf0a5084 100644 --- a/src/main/java/com/thealgorithms/strings/Zalgorithm.java +++ b/src/main/java/com/thealgorithms/strings/Zalgorithm.java @@ -11,7 +11,7 @@ private Zalgorithm() { } /** - * Finds the occurrences of a pattern in a text using Z-algorithm. + * Finds occurrences of a pattern in a text using Z-algorithm. * * @param text the input text in which we are searching the pattern * @param pattern the pattern to search for @@ -22,11 +22,17 @@ public static List findPatternOccurrences(String text, String pattern) int[] zArray = calculateZ(combined); List occurrences = new ArrayList<>(); int patternLength = pattern.length(); - // performing z algorithm + for (int i = patternLength + 1; i < zArray.length; i++) { if (zArray[i] == patternLength) { occurrences.add(i - patternLength - 1); - i += patternLength - 1; + + // Modification to handle single and multi-character patterns differently: + // Skip to next position for non-overlapping matches only if pattern length > 1 + if (patternLength > 1) { + i += patternLength - 1; // Skip positions for non-overlapping matches + } + // For single-character patterns, continue without skipping to capture overlaps } } return occurrences; From c0edcc57aea1d0f3f9d260651f690ba104210377 Mon Sep 17 00:00:00 2001 From: Mrinal Chauhan Date: Fri, 25 Oct 2024 16:03:29 +0530 Subject: [PATCH 09/17] fix: updated code to fix run_infer errors --- src/main/java/com/thealgorithms/strings/Zalgorithm.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/strings/Zalgorithm.java b/src/main/java/com/thealgorithms/strings/Zalgorithm.java index 43bacf0a5084..c6713ec17686 100644 --- a/src/main/java/com/thealgorithms/strings/Zalgorithm.java +++ b/src/main/java/com/thealgorithms/strings/Zalgorithm.java @@ -24,7 +24,7 @@ public static List findPatternOccurrences(String text, String pattern) int patternLength = pattern.length(); for (int i = patternLength + 1; i < zArray.length; i++) { - if (zArray[i] == patternLength) { + if (zArray[i] >= patternLength) { occurrences.add(i - patternLength - 1); // Modification to handle single and multi-character patterns differently: From 198d944a4ca47353a1b77be3a93711ea550299da Mon Sep 17 00:00:00 2001 From: Mrinal Chauhan Date: Fri, 25 Oct 2024 16:09:11 +0530 Subject: [PATCH 10/17] fix: updated code to fix run_infer errors --- src/main/java/com/thealgorithms/strings/Zalgorithm.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/strings/Zalgorithm.java b/src/main/java/com/thealgorithms/strings/Zalgorithm.java index c6713ec17686..1fbf786dcda4 100644 --- a/src/main/java/com/thealgorithms/strings/Zalgorithm.java +++ b/src/main/java/com/thealgorithms/strings/Zalgorithm.java @@ -30,7 +30,7 @@ public static List findPatternOccurrences(String text, String pattern) // Modification to handle single and multi-character patterns differently: // Skip to next position for non-overlapping matches only if pattern length > 1 if (patternLength > 1) { - i += patternLength - 1; // Skip positions for non-overlapping matches + i += patternLength - 1; } // For single-character patterns, continue without skipping to capture overlaps } From 34eeeb6ea5fa491a7082f6c3905593521633f5a9 Mon Sep 17 00:00:00 2001 From: Mrinal Chauhan Date: Sat, 26 Oct 2024 01:24:51 +0530 Subject: [PATCH 11/17] fix: updated code to fix errors --- src/main/java/com/thealgorithms/strings/Zalgorithm.java | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/src/main/java/com/thealgorithms/strings/Zalgorithm.java b/src/main/java/com/thealgorithms/strings/Zalgorithm.java index 1fbf786dcda4..8df9496f1343 100644 --- a/src/main/java/com/thealgorithms/strings/Zalgorithm.java +++ b/src/main/java/com/thealgorithms/strings/Zalgorithm.java @@ -24,15 +24,8 @@ public static List findPatternOccurrences(String text, String pattern) int patternLength = pattern.length(); for (int i = patternLength + 1; i < zArray.length; i++) { - if (zArray[i] >= patternLength) { + if (zArray[i] == patternLength) { occurrences.add(i - patternLength - 1); - - // Modification to handle single and multi-character patterns differently: - // Skip to next position for non-overlapping matches only if pattern length > 1 - if (patternLength > 1) { - i += patternLength - 1; - } - // For single-character patterns, continue without skipping to capture overlaps } } return occurrences; From 1047009119f2134df5d36fd2261d7b824911c509 Mon Sep 17 00:00:00 2001 From: Mrinal Chauhan Date: Sat, 26 Oct 2024 01:27:46 +0530 Subject: [PATCH 12/17] fix: updated code to fix errors --- src/test/java/com/thealgorithms/strings/ZalgorithmTest.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java b/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java index 40c04389e72f..26d7089c51d0 100644 --- a/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java +++ b/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java @@ -33,6 +33,7 @@ public void testFindPatternOccurrences() { List expected = Arrays.asList(2, 5, 8); assertEquals(expected, Zalgorithm.findPatternOccurrences(text, pattern)); } + /** * Test 3: * Pattern: "aa", Text: "aaaaaa" From 4c13c06aa938c4d20e710f197d371089ddf8431b Mon Sep 17 00:00:00 2001 From: Mrinal Chauhan Date: Sat, 26 Oct 2024 01:31:45 +0530 Subject: [PATCH 13/17] fix: updated code to fix errors --- src/main/java/com/thealgorithms/strings/Zalgorithm.java | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/thealgorithms/strings/Zalgorithm.java b/src/main/java/com/thealgorithms/strings/Zalgorithm.java index 8df9496f1343..ec5e5a635f4a 100644 --- a/src/main/java/com/thealgorithms/strings/Zalgorithm.java +++ b/src/main/java/com/thealgorithms/strings/Zalgorithm.java @@ -7,8 +7,7 @@ * Z-algorithm implementation to find all occurrences of a pattern in a text. */ public final class Zalgorithm { - private Zalgorithm() { - } + private Zalgorithm() {} /** * Finds occurrences of a pattern in a text using Z-algorithm. @@ -24,7 +23,7 @@ public static List findPatternOccurrences(String text, String pattern) int patternLength = pattern.length(); for (int i = patternLength + 1; i < zArray.length; i++) { - if (zArray[i] == patternLength) { + if (zArray[i] >= patternLength) { occurrences.add(i - patternLength - 1); } } From f5aea145340a1e384a8024661d8e4d4e04c14640 Mon Sep 17 00:00:00 2001 From: Mrinal Chauhan Date: Sat, 26 Oct 2024 01:31:59 +0530 Subject: [PATCH 14/17] fix: updated code to fix errors --- src/test/java/com/thealgorithms/strings/ZalgorithmTest.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java b/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java index 26d7089c51d0..99cdb5fe3c0c 100644 --- a/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java +++ b/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java @@ -1,7 +1,6 @@ package com.thealgorithms.strings; import static org.junit.jupiter.api.Assertions.assertEquals; - import java.util.Arrays; import java.util.List; import org.junit.jupiter.api.Test; @@ -33,7 +32,7 @@ public void testFindPatternOccurrences() { List expected = Arrays.asList(2, 5, 8); assertEquals(expected, Zalgorithm.findPatternOccurrences(text, pattern)); } - + /** * Test 3: * Pattern: "aa", Text: "aaaaaa" From 047c1da1aaed9afdb2dae974f5bf2a0affc5ba1f Mon Sep 17 00:00:00 2001 From: Mrinal Chauhan Date: Sat, 26 Oct 2024 01:34:07 +0530 Subject: [PATCH 15/17] fix: updated code to fix errors --- src/main/java/com/thealgorithms/strings/Zalgorithm.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/strings/Zalgorithm.java b/src/main/java/com/thealgorithms/strings/Zalgorithm.java index ec5e5a635f4a..c43f20cf3add 100644 --- a/src/main/java/com/thealgorithms/strings/Zalgorithm.java +++ b/src/main/java/com/thealgorithms/strings/Zalgorithm.java @@ -7,7 +7,8 @@ * Z-algorithm implementation to find all occurrences of a pattern in a text. */ public final class Zalgorithm { - private Zalgorithm() {} + private Zalgorithm() { + } /** * Finds occurrences of a pattern in a text using Z-algorithm. From 7bee21b028ae5721ad135651472de19254281dbc Mon Sep 17 00:00:00 2001 From: Mrinal Chauhan Date: Sat, 26 Oct 2024 01:39:42 +0530 Subject: [PATCH 16/17] fix: updated code to fix errors --- src/test/java/com/thealgorithms/strings/ZalgorithmTest.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java b/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java index 99cdb5fe3c0c..f92a6b43e211 100644 --- a/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java +++ b/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java @@ -1,6 +1,7 @@ package com.thealgorithms.strings; import static org.junit.jupiter.api.Assertions.assertEquals; + import java.util.Arrays; import java.util.List; import org.junit.jupiter.api.Test; From d4c9664260f153af11be9378d5b61975c69f565c Mon Sep 17 00:00:00 2001 From: Mrinal Chauhan Date: Sat, 26 Oct 2024 01:43:15 +0530 Subject: [PATCH 17/17] fix: updated code to fix errors --- .../com/thealgorithms/strings/ZalgorithmTest.java | 15 +-------------- 1 file changed, 1 insertion(+), 14 deletions(-) diff --git a/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java b/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java index f92a6b43e211..3f03a4a7ffc4 100644 --- a/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java +++ b/src/test/java/com/thealgorithms/strings/ZalgorithmTest.java @@ -10,19 +10,6 @@ public class ZalgorithmTest { /** * Test 1: - * Pattern: "a", Text: "aabaaabaa" - * Expected: [0, 1, 4, 5, 8] - */ - @Test - public void testFindPatternOccurrencesSingleCharacter() { - String text = "aabaaabaa"; - String pattern = "a"; - List expected = Arrays.asList(0, 1, 4, 5, 8); - assertEquals(expected, Zalgorithm.findPatternOccurrences(text, pattern)); - } - - /** - * Test 2: * Pattern: "abc", Text: "ababcabcabc" * Expected: [2, 5, 8] */ @@ -35,7 +22,7 @@ public void testFindPatternOccurrences() { } /** - * Test 3: + * Test 2: * Pattern: "aa", Text: "aaaaaa" * Expected: [0, 1, 2, 3, 4] */