Cours CNAM par J. Laforgue

Exercice01_Phrase

Retour

Télécharger

Exercice sur les chaines de caractère : création d'une classe Phrase avec détermination si la phrase est un palindrome, purge des caractères blancs de la phrase avec deux algorithmes.

EnonceExercice01.pdf

README.txt
Exercice01.java

// Exercice sur les chaines de caractère : création d'une classe Phrase avec détermination si la phrase est un palindrome, purge des caractères blancs de la phrase avec deux algorithmes.
public class Exercice01
{
    /** méthode principale de l'exercice */
    public static void main(String... args)
    {
        // Test du palindrome
        //
        Phrase p1 = new Phrase();
        p1.saisir("Entrez le palindrome");
        
        if (p1.palindrome1())
            Terminal.ecrireStringln("C'est un palindrome");
        else
            Terminal.ecrireStringln("Ce n'est pas un palindrome");

if (p1.palindrome2())
            Terminal.ecrireStringln("C'est un palindrome");
        else
            Terminal.ecrireStringln("Ce n'est pas un palindrome");
        
        // Test de la purge des blancs
        do{
            p1.saisir("Phrase a purger");
            Terminal.ecrireStringln("["+p1+"]");
            p1.diminuerBlancs();
            Terminal.ecrireStringln("["+p1+"]");
        }while(! p1.toString().equals(""));

// Test de la purge des blancs avec un autre algo
        do{
            p1.saisir("Phrase a purger (algo bis)");
            Terminal.ecrireStringln("["+p1+"]");
            p1.diminuerBlancsBis();
            Terminal.ecrireStringln("["+p1+"]");
        }while(! p1.toString().equals(""));

//Test de isolerMots
        do{
            p1.saisir("Isoler les mots de ");
            Terminal.ecrireStringln("["+p1+"]");
            String[] t=p1.isolerMots();
            if(t!=null) for(String s:t)Terminal.ecrireStringln("["+s+"]");
        }while(! p1.toString().equals(""));

}
}

Phrase.java

/**
   Classe de définition d'une phrase. 
   Une phrase est avant tout une chaîne de caractères dont les mots sont espacés par des caractères blancs.
*/
public class Phrase
{
    private String phrase; // La String contenant la phrase

/** Ce constructeur crée une phrase dont la valeur par défaut est "". */
    public Phrase()
    {
        this.phrase = new String("");
    }

/** Ce constructeur crée une phrase dont la valeur est la String passé en paramètre.
       @param phrase : la chaine */
    public Phrase(String phrase)
    {
        this.phrase = phrase;
    }
    
    /** retourne la chaine de la phrase 
     @return String */
    public String toString(){return phrase;}

/** méthode qui modifie la phrase
        @param p : la phrase */
    public void setPhrase(String p){phrase=p;}

/** méthode qui permet de saisir en console la phrase 
     @param texteInvite : texte affiché avant la demande de saisie*/
    public void saisir(String texteInvite)
    {
        Terminal.ecrireString(texteInvite+" : ");
        this.phrase = Terminal.lireString();
    }
    
