Cours CNAM par J. Laforgue

Exercice07_PbDes8Reines

Retour

Télécharger

Exercice sur le probleme des 8 reines.

EnonceExercice07.pdf

Exercice07.java

// Exercice sur le probleme des 8 reines.
//  
import fr.cnam.ihm.*;

public class Exercice07
{
    /** méthode principale de l'exercice */
    public static void main(String... args)
    {
        int[][] echiquier; // 1 case occupe par une reine
        int colCour;       // Colonne courante pour placer une reine

echiquier = new int[8][8];
        colCour=0;
        boolean fini = false;
        while (! fini)
            {
                boolean reussi = placerReine(echiquier,colCour);
                // Si la reine n'a pu etre placer dans la colonne
                //  cette methode enleve la reine de la colonne

if (reussi)
                    {
                        afficherEchiquier(echiquier);
                        //Terminal.lireString();
                        if (colCour==7) fini = true;
                        else
                            colCour = colCour + 1;
                    }
                else
                    {
                        if (colCour==0) // Pas de solution
                            fini = true;
                        else
                            colCour = colCour-1;
                    }
            }
        afficherEchiquier(echiquier);
        afficherEchiquierIHM(echiquier);
    }

private static boolean placerReine(int[][] echiquier,int colCour)
    {
        /*
          Tester s'il existe deja une reine dans la colonne colCour;
          Si existe
          Alors 
            la deplacer en avant jusqu'a une case libre;
            Si pas de case libre alors
              enlever la reine de la colonne;
              reussi = faux;
            Sinon
              mettre la reine à cette case libre;
              reussi = vrai;
            Finsi
          Sinon
            trouver une case libre;
            Si pas trouve alors
              reussi = faux;
            Sinon
              mettre la reine à cette case libre;
              reussi = vrai;
            Finsi
          Finsi
        */

boolean reussi;

//Tester s'il existe deja une reine dans la colonne colCour;
        int posReine=-1;
        for(int i=0;i<8;i++)
            if (echiquier[i][colCour]==1)
                {
                    posReine=i;
                    break;
                }
        //
        if (posReine!=-1)
            {
                int posLibre = determinerCaseLibre(echiquier,posReine,colCour);
                if (posLibre==-1)
                    {
                        echiquier[posReine][colCour]=0;
                        reussi=false;
                    }
                else
                    {
                        echiquier[posLibre][colCour]=1;
                        reussi=true;
                    }
            }
        else
            {
                int posLibre = determinerCaseLibre(echiquier,-1,colCour);
                if (posLibre==-1)
                    {
                        reussi=false;
                    }
                else
                    {
                        echiquier[posLibre][colCour]=1;
                        reussi=true;
                    }
            }

return reussi;
    }

//Methode qui determine la 1ere case libre dans une colonne
    // a partir d'une position (exclus)
    // Retourne -1 si pas trouvé
    private static int determinerCaseLibre(int[][] echiquier,int ligneReine,int colonneReine)
    {
        int ligneDebut;
        
        if (ligneReine==7) return -1;
        if (ligneReine==-1) ligneDebut=0;
        else 
            {
                ligneDebut=ligneReine+1;
                echiquier[ligneReine][colonneReine]=0;
            }

int posTrouve=-1;
        for(int l=ligneDebut;l<8;l++)
            {
                if (caseLibre(echiquier,l,colonneReine))
                    {
                        posTrouve=l;
                        break;
                    }
            }
        return posTrouve;
    }

//Methode qui determine si une case est libre (pas en prise par une reine)
    private static boolean caseLibre(int[][] echiquier,int ligne,int colonne)
    {
        for(int sensL=0;sensL<3;sensL++)
            for(int sensC=0;sensC<3;sensC++)
                if (existeReineSens(echiquier,ligne,colonne,sensL-1,sensC-1)) return false;
        return true;
    }

//Methode qui teste si il existe une reine dans un sens
    private static boolean existeReineSens(int[][] echiquier,int ligne,int colonne,int sensL,int sensC)
    {
        for(int k=0;k<8;k++)
            {
                int lCour = ligne+k*sensL;
                int cCour = colonne+k*sensC;
                if ((lCour>=0)&&(lCour<=7)&&
                    (cCour>=0)&&(cCour<=7))
                    if (echiquier[lCour][cCour]==1)
                        return true;
            }
        return false;
    }

static private void afficherEchiquier(int[][] echiquier)
    {
        for(int l=0;l<8;l++)
            {
                for(int c=0;c<8;c++)
                    if (echiquier[l][c]==1) System.out.print(" X");
                    else System.out.print(" .");
                System.out.println("");
            }
        System.out.println("----------------");
        Terminal.lireString();
    }

static private void afficherEchiquierIHM(int[][] echiquier)
    {
        CanvasIHM grille = CanvasIHM.creerCanvasIhmDansFrame(8,8,15);
        grille.afficherFrame(10,10);
        for(int l=0;l<8;l++)
            {
                for(int c=0;c<8;c++)
                    if (echiquier[l][c]==1) 
                        grille.setMarque(1,l,c);
            }

}

Terminal.java

import java.io.*;

public class Terminal{    
    static BufferedReader in =
        new BufferedReader(new InputStreamReader(System.in));

public static String lireString() // Lire un String
    {
        String tmp="";
        char C='\0';
        try {
            tmp = in.readLine();
        }
        catch (IOException e)
            {
                exceptionHandler(e);
            }
        return tmp;
    } // fin de lireString()
    public static int lireInt()  // Lire un entier
    {
        int x=0;
        try {
            x=Integer.parseInt(lireString());
        }
        catch (NumberFormatException e) {
            exceptionHandler(e);
        }    
        return x ;
    }
    public static boolean lireBoolean()  // Lire un entier
    {
        boolean b = true;
        try {
            b = Boolean.valueOf(lireString()).booleanValue();
        }
        catch (NumberFormatException e) {
            exceptionHandler(e);
        }    
        return b;
    }
    public  static double lireDouble()  // Lire un double
    {
        double x=0.0;
        try {
            x=Double.valueOf(lireString()).doubleValue();
        }
        catch (NumberFormatException e) {
            exceptionHandler(e);
        }    
        return x ;
    }
    public  static char lireChar()  // Lire un caractere
    {
        String tmp=lireString();
        if (tmp.length()==0)
            return '\n';
        else 
            {
                return tmp.charAt(0);
            }
    }
    public static void ecrireString(String s){ // Afficher un String
        try{
            System.out.print(s);
        } catch (Exception ex){
            exceptionHandler(ex);
        }
    }
    public static void ecrireStringln(String s) // Afficher un String
    {
        ecrireString(s);
        sautDeLigne();
    } // fin de ecrireStringln()
    public static void ecrireInt(int i)  // Afficher un entier
    {
        ecrireString(""+i);
    }
    public static void ecrireIntln(int i)  // Afficher un entier
    {
        ecrireString(""+i);
        sautDeLigne();
    }
    public static void ecrireBoolean(boolean b){
        ecrireString(""+b);
    }
    public static void ecrireBooleanln(boolean b){
        ecrireString(""+b);
        sautDeLigne();
    }
    public  static void ecrireDouble(double d)  // Afficher un double
    {
        ecrireString(""+d);
    }
    public  static void ecrireDoubleln(double d)  // Afficher un double
    {
        ecrireDouble(d);
        sautDeLigne();
    }
    public  static void ecrireChar(char c)  // Afficher un caractere
    {
        ecrireString(""+c);
    }  
    public  static void ecrireCharln(char c)  // Afficher un caractere
    {
        ecrireChar(c);
        sautDeLigne();
    }
    public static void sautDeLigne(){
        try{
            System.out.println();
        }catch(Exception ex){
            exceptionHandler(ex);
        }
    }
    protected static void exceptionHandler(Exception ex){
        TerminalException err = new TerminalException(ex);
        throw err;
    }
    public static void ecrireException(Throwable ex){
        ecrireString(ex.toString());
        ex.printStackTrace(System.err);
    }
}  
class TerminalException extends RuntimeException{
    Exception ex;
    TerminalException(Exception e){
        ex = e;
    }
}

      compil.bat
      fr
         cnam
            echiquier
               Echiquier.java
               PieceEchec.java
               TypePieceEchec.java
            ihm
            tore
      run.bat

Cours d'Informatique par Jacques LAFORGUE

Retour

Télécharger

Cours d'Informatique
par Jacques LAFORGUE