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 Cesure
Donnez 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;
}
}

Article publié le 13 Août 2010 Mise à jour le Lundi, 06 Juin 2022 17:56 par Salim KHALIL