Exercice Java corrigé machine de Turing, algorithme et POO de base

// ----------------------------------------------------------------------
// Classes utiles
// ----------------------------------------------------------------------

class Tete {
    private int position;

    public Tete() {
        position = Turing.POSITION_INITIALE;
    }

    public int getPosition() {
        return position;
    }

    public void setPosition(int position) {
        this.position = position;
    }

    public void avance() {
        position++;
    }

    public void recule() {
        position--;
    }
}

class Transition {
    private int etat;
    private char caractere;
    private int deplacement;

    public Transition(int etat, char caractere, int deplacement) {
        this.etat = etat;
        this.caractere = caractere;
        this.deplacement = deplacement;
    }

    public int getEtat() {
        return etat;
    }

    public char getCaractere() {
        return caractere;
    }

    public int getDeplacement() {
        return deplacement;
    }
}

class TMachine {
    private int etatActuel;
    private String bande;
    private Tete tete;
    private Transition table [][];

    public TMachine(Transition[][] table) {
        etatActuel = Turing.ETAT_INITIAL;
        bande = "";
        tete = new Tete();
        tete.setPosition(Turing.POSITION_INITIALE);
        this.table = table;
    }

    /**
     * Réinitialise une machine et écrit les données d'entrée sur la bande.
     * @param entree Les données d'entrée
     */
    public void reinitialise(final String entree) {
        etatActuel = Turing.ETAT_INITIAL;
        bande = entree;
        tete.setPosition(Turing.POSITION_INITIALE);
    }

    /**
     * Lit le caractère courant sur une bande doublement infinie.
     * Simule l'aspect infini négatif en ajoutant un caractère en début de
     * chaîne puis en décalant la valeur de la tête (càd la remettre à 0)
     * @return Le caractère lu
     */
    private char lecture() {
        // simulation du ruban pour les positions négatives
        while (tete.getPosition() < 0) {
            bande = Turing.EPSILON + bande;
            tete.avance();
        }
        // insertion des EPSILON nécessaires pour les position positives
        while (tete.getPosition() >= bande.length()) {
            bande = bande + Turing.EPSILON;
        }
        // lecture du caractère
        return bande.charAt(tete.getPosition());
    }

    /**
     * Écrit un caractère sur une bande doublement infinie.
     * Simule l'aspect infini négatif en ajoutant un caractère en début de
     * chaîne puis en décalant la valeur de la tête (càd la remettre à 0)
     * @param Le caractère à écrire
     */
    private void ecriture(char c) {
        // simulation du ruban pour les positions négatives
        while (tete.getPosition() < 0) {
            bande = Turing.EPSILON + bande;
            tete.avance();
        }

        // insertion des EPSILON nécessaires pour les positions positives
        while (tete.getPosition() >= bande.length()) {
            bande = bande + Turing.EPSILON;
        }

        // écriture du caractère
        bande = bande.substring(0, tete.getPosition()) + c
                + bande.substring(tete.getPosition() + 1, bande.length());
    }

    /**
    * Affiche l'état de la machine de Turing
    */
    private void affiche() {
        System.out.println("    --------------------------------");
        System.out.println("    Etat actuel : " + etatActuel);
        System.out.println("    Bande :");
        System.out.println("       " + bande);
        System.out.print("      ");
        for (int i = -1; i < tete.getPosition(); i++) {
            System.out.print(" ");
        }
        System.out.println("^ (Tete : " + tete.getPosition() + ")");
        System.out.println("    --------------------------------");
    }

    /**
    * Lance l'exécution de la machine de Turing
    */
    public void lance() {
        System.out.println("Lancement de la machine de Turing");
        affiche();

        while (etatActuel != UNDEF) {
            // Cherche la position à lire dans la table de transition

            // Indice de ligne
            int i = etatActuel - 1;
            // Indice de colonne (caractère lu)
            System.out.print(" lu : " + lecture() + ",");
            int j = 0;
            switch (lecture()) {
            case '0':
                j = 0;
                break;
            case '1':
                j = 1;
                break;
            case EPSILON:
                j = 2;
                break;
            default:
                System.out.println("ERREUR: j'ai lu un caractère inconnu: " + lecture());
                affiche();
            }

            // Mise à jour de la machine
            etatActuel = table[i][j].getEtat();
            System.out.print(" nouvel état : " + etatActuel + ",");
            ecriture(table[i][j].getCaractere());
            System.out.print(" écrit : " + table[i][j].getCaractere() + ",");

            switch (table[i][j].getDeplacement()) {
            case 1:
                tete.avance();
                System.out.println(" avance");
                break;
            case -1:
                tete.recule();
                System.out.println(" recule");
                break;
            default:
                System.out.println("ERREUR: déplacement inconnu: "
                        + table[i][j].getDeplacement());
                affiche();
            }

            affiche();
        }

        System.out.println("Arrêt de la machine de Turing.");
    }

}

/**
 * Classe Principale
 */
class Turing {
    public static final char EPSILON = 'e';
    public static final int POSITION_INITIALE = 0;
    public static final int UNDEF = 0;
    public static final int ETAT_INITIAL = 1;

    public static void main(String[] args) {
        // Définit la table pour le calcul de parité
        Transition[][] table1 = {
            {new Transition(1, '0', +1), new Transition(1, '1', +1), new Transition(2, EPSILON, -1)},
            {new Transition(3, EPSILON, -1), new Transition(4, EPSILON, -1), new Transition(UNDEF, EPSILON, -1)},
            {new Transition(3, EPSILON, -1), new Transition(3, EPSILON, -1), new Transition(5, '1', +1)},
            {new Transition(4, EPSILON, -1), new Transition(4, EPSILON, -1), new Transition(5, '0', +1)},
            {new Transition(UNDEF, EPSILON, -1), new Transition(UNDEF, EPSILON, -1), new Transition(UNDEF, EPSILON, -1)}
        };

        // La table pour l'inversion des bits est donnée ci-après
        // A vous de "l'injecter" dans votre programme dans le bon format
        // voir table ci-dessus.
        /*   { {    2,     '0', +1}, {    3,     '1', +1}, {UNDEF, EPSILON, +1} },
        { {    2,     '0', +1}, {    3,     '1', +1}, {    4, EPSILON, +1} },
        { {    2,     '0', +1}, {    3,     '1', +1}, {    5, EPSILON, +1} },
        { {    4,     '0', +1}, {    4,     '1', +1}, {    6,     '0', -1} },
        { {    5,     '0', +1}, {    5,     '1', +1}, {    6,     '1', -1} },
        { {    6,     '0', -1}, {    6,     '1', -1}, {    7, EPSILON, -1} },
        { {    8, EPSILON, -1}, {    8, EPSILON, -1}, {    7, EPSILON, -1} },
        { {   10,     '0', +1}, {   11,     '1', +1}, {    9, EPSILON, +1} },
        { {UNDEF,     '0', -1}, {UNDEF,     '1', -1}, {    9, EPSILON, +1} },
        { {    4,     '0', +1}, {    4,     '1', +1}, {   10, EPSILON, +1} },
        { {    5,     '0', +1}, {    5,     '1', +1}, {   11, EPSILON, +1} }

        };*/

        TMachine m = new TMachine(table1);
        //m.reinitialise("10");
        m.reinitialise("1101");
        m.lance();
    }
}

Télécharger aussi :

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *