Exercice java programme de césure modularisation
But: | Compléter un petit programme de césure | |||
Thème: | String, Modularisation, algorithme | |||
La césure est la façon de couper les mots afin de pouvoir les imprimer sur deux ou plusieurs lignes. Un tiret à la fin de la ligne indique si le mot continue sur la ligne suivante. Exemple:
Aussitôt que le message lui parve-nait, le roi des rois sortait.
Dans cet exercice, il est question de compléter un petit programme de césure appellé Cesure.java. Il y a 4 méthodes auxiliaires à compléter en utilisant notamment des méthodes prédéfinies de la classe String. Le programme à compléter ci-dessous devra lire une phrase sous la forme d'un tableau de chaines de caractères et indiquer les endroits où le(s) mot(s) peu(ven)t être coupé(s).
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | class Cesure { public static void main(String[] args) { >String [] phrase = lirePhrase(); for (int i = 0; i phrase.length; i++) { cesure(phrase[i]); } } static String[] lirePhrase(){ // A compléter: // retourne un tableau de chaines de caractères // introduits par l'utilisateur } static boolean voyelle (char c) { // A compléter: // teste si un caractère est une voyelle } static boolean queVoyelles (String s){ // A compléter: // teste si une chaîne ne contient que des voyelles // utilise la méthode voyelle } static void cesure(String mot){ // A compléter: // détermine la césure d'un mot donné et effectue les affichages // correspondants (voir exemple de déroulement) } } |
Voici les trois règles de césure que vous devrez appliquer. Celles-ci ne correspondent évidemment pas aux véritables règles utilisées en français car le programme deviendrait trop compliqué pour le but de cet exercice.
- Un mot ne peut être coupé qu'entre une voyelle et une consonne,
- Une lettre ne peut être seule sur une ligne. Il faut veiller à cette situation au début et à la fin d'un mot
- Il doit y avoir au moins une consonne sur chaque ligne
Votre programme respectera également les règles suivantes:
- On utilisera l'alphabet latin avec les 26 lettres de a à z
- les voyelles sont a, e, i, o, u, y
- on supposera que le mot est toujours sans accents ni ponctuation et en lettres minuscules.
Les exemples d'exécutions ci-dessous illustrent différentes situations possibles:
>java CesureDonnez le nombre de mots dans votre phrase: 1
Donnez le mot 1 : java
Le résultat est :
ja-
va
>java Cesure
Donnez le nombre de mots dans votre phrase: 1
Donnez le mot 1 : calculer
Le résultat est :
ca-
lcu-
ler
>java Cesure
Donnez le nombre de mots dans votre phrase: 2
Donnez le mot 1 : tapis
Donnez le mot 2 : rouge
Le résultat est :
ta-
pis
rou-
ge
>java Cesure
Donnez le nombre de mots dans votre phrase: 3
Donnez le mot 1 : oeil
Donnez le mot 2 : de
Donnez le mot 3 : boeuf
Le résultat est :
oeil
de
boeuf
>java Cesure
Donnez le nombre de mots dans votre phrase: 0
entrez une valeur plus grande que 0
Les méthodes suivantes de la classe String peuvent vous être utile (vous n'aurez pas forcément besoin de toutes ces méthodes):
- length ()
Retourne la longueur de la chaine de caractères, c'est-à-dire le nombre de caractères qui la composent. - char charAt (int index)
Retourne le caractère qui se trouve à la position index de la chaine de caractères. Le premier caractère se trouve à la position 0 et le dernier à la position length()-1. - String substring (int beginIndex, int endIndex)
Retourne une nouvelle chaine de caractères composée de la partie de la chaine de caractères actuelle qui commence à la position beginIndex et se termine à la position (endIndex-1). - String concat(String str)
Retourne une nouvelle chaine de caractères i constituée de la chaine courante à laquelle a été concaténée (collée) la chaine str. - String.valueOf(c) permet de convertir le char c en String.
Fichiers: |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 | import java.util.Scanner; class Cesure { private static Scanner scanner = new Scanner(System.in); public static void main(String[] args) { String[] phrase = lirePhrase(); System.out.println("Le résultat est : "); for (int i = 0; i phrase.length; i++) { cesure(phrase[i]); } } /** * Lit une phrase depuis le terminal. * @return un tableau de Strings où chaque entrée * est un mot de la phrase lue. */ static String[] lirePhrase() { int number = 0; while (number 0) { System.out.print("Donnez le nombre de mots de votre phrase : "); number = scanner.nextInt(); if (number 0) { System.out.println("Entrez une valeur plus grande que 0"); } } String[] phrase = new String [number]; // se debarasser du \n scanner.nextLine(); for (int i = 0; i number; i++) { System.out.print("Donnez le mot " + (i + 1) + " : "); phrase[i] = scanner.nextLine(); } return phrase; } /** * Réalise la césure pour un mot donné * Pour ce faire, examine les différentes façons de couper * le mot: entre l'indice debut et l'indice i et entre i et * la longueur du mot (i variant de 1 à la longueur du mot et * debut étant initialisé à 0). * Si la régle de césure s'applique à ces deux parties * afficher le "-" et passer à la ligne suivante. * Puis, faire le même traitement en considérant la portion de mot * entre i et longueur du mot (debut prend la valeur de i) * @param mot une String représentant un mot de la phrase */ static void cesure(String mot) { int debut = 0; for (int i = 1; i mot.length(); i++) { char c1 = mot.charAt(i - 1); char c2 = mot.charAt(i); if ((voyelle(c1) && !voyelle(c2))) { String s1 = mot.substring(debut, i); String s2 = mot.substring(i, mot.length()); if ((s1.length() > 1) && (s2.length() > 1)) { if (!(queVoyelles(s1) || queVoyelles(s2))) { System.out.println(s1 + "-"); debut = i; } } } } String s1 = mot.substring(debut, mot.length()); System.out.println(s1); } /** * Teste si un caractère est une voyelle * @param c le caractère à tester * @return vrai si c est une voyelle et faux sinon */ static boolean voyelle(char c) { return ((c == 'a') || (c == 'e') || (c == 'i') || (c == 'o') || (c == 'u') || (c == 'y')); } /** * Teste si une chaîne de caractères ne contient que des voyelles * @param s la chaîne à tester * @return vrai si s ne contient que des voyelles et faux sinon */ static boolean queVoyelles(String s) { for (int i = 0; i s.length(); i++) { if (voyelle(s.charAt(i)) == false) { return false; } } return true; } } |