From 7d13207ea813fb5048125beeeb354b6f500e40f3 Mon Sep 17 00:00:00 2001 From: Samuel Facchinello Date: Wed, 12 Jun 2024 15:12:43 +0200 Subject: [PATCH 01/12] refactor --- .../others/StringMatchFiniteAutomata.java | 118 ++++++++++++------ 1 file changed, 78 insertions(+), 40 deletions(-) diff --git a/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java b/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java index 22979e59b555..9ff0d8c297a6 100644 --- a/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java +++ b/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java @@ -1,80 +1,118 @@ package com.thealgorithms.others; -/** - * @author Prateek Kumar Oraon (https://github.com/prateekKrOraon) - */ import java.util.Scanner; +import java.util.Set; +import java.util.TreeSet; -// An implementation of string matching using finite automata +/** + * A class to perform string matching using finite automata. + * + * @author Prateek Kumar Oraon + */ public final class StringMatchFiniteAutomata { + + // Constants + private static final int CHARS = 256; // Total number of characters in the input alphabet + + // Finite automata table + private static int[][] finiteAutomata; + + // Private constructor to prevent instantiation private StringMatchFiniteAutomata() { } - public static final int CHARS = 256; - public static int[][] fa; - public static Scanner scanner = null; - public static void main(String[] args) { - scanner = new Scanner(System.in); - System.out.println("Enter String"); - String text = scanner.nextLine(); - System.out.println("Enter pattern"); - String pat = scanner.nextLine(); + // Scanner instance for user input + try (Scanner scanner = new Scanner(System.in);) { + + System.out.println("Enter text:"); + String text = scanner.nextLine(); - searchPat(text, pat); + System.out.println("Enter pattern:"); + String pattern = scanner.nextLine(); - scanner.close(); + Set indexFound = searchPattern(text, pattern); + indexFound.forEach(System.out::println); + } } - public static void searchPat(String text, String pat) { - int m = pat.length(); - int n = text.length(); + /** + * Searches for the pattern in the given text using finite automata. + * + * @param text The text to search within. + * @param pattern The pattern to search for. + */ + public static Set searchPattern(String text, String pattern) { + Set indexFound = new TreeSet<>(); + int patternLength = pattern.length(); + int textLength = text.length(); + + // Initialize finite automata table + finiteAutomata = new int[patternLength + 1][CHARS]; - fa = new int[m + 1][CHARS]; + // Preprocess the pattern to create the finite automata table + computeFiniteAutomata(pattern, patternLength); - computeFA(pat, m, fa); + int state = 0; // Initial state - int state = 0; - for (int i = 0; i < n; i++) { - state = fa[state][text.charAt(i)]; + // Process the text over the finite automata + for (int i = 0; i < textLength; i++) { + state = finiteAutomata[state][text.charAt(i)]; - if (state == m) { - System.out.println("Pattern found at index " + (i - m + 1)); + if (state == patternLength) { + indexFound.add((i - patternLength + 1)); } } + return indexFound; } - // Computes finite automata for the pattern - public static void computeFA(String pat, int m, int[][] fa) { - for (int state = 0; state <= m; ++state) { + /** + * Computes the finite automata table for the given pattern. + * + * @param pattern The pattern to preprocess. + * @param patternLength The length of the pattern. + */ + private static void computeFiniteAutomata(String pattern, int patternLength) { + for (int state = 0; state <= patternLength; ++state) { for (int x = 0; x < CHARS; ++x) { - fa[state][x] = getNextState(pat, m, state, x); + finiteAutomata[state][x] = getNextState(pattern, patternLength, state, x); } } } - public static int getNextState(String pat, int m, int state, int x) { - // if current state is less than length of pattern - // and input character of pattern matches the character in the alphabet - // then automata goes to next state - if (state < m && x == pat.charAt(state)) { + /** + * Gets the next state for the finite automata. + * + * @param pattern The pattern being matched. + * @param patternLength The length of the pattern. + * @param state The current state. + * @param x The current character from the input alphabet. + * @return The next state. + */ + private static int getNextState(String pattern, int patternLength, int state, int x) { + // If the current state is less than the length of the pattern + // and the character matches the pattern character, go to the next state + if (state < patternLength && x == pattern.charAt(state)) { return state + 1; } + // Check for the highest prefix which is also a suffix for (int ns = state; ns > 0; ns--) { - if (pat.charAt(ns - 1) == x) { + if (pattern.charAt(ns - 1) == x) { + boolean match = true; for (int i = 0; i < ns - 1; i++) { - if (pat.charAt(i) != pat.charAt(state - ns + i + 1)) { + if (pattern.charAt(i) != pattern.charAt(state - ns + i + 1)) { + match = false; break; } - - if (i == ns - 1) { - return ns; - } + } + if (match) { + return ns; } } } + // If no prefix which is also a suffix is found, return 0 return 0; } } From 9505edbe1ada966e066fb34197f8f5fdd3e87792 Mon Sep 17 00:00:00 2001 From: Samuel Facchinello Date: Wed, 12 Jun 2024 15:12:49 +0200 Subject: [PATCH 02/12] add test --- .../others/StringMatchFiniteAutomataTest.java | 31 +++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 src/test/java/com/thealgorithms/others/StringMatchFiniteAutomataTest.java diff --git a/src/test/java/com/thealgorithms/others/StringMatchFiniteAutomataTest.java b/src/test/java/com/thealgorithms/others/StringMatchFiniteAutomataTest.java new file mode 100644 index 000000000000..0469fe3bb566 --- /dev/null +++ b/src/test/java/com/thealgorithms/others/StringMatchFiniteAutomataTest.java @@ -0,0 +1,31 @@ +package com.thealgorithms.others; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.Set; +import java.util.stream.Stream; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +class StringMatchFiniteAutomataTest { + + @ParameterizedTest + @MethodSource("provideTestCases") + void searchPattern(String text, String pattern, Set expectedOutput) { + assertEquals(expectedOutput, StringMatchFiniteAutomata.searchPattern(text, pattern)); + } + + private static Stream provideTestCases() { + return Stream.of( + Arguments.of("abcbcabc", "abc", Set.of(0, 5)), // + Arguments.of("", "abc", Set.of()), // + Arguments.of("abcdefg", "xyz", Set.of()), // + Arguments.of("abcde", "", Set.of(1, 2, 3, 4, 5)), // + Arguments.of("abcabcabc", "abc", Set.of(0, 3, 6)), // + Arguments.of("abcabcabc", "abcabcabc", Set.of(0)), // + Arguments.of("aaabbbaaa", "aaa", Set.of(0, 6)), // + Arguments.of("abcdefg", "efg", Set.of(4))// + ); + } +} \ No newline at end of file From 4a8eff66654a79d5d806a53aea2f19234689f66b Mon Sep 17 00:00:00 2001 From: Samuel Facchinello Date: Wed, 12 Jun 2024 15:17:01 +0200 Subject: [PATCH 03/12] fix clang --- .../others/StringMatchFiniteAutomataTest.java | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/src/test/java/com/thealgorithms/others/StringMatchFiniteAutomataTest.java b/src/test/java/com/thealgorithms/others/StringMatchFiniteAutomataTest.java index 0469fe3bb566..ef60c9ae4a2d 100644 --- a/src/test/java/com/thealgorithms/others/StringMatchFiniteAutomataTest.java +++ b/src/test/java/com/thealgorithms/others/StringMatchFiniteAutomataTest.java @@ -17,15 +17,14 @@ void searchPattern(String text, String pattern, Set expectedOutput) { } private static Stream provideTestCases() { - return Stream.of( - Arguments.of("abcbcabc", "abc", Set.of(0, 5)), // - Arguments.of("", "abc", Set.of()), // - Arguments.of("abcdefg", "xyz", Set.of()), // - Arguments.of("abcde", "", Set.of(1, 2, 3, 4, 5)), // - Arguments.of("abcabcabc", "abc", Set.of(0, 3, 6)), // - Arguments.of("abcabcabc", "abcabcabc", Set.of(0)), // - Arguments.of("aaabbbaaa", "aaa", Set.of(0, 6)), // - Arguments.of("abcdefg", "efg", Set.of(4))// + return Stream.of(Arguments.of("abcbcabc", "abc", Set.of(0, 5)), // + Arguments.of("", "abc", Set.of()), // + Arguments.of("abcdefg", "xyz", Set.of()), // + Arguments.of("abcde", "", Set.of(1, 2, 3, 4, 5)), // + Arguments.of("abcabcabc", "abc", Set.of(0, 3, 6)), // + Arguments.of("abcabcabc", "abcabcabc", Set.of(0)), // + Arguments.of("aaabbbaaa", "aaa", Set.of(0, 6)), // + Arguments.of("abcdefg", "efg", Set.of(4)) // ); } -} \ No newline at end of file +} From 6f9c5df0988a3aac6b3eb1e983ab9268cd9451c1 Mon Sep 17 00:00:00 2001 From: Samuel Facchinello Date: Wed, 12 Jun 2024 15:22:28 +0200 Subject: [PATCH 04/12] fix pmd --- .../com/thealgorithms/others/StringMatchFiniteAutomata.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java b/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java index 9ff0d8c297a6..59ae238c55cb 100644 --- a/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java +++ b/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java @@ -60,7 +60,7 @@ public static Set searchPattern(String text, String pattern) { state = finiteAutomata[state][text.charAt(i)]; if (state == patternLength) { - indexFound.add((i - patternLength + 1)); + indexFound.add(i - patternLength + 1); } } return indexFound; From bdd4d624f8816d826f308d01c3316b2b811bd9e9 Mon Sep 17 00:00:00 2001 From: Samuel Facchinello Date: Thu, 13 Jun 2024 10:30:05 +0200 Subject: [PATCH 05/12] remove main method --- .../others/StringMatchFiniteAutomata.java | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java b/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java index 59ae238c55cb..cab7b328b586 100644 --- a/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java +++ b/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java @@ -1,6 +1,5 @@ package com.thealgorithms.others; -import java.util.Scanner; import java.util.Set; import java.util.TreeSet; @@ -21,21 +20,6 @@ public final class StringMatchFiniteAutomata { private StringMatchFiniteAutomata() { } - public static void main(String[] args) { - // Scanner instance for user input - try (Scanner scanner = new Scanner(System.in);) { - - System.out.println("Enter text:"); - String text = scanner.nextLine(); - - System.out.println("Enter pattern:"); - String pattern = scanner.nextLine(); - - Set indexFound = searchPattern(text, pattern); - indexFound.forEach(System.out::println); - } - } - /** * Searches for the pattern in the given text using finite automata. * From 9fa6d680f134ee3e6f72f9a1c3f510744f6ca956 Mon Sep 17 00:00:00 2001 From: Samuel Facchinello Date: Thu, 13 Jun 2024 10:42:35 +0200 Subject: [PATCH 06/12] refactor searchPattern with private class --- .../others/StringMatchFiniteAutomata.java | 74 ++++++++++++------- 1 file changed, 49 insertions(+), 25 deletions(-) diff --git a/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java b/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java index cab7b328b586..d7e053563b1c 100644 --- a/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java +++ b/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java @@ -13,9 +13,6 @@ public final class StringMatchFiniteAutomata { // Constants private static final int CHARS = 256; // Total number of characters in the input alphabet - // Finite automata table - private static int[][] finiteAutomata; - // Private constructor to prevent instantiation private StringMatchFiniteAutomata() { } @@ -26,25 +23,16 @@ private StringMatchFiniteAutomata() { * @param text The text to search within. * @param pattern The pattern to search for. */ - public static Set searchPattern(String text, String pattern) { - Set indexFound = new TreeSet<>(); - int patternLength = pattern.length(); - int textLength = text.length(); - - // Initialize finite automata table - finiteAutomata = new int[patternLength + 1][CHARS]; - - // Preprocess the pattern to create the finite automata table - computeFiniteAutomata(pattern, patternLength); - - int state = 0; // Initial state + public static Set searchPattern(final String text, final String pattern) { + final var stateTransitionTable = computeStateTransitionTable(pattern); + FiniteAutomata finiteAutomata = new FiniteAutomata(stateTransitionTable); - // Process the text over the finite automata - for (int i = 0; i < textLength; i++) { - state = finiteAutomata[state][text.charAt(i)]; + Set indexFound = new TreeSet<>(); + for (int i = 0; i < text.length(); i++) { + finiteAutomata.consume(text.charAt(i)); - if (state == patternLength) { - indexFound.add(i - patternLength + 1); + if (finiteAutomata.getState() == pattern.length()) { + indexFound.add(i - pattern.length() + 1); } } return indexFound; @@ -53,15 +41,20 @@ public static Set searchPattern(String text, String pattern) { /** * Computes the finite automata table for the given pattern. * - * @param pattern The pattern to preprocess. - * @param patternLength The length of the pattern. + * @param pattern The pattern to preprocess. + * @return The state transition table. */ - private static void computeFiniteAutomata(String pattern, int patternLength) { + private static int[][] computeStateTransitionTable(final String pattern) { + int patternLength = pattern.length(); + int[][] stateTransitionTable = new int[patternLength + 1][CHARS]; + for (int state = 0; state <= patternLength; ++state) { for (int x = 0; x < CHARS; ++x) { - finiteAutomata[state][x] = getNextState(pattern, patternLength, state, x); + stateTransitionTable[state][x] = getNextState(pattern, patternLength, state, x); } } + + return stateTransitionTable; } /** @@ -73,7 +66,7 @@ private static void computeFiniteAutomata(String pattern, int patternLength) { * @param x The current character from the input alphabet. * @return The next state. */ - private static int getNextState(String pattern, int patternLength, int state, int x) { + private static int getNextState(final String pattern, final int patternLength, final int state, final int x) { // If the current state is less than the length of the pattern // and the character matches the pattern character, go to the next state if (state < patternLength && x == pattern.charAt(state)) { @@ -99,4 +92,35 @@ private static int getNextState(String pattern, int patternLength, int state, in // If no prefix which is also a suffix is found, return 0 return 0; } + + /** + * A class representing the finite automata for pattern matching. + */ + private static class FiniteAutomata { + private int state; + private final int[][] stateTransitionTable; + + public FiniteAutomata(int[][] stateTransitionTable) { + this.stateTransitionTable = stateTransitionTable; + this.state = 0; // Initial state + } + + /** + * Consumes an input character and transitions to the next state. + * + * @param input The input character. + */ + public void consume(final char input) { + state = stateTransitionTable[state][input]; + } + + /** + * Gets the current state of the finite automata. + * + * @return The current state. + */ + public int getState() { + return state; + } + } } From 24df2bba69cb4cb5f7070cb5c53b919691d2d283 Mon Sep 17 00:00:00 2001 From: Samuel Facchinello Date: Thu, 13 Jun 2024 11:13:24 +0200 Subject: [PATCH 07/12] fix checkstyle --- .../thealgorithms/others/StringMatchFiniteAutomata.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java b/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java index d7e053563b1c..a0b1d5fa4b1b 100644 --- a/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java +++ b/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java @@ -96,11 +96,11 @@ private static int getNextState(final String pattern, final int patternLength, f /** * A class representing the finite automata for pattern matching. */ - private static class FiniteAutomata { + private static final class FiniteAutomata { private int state; private final int[][] stateTransitionTable; - public FiniteAutomata(int[][] stateTransitionTable) { + private FiniteAutomata(int[][] stateTransitionTable) { this.stateTransitionTable = stateTransitionTable; this.state = 0; // Initial state } @@ -110,7 +110,7 @@ public FiniteAutomata(int[][] stateTransitionTable) { * * @param input The input character. */ - public void consume(final char input) { + private void consume(final char input) { state = stateTransitionTable[state][input]; } @@ -119,7 +119,7 @@ public void consume(final char input) { * * @return The current state. */ - public int getState() { + private int getState() { return state; } } From c618113bbc87cceec6b285d6f99a773108ba44bc Mon Sep 17 00:00:00 2001 From: Samuel Facchinello <4256795+samuelfac@users.noreply.github.com> Date: Thu, 13 Jun 2024 20:13:38 +0200 Subject: [PATCH 08/12] Update src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java Co-authored-by: Piotr Idzik <65706193+vil02@users.noreply.github.com> --- .../com/thealgorithms/others/StringMatchFiniteAutomata.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java b/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java index a0b1d5fa4b1b..6ab958904c81 100644 --- a/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java +++ b/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java @@ -97,12 +97,11 @@ private static int getNextState(final String pattern, final int patternLength, f * A class representing the finite automata for pattern matching. */ private static final class FiniteAutomata { - private int state; + private int state = 0; private final int[][] stateTransitionTable; private FiniteAutomata(int[][] stateTransitionTable) { this.stateTransitionTable = stateTransitionTable; - this.state = 0; // Initial state } /** From 1b5115b8e7fb1b17ef25fd7519e81c3c28f6550e Mon Sep 17 00:00:00 2001 From: Samuel Facchinello <4256795+samuelfac@users.noreply.github.com> Date: Thu, 13 Jun 2024 20:13:44 +0200 Subject: [PATCH 09/12] Update src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java Co-authored-by: Piotr Idzik <65706193+vil02@users.noreply.github.com> --- .../com/thealgorithms/others/StringMatchFiniteAutomata.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java b/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java index 6ab958904c81..5e41bd457cdf 100644 --- a/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java +++ b/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java @@ -45,7 +45,7 @@ public static Set searchPattern(final String text, final String pattern * @return The state transition table. */ private static int[][] computeStateTransitionTable(final String pattern) { - int patternLength = pattern.length(); + final int patternLength = pattern.length(); int[][] stateTransitionTable = new int[patternLength + 1][CHARS]; for (int state = 0; state <= patternLength; ++state) { From a46a5a0fdbb385b14a0d98a400851a9f8922a080 Mon Sep 17 00:00:00 2001 From: Samuel Facchinello <4256795+samuelfac@users.noreply.github.com> Date: Thu, 13 Jun 2024 20:13:51 +0200 Subject: [PATCH 10/12] Update src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java Co-authored-by: Piotr Idzik <65706193+vil02@users.noreply.github.com> --- .../com/thealgorithms/others/StringMatchFiniteAutomata.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java b/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java index 5e41bd457cdf..561845f41a07 100644 --- a/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java +++ b/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java @@ -11,7 +11,7 @@ public final class StringMatchFiniteAutomata { // Constants - private static final int CHARS = 256; // Total number of characters in the input alphabet + private static final int CHARS = Character.MAX_VALUE + 1; // Total number of characters in the input alphabet // Private constructor to prevent instantiation private StringMatchFiniteAutomata() { From e106e64db18a85f24cb18832e2794e9285a7a8b5 Mon Sep 17 00:00:00 2001 From: Samuel Facchinello Date: Fri, 14 Jun 2024 17:32:38 +0200 Subject: [PATCH 11/12] fix clang --- .../others/StringMatchFiniteAutomataTest.java | 11 ++--------- 1 file changed, 2 insertions(+), 9 deletions(-) diff --git a/src/test/java/com/thealgorithms/others/StringMatchFiniteAutomataTest.java b/src/test/java/com/thealgorithms/others/StringMatchFiniteAutomataTest.java index ef60c9ae4a2d..2279e7fa999e 100644 --- a/src/test/java/com/thealgorithms/others/StringMatchFiniteAutomataTest.java +++ b/src/test/java/com/thealgorithms/others/StringMatchFiniteAutomataTest.java @@ -17,14 +17,7 @@ void searchPattern(String text, String pattern, Set expectedOutput) { } private static Stream provideTestCases() { - return Stream.of(Arguments.of("abcbcabc", "abc", Set.of(0, 5)), // - Arguments.of("", "abc", Set.of()), // - Arguments.of("abcdefg", "xyz", Set.of()), // - Arguments.of("abcde", "", Set.of(1, 2, 3, 4, 5)), // - Arguments.of("abcabcabc", "abc", Set.of(0, 3, 6)), // - Arguments.of("abcabcabc", "abcabcabc", Set.of(0)), // - Arguments.of("aaabbbaaa", "aaa", Set.of(0, 6)), // - Arguments.of("abcdefg", "efg", Set.of(4)) // - ); + return Stream.of(Arguments.of("abcbcabc", "abc", Set.of(0, 5)), Arguments.of("", "abc", Set.of()), Arguments.of("abcdefg", "xyz", Set.of()), Arguments.of("abcde", "", Set.of(1, 2, 3, 4, 5)), Arguments.of("abcabcabc", "abc", Set.of(0, 3, 6)), Arguments.of("abcabcabc", "abcabcabc", Set.of(0)), + Arguments.of("aaabbbaaa", "aaa", Set.of(0, 6)), Arguments.of("abcdefg", "efg", Set.of(4))); } } From 841a7acd8c94625737e65f6098abfdade4cedb4f Mon Sep 17 00:00:00 2001 From: Piotr Idzik <65706193+vil02@users.noreply.github.com> Date: Mon, 17 Jun 2024 22:50:56 +0200 Subject: [PATCH 12/12] tests: add more test cases --- .../thealgorithms/others/StringMatchFiniteAutomataTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/test/java/com/thealgorithms/others/StringMatchFiniteAutomataTest.java b/src/test/java/com/thealgorithms/others/StringMatchFiniteAutomataTest.java index 2279e7fa999e..6e1947b76a38 100644 --- a/src/test/java/com/thealgorithms/others/StringMatchFiniteAutomataTest.java +++ b/src/test/java/com/thealgorithms/others/StringMatchFiniteAutomataTest.java @@ -17,7 +17,7 @@ void searchPattern(String text, String pattern, Set expectedOutput) { } private static Stream provideTestCases() { - return Stream.of(Arguments.of("abcbcabc", "abc", Set.of(0, 5)), Arguments.of("", "abc", Set.of()), Arguments.of("abcdefg", "xyz", Set.of()), Arguments.of("abcde", "", Set.of(1, 2, 3, 4, 5)), Arguments.of("abcabcabc", "abc", Set.of(0, 3, 6)), Arguments.of("abcabcabc", "abcabcabc", Set.of(0)), - Arguments.of("aaabbbaaa", "aaa", Set.of(0, 6)), Arguments.of("abcdefg", "efg", Set.of(4))); + return Stream.of(Arguments.of("abcbcabc", "abc", Set.of(0, 5)), Arguments.of("", "abc", Set.of()), Arguments.of("", "", Set.of()), Arguments.of("a", "b", Set.of()), Arguments.of("a", "a", Set.of(0)), Arguments.of("abcdabcabcabcd", "abcd", Set.of(0, 10)), Arguments.of("abc", "bcd", Set.of()), + Arguments.of("abcdefg", "xyz", Set.of()), Arguments.of("abcde", "", Set.of(1, 2, 3, 4, 5)), Arguments.of("abcabcabc", "abc", Set.of(0, 3, 6)), Arguments.of("abcabcabc", "abcabcabc", Set.of(0)), Arguments.of("aaabbbaaa", "aaa", Set.of(0, 6)), Arguments.of("abcdefg", "efg", Set.of(4))); } }