    /** méthode qui teste si la phrase est un palindrome.
        Algorithme : teste si la chaine et l'inversion de la chaine sont égales
        @return true ou flase suivant que la phrase est ou non un palindrome */
    public boolean palindrome1()
        {
        String l_chaine;
        l_chaine = this.phrase;

String l_strtmp="";
        // Inversion de la chaine
        for(int i=0;i<l_chaine.length();i++)
            l_strtmp = l_chaine.charAt(i) + l_strtmp;
        
        if (l_strtmp.equals(l_chaine)) return true;
        else return false;
        }

/** méthode qui teste si la phrase est un palindrome.
        Algorithme : parcours si les caractères sont en miroir
        @return true ou flase suivant que la phrase est ou non un palindrome */
    public boolean palindrome2()
        {
        String l_chaine;
        l_chaine = this.phrase;

boolean l_palindrome = true;
        for(int i=0;i<l_chaine.length()/2;i++)
            if (l_chaine.charAt(i)!=l_chaine.charAt(l_chaine.length()-i-1))
                l_palindrome = false;

if (l_palindrome) return true;
        else return false;
        }

/**
       Cette méthode enlève les blans superflus de la phrase. 
       Exemple : la phrase "   je     suis     dans   la    cuisine   "  
       devient "je suis dans la cuisine" */
    public void diminuerBlancs()
    {
        // L'algorithme consiste à parcourir la phrase caractère par caractère
        //  et à ne garder que les caractères blancs qui sont suivis d'un
        //  caractère non blanc sauf pour ceux en début de phrase
        //
        String str="";
        int debut=-1;
        // on saute les éventuels premiers caracteres blancs
        for(int i=0;i<phrase.length();i++)
            if (phrase.charAt(i)!=' ')
                {
                    debut=i;
                    break;
                }
        if (debut==-1) 
            {
                phrase="";
                return;
            }

for(int i=debut;i<phrase.length()-1;i++)
            {
                char car1 = phrase.charAt(i);
                char car2 = phrase.charAt(i+1);
                if (car1!=' ')
                    str=str+car1;
                else
                    if (car2!=' ')
                        str=str+car1;
            }
        if (phrase.charAt(phrase.length()-1)!=' ')
            str=str+phrase.charAt(phrase.length()-1);
        
        phrase=str;
    }

/**
       Cette méthode enlève les blans superflus de la phrase. 
       Avec un algo  différent.
       Exemple : la phrase "   je     suis     dans   la    cuisine   "  
       devienr "je suis dans la cuisine" */
    public void diminuerBlancsBis()
    {
        // L'algorithme consiste à parcourir la phrase caractère par caractère, à compter
        //  les blanc et à ne mettre que si compteur = 1. On re initialise le compteur
        //  quand on tombe sur un caractere non blanc. Il reste ensuite éventuellement
        // 1 caract blanc en début ou 1 caract blanc à la fin qu'il faut élminier.
        //
        String str="";
        //
        int c=0;
        for(int i=0;i<phrase.length();i++)
            {
                if (phrase.charAt(i)!=' ')
                    {
                        str=str+phrase.charAt(i);
                        c = 0;
                    }
                else
                    {
                        c=c+1;
                        if (c==1)
                            str=str+' ';
                    }
            }
        phrase=str;

// Enlever le caract blanc de debut et de la fin si il y en a
        str="";
        for(int i=0;i<phrase.length();i++)
            {
                if ( (i==0) && (phrase.charAt(i)==' '))
                    {}
                else if ( (i==phrase.length()-1) && (phrase.charAt(i)==' '))
                    {}
                else str=str+phrase.charAt(i);
            }
        phrase=str;
    }

/**
       Cette méthode retourne un tableau contenant les mots de la phrase */
    public String[] isolerMots()
    {
        String[] tab = null;

// On enlève les blancs superflus de la phrase
        diminuerBlancs();

// Il suffirait de faire l'instruction suivante car la méthode prédéfinie split existe
        //
        // return phrase.split(" ");
        //
        // Mais on peut faire l'algorithme suivant :
        //

if (phrase.length()!=0)
        {
            // Soit pos la position courante de début d'un mot dans la phrase, le pos suivant
            // est le caractère qui suit le prochain caractere blanc
            
            boolean fini = false;
            int pos = 0;
            int debut, fin = 0;
            do {
                // Recherche du pos suivant et des indices de debut et fin du mot
                debut=pos;
                fin=-1;
                for(int i=pos;i<=phrase.length()-1;i++)
                    {
                        if (phrase.charAt(i)==' ')
                            {
                                fin   = i-1;
                                pos   = i+1;
                                break;
                            }
                    }
                //Si dernier mot
                if(fin==-1) 
                    {
                        fin=phrase.length()-1;
                        fini=true;
                    }
                
                // On extrait le mot de la phrase
                String mot = phrase.substring(debut,fin+1);
                
                // On ajoute le mot dans le trableau
                if (tab==null)
                    {
                        tab = new String[1];
                        tab[0] = mot;
                    }
                else
                    {
                        String[] tabTmp = new String[tab.length+1];
                        for(int i=0;i<tab.length;i++) tabTmp[i]=tab[i];
                        tabTmp[tabTmp.length-1]=mot;
                        tab=tabTmp;
                    }
            }while(! fini);
        }
        return tab;
    }
}

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
run.bat

Cours d'Informatique par Jacques LAFORGUE

Retour

Télécharger

Cours d'Informatique
par Jacques LAFORGUE