algorithm/Java
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Java.git synced 2025-07-08 02:04:31 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: redesign StringMatchFiniteAutomata (#5222)

Browse Source 
* refactor

* add test

* fix clang

* fix pmd

* remove main method

* refactor searchPattern with private class

* fix checkstyle

* Update src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java

Co-authored-by: Piotr Idzik <65706193+vil02@users.noreply.github.com>

* Update src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java

Co-authored-by: Piotr Idzik <65706193+vil02@users.noreply.github.com>

* Update src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java

Co-authored-by: Piotr Idzik <65706193+vil02@users.noreply.github.com>

* fix clang

* tests: add more test cases

---------

Co-authored-by: Samuel Facchinello <samuel.facchinello@piksel.com>
Co-authored-by: Piotr Idzik <65706193+vil02@users.noreply.github.com>
This commit is contained in:
Samuel Facchinello
2024-06-17 22:55:20 +02:00
committed by GitHub
parent c7ee0e73c2
commit 9973b8efc8
2 changed files with 116 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

141
src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java
View File

@ -1,80 +1,125 @@
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 <a href="https://en.wikipedia.org/wiki/Finite-state_machine">finite automata</a>.
*
* @author <a href="https://github.com/prateekKrOraon">Prateek Kumar Oraon</a>
*/
public final class StringMatchFiniteAutomata {
// Constants
private static final int CHARS = Character.MAX_VALUE + 1; // Total number of characters in the input alphabet
// Private constructor to prevent instantiation
private StringMatchFiniteAutomata() {
}
public static final int CHARS = 256;
public static int[][] fa;
public static Scanner scanner = null;
/**
* 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<Integer> searchPattern(final String text, final String pattern) {
final var stateTransitionTable = computeStateTransitionTable(pattern);
FiniteAutomata finiteAutomata = new FiniteAutomata(stateTransitionTable);
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();
Set<Integer> indexFound = new TreeSet<>();
for (int i = 0; i < text.length(); i++) {
finiteAutomata.consume(text.charAt(i));
searchPat(text, pat);
scanner.close();
}
public static void searchPat(String text, String pat) {
int m = pat.length();
int n = text.length();
fa = new int[m + 1][CHARS];
computeFA(pat, m, fa);
int state = 0;
for (int i = 0; i < n; i++) {
state = fa[state][text.charAt(i)];
if (state == m) {
System.out.println("Pattern found at index " + (i - m + 1));
if (finiteAutomata.getState() == pattern.length()) {
indexFound.add(i - pattern.length() + 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.
* @return The state transition table.
*/
private static int[][] computeStateTransitionTable(final String pattern) {
final 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) {
fa[state][x] = getNextState(pat, m, state, x);
stateTransitionTable[state][x] = getNextState(pattern, patternLength, state, x);
}
}
return stateTransitionTable;
}
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(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)) {
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;
}
/**
* A class representing the finite automata for pattern matching.
*/
private static final class FiniteAutomata {
private int state = 0;
private final int[][] stateTransitionTable;
private FiniteAutomata(int[][] stateTransitionTable) {
this.stateTransitionTable = stateTransitionTable;
}
/**
* Consumes an input character and transitions to the next state.
*
* @param input The input character.
*/
private void consume(final char input) {
state = stateTransitionTable[state][input];
}
/**
* Gets the current state of the finite automata.
*
* @return The current state.
*/
private int getState() {
return state;
}
}
}