GRAMMAIRE_2.java

///EXO2///
import java.util.HashSet;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Moore {
    static private char[] alphabetIt;
    static private EtatMoore[] colonnes;

    public static Automate minimisation(Automate af) {
        boolean premierAppel = true;
        alphabetIt = new char[af.alphabet().size()];
        colonnes = new EtatMoore[af.size()];
        int compteur = 0;
        for (Character c : af.alphabet()) alphabetIt[compteur++] = c.charValue();
        compteur = 0;
        for (Etat e : af) colonnes[compteur++] = new EtatMoore(e, alphabetIt.length);
        if (Main.INFO) System.out.println("--- ETAPES MOORE ---");

        do {
            if (premierAppel) premierAppel = false;
            else preparationEtape();

            for (EtatMoore etape : colonnes) {
                for (int j = 0; j < alphabetIt.length; j++) {
                    etape.transitions[j] = rechercheValeur(etape.etat, alphabetIt[j]);
                }
            }
            bilan();
            if (Main.INFO) print();
        } while (!finMoore());

        Automate minimale = new Automate();
        HashSet<Integer> doublee = colonneDouble();
        for (int i = 0; i < colonnes.length; i++) {
            EtatMoore etape = colonnes[i];
            if (!doublee.contains(Integer.valueOf(i))) {
                minimale.ajouteEtatSeul(new Etat(etape.etat.isInit(), etape.etat.isTerm(), etape.bilan));
            }
        }

        for (int k = 0; k < colonnes.length; k++) {
            EtatMoore etape = colonnes[k];
            if (!doublee.contains(Integer.valueOf(k))) {
                for (int i = 0; i < alphabetIt.length; i++) {
                    if (etape.transitions[i] != -1) {
                        Etat etat = minimale.getEtat(etape.bilan);
                        etat.ajouteTransition(alphabetIt[i], minimale.getEtat(etape.transitions[i]));
                    }
                }
            }
        }
        return minimale;
    }

    private static HashSet<Integer> colonneDouble() {
        HashSet<Integer> res = new HashSet<Integer>();
        HashSet<Integer> index = new HashSet<Integer>();
        for (int i = 0; i < colonnes.length; i++) {
            if (!index.add(new Integer(colonnes[i].bilan))) {
                res.add(new Integer(i));
            }
        }
        return res;
    }

    private static void bilan() {
        int compteur = 1;
        boolean succes = false;
        for (int i = 0; i < colonnes.length; i++) {
            for (int j = 0; j < i; j++) {
                if (bilanEgale(colonnes[i], colonnes[j])) {
                    colonnes[i].bilan = colonnes[j].bilan;
                    succes = true;
                    break;
                }
            }
            if (!succes) colonnes[i].bilan = compteur++;
            succes = false;
        }
    }

    private static void preparationEtape() {
        for (EtatMoore etape : colonnes) {
            etape.motVide = etape.bilan;
        }
    }

    private static boolean finMoore() {
        for (EtatMoore etape : colonnes) {
            if (etape.motVide != etape.bilan) return false;
        }
        return true;
    }

    private static boolean bilanEgale(EtatMoore a, EtatMoore b) {
        if (a.motVide != b.motVide) return false;
        for (int i = 0; i < a.transitions.length; i++) {
            if (a.transitions[i] != b.transitions[i]) return false;
        }
        return true;
    }

   private static int rechercheValeur(Etat depart, char c) {
    EnsEtat succ = depart.succ(c);
    if (succ.isEmpty()) return -1;

    Etat suivant = succ.iterator().next();
    EtatMoore etapeDuSuivant = null;
    for (EtatMoore etape : colonnes) {
        if (etape.etat == suivant) {
            etapeDuSuivant = etape;
            break;
        }
    }

    if (etapeDuSuivant == null) return -1;

    return etapeDuSuivant.motVide;
}

    private static void print() {
        System.out.print("   ");
        for (EtatMoore etape : colonnes) {
            System.out.print(etape.etat.hashCode() + "  ");
        }
        System.out.println();

        System.out.print("1  ");
        for (EtatMoore etape : colonnes) {
            System.out.print(etape.motVide + "  ");
        }
        System.out.println();

        for (int i = 0; i < alphabetIt.length; i++) {
            System.out.print(alphabetIt[i] + "  ");
            for (int j = 0; j < colonnes.length; j++) {
                if (colonnes[j].transitions[i] == -1) System.out.print(colonnes[j].transitions[i] + " ");
                else System.out.print(colonnes[j].transitions[i] + "  ");
            }
            System.out.println();
        }

        System.out.print("=> ");
        for (EtatMoore etape : colonnes) {
            System.out.print(etape.bilan + "  ");
        }
        System.out.println("\n");
    }
}

class EtatMoore {
    public Etat etat;
    public int motVide;
    public int bilan;
    public int[] transitions;

    public EtatMoore(Etat etat, int size) {
        this.etat = etat;
        this.motVide = (etat.isTerm()) ? 2 : 1;
        this.bilan = 0;
        this.transitions = new int[size];
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            Automate afd = readAFDFromFile("input.txt");
            Automate minimalAutomaton = Moore.minimisation(afd);
            writeAutomateToFile("output.txt", minimalAutomaton);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

   private static Automate readAFDFromFile(String filename) throws IOException {
    Automate afd = new Automate();

    try (BufferedReader br = new BufferedReader(new FileReader(filename))) {
        String line;
        while ((line = br.readLine()) != null) {
           
            String[] parts = line.split(" "); 
            Etat source = new Etat(Integer.parseInt(parts[0])); 
            char symbol = parts[1].charAt(0); 
            Etat destination = new Etat(Integer.parseInt(parts[2])); 
            source.ajouteTransition(symbol, destination);
          
        }
    }

    return afd;
}

private static void writeAutomateToFile(String filename, Automate automate) throws IOException {
    try (BufferedWriter bw = new BufferedWriter(new FileWriter(filename))) {
        for (Etat etat : automate) {
            for (char symbol : automate.alphabet()) {
                EnsEtat successors = etat.succ(symbol);
                if (!successors.isEmpty()) {
                    Etat destination = successors.iterator().next();
                    bw.write(etat.hashCode() + " " + symbol + " " + destination.hashCode() + "\n");
                }
            }
        }
    }
}