compter le nombre de répétions succesives du même caractère

**cheyma** · 12/10/2016, 12h37

Bonjour,

je voudrais créer une fonction qui me permet de compter le nombre de répétition du même caractère successivement (plus de 2 caractères)
Exemple : le mot : 'bonnjjjouuuuur'
Le resultat vaut: 2
car:
* j'ai la caractère 'j' se répéte plus de deux fois (3 fois).
* aussi le caractère 'u' se répete plus de deux fois (5 fois).
par contre la répetition du caractère 'n' n'était pas pris en considération (seulement 2 fois).
Merci

**joel.drigo** · 12/10/2016, 12h50

Salut,

Très bien, mais tu as une question ?

**cheyma** · 12/10/2016, 13h20

Oui, j'ai essayé avec cette fonction mais ça n'a pas marché

Pourriez vous m'aider à corriger ?
Merci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 public static int etirement(String m) {
        int i=1;
        int j=i+1;
        int nbFq=0;
        int etir=0;
        while(i<=m.length()-1)
        {   if (m.charAt(i)== m.charAt(j)) 
            {nbFq++;}
           if (nbFq>2)
                etir++;
            }
          return etir;
    }

**joel.drigo** · 12/10/2016, 14h34

Déjà, ce code ne doit rien te donner puisqu'il boucle infiniment : on n'incrémente pas i, donc la condition du while ne change pas, donc boucle infinie.

Tu n'as pas besoin de deux index. Tu sais que le caractère de position 0 ne suit aucun caractère, donc on peut commencer en position 1, ce qui permet de comparer avec la position précédente (qui existe toujours), ce qui donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static int etirement(String m) {
   int j = 1;
   int nbFq = 0;
   int etir = 0;
   while (j < m.length() ) {
      if (m.charAt(j-1) == m.charAt(j)) {
	  nbFq++;
      }
      if (nbFq > 2)
	  etir++;
      j++;
   }
   return etir;
}

Ensuite, le test if (nbFq > 2). Il n'y aucune réinitialisation de nbFq, donc dès que nbFq est supérieur à 2, on incrémente etir. Donc, premier problème, dès qu'on a 3 lettres qui se suivent, même si on a que des lettres non doublées après, on incrémente à chaque lettre. Si une lettre est quadruplée, nbFq passe à 4, et donc, second problème, on incrémente aussi, alors qu'on a déjà compter la lettre comme triplée. Enfin, troisième problème, on compte 1 ((0+)1) lorsque deux lettres se suivent, et on incrémente nbFq à chaque fois que deux mêmes lettres se succèdent, donc 2(1+1) quand trois lettres se suivent, 3(1+1+1) quand quatre lettres se suivent et ainsi de suite. Comme tu cherches à compter les lettres qui sont au moins triplées (trois lettres qui se suivent), il faut tester nbFq=2.

Pour le premier problème, il faut donc initialiser nbFq (le remettre à 0). Quand faut-il le faire ? Et bien, quand 2 lettres qui se suivent ne sont pas égale :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
if (m.charAt(j-1) == m.charAt(j)) {
  nbFq++;
}
else {
  nbFq=0;
}

Et si tu remplaces ton test par if ( nbFq==2 ), le second et le troisième problème sont résolus : on ne compte plus qu'une fois une lettre à partir du moment où elle est au moins triplée.

Une petite optimisation en bonus. On n'a pas besoin de faire ce test de nbFq==2 quand nbFq est à 0. On peut donc faire ce test uniquement lorsqu'on l'incrémente. Or on l'incrémente seulement lorsqu'on a égalité des deux caractères successifs : on peut donc mettre ce test dans le bloc du if correspondant.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static int etirement(String m) {
    int j = 1;
    int nbFq = 0;
    int etir = 0;
    while (j < m.length() ) {
        if (m.charAt(j-1) == m.charAt(j)) {
           nbFq++; 
           if (nbFq == 2)
              etir++;
        }
        else {
           nbFq=0;
        }
        j++;
    }
    return etir;
}

A noter que comme l'index j ne sert que dans la boucle, on pourrait même faire simplement un for :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static int etirement(String m) {
   int nbFq = 0;
   int etir = 0;
   for (int j=1; j < m.length(); j++ ) {
      if (m.charAt(j-1) == m.charAt(j)) {
          nbFq++; 
 	  if (nbFq == 2)
	      etir++;
     }
     else {
	 nbFq=0;
     }
   }
   return etir;
}

Mais tout ça, ça te donne le nombre de caractères qui se succèdent plus de deux fois. Pas le nombre de fois qu'une lettre se succède. Pour ça, il faut introduire un paramètre : la lettre qu'on veut compter. Mais en plus, on pourait avoir 2 fois une succession de la même lettre.
Par exemple dans ATTTITTTTUDE, le T est 3 fois, puis 4...
Comment est-ce censée être traité ? On répond quoi 3 ? 4 ? 7 ?

**cheyma** · 12/10/2016, 17h01

Merci pour votre aide

Voila c'est

J'ai ajouté quelques changements pour que l'étirement soit logique selon mes besoins.
Peux-être que ce n'est pas le traitement optimal, mais il fonctionne correctement

Merci encore une fois

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
public static int etirement(String m) {
        int j = 1;
        int nbFq = 0;
        int etir = 0;
        {
            while (j < m.length()) {
                // l'Etirement existe même avec seulement deux voyelles consicutives identiques 
                if ((m.charAt(j - 1) == m.charAt(j)) && (m.charAt(j) == 'a' || m.charAt(j) == 'à' || m.charAt(j) == 'â' || m.charAt(j) == 'À' || m.charAt(j) == 'Â' || m.charAt(j) == 'Æ' || m.charAt(j) == 'æ' || m.charAt(j) == 'A'
                        || m.charAt(j) == 'e' || m.charAt(j) == 'é' || m.charAt(j) == 'è' || m.charAt(j) == 'ê' || m.charAt(j) == 'ë' || m.charAt(j) == 'E' || m.charAt(j) == 'É' || m.charAt(j) == 'Ë' || m.charAt(j) == 'Ê' || m.charAt(j) == 'È'
                        || m.charAt(j) == 'i' || m.charAt(j) == 'î' || m.charAt(j) == 'ï' || m.charAt(j) == 'I' || m.charAt(j) == 'Ï' || m.charAt(j) == 'Î'
                        || m.charAt(j) == 'o' || m.charAt(j) == 'ô' || m.charAt(j) == 'œ' || m.charAt(j) == 'O' || m.charAt(j) == 'Œ' || m.charAt(j) == 'Ô'
                        || m.charAt(j) == 'u' || m.charAt(j) == 'û' || m.charAt(j) == 'ü' || m.charAt(j) == 'U' || m.charAt(j) == 'Û' || m.charAt(j) == 'Ü'
                        || m.charAt(j) == 'y' || m.charAt(j) == 'ÿ' || m.charAt(j) == 'Y' || m.charAt(j) == 'Ÿ')) {
                    nbFq++;
                    if (nbFq == 1) {
                        etir++;
                    }
                } // pas d'étirement avec les chiffre.
                else if ((m.charAt(j - 1) == m.charAt(j)) && (m.charAt(j) == '0' || m.charAt(j) == '1' || m.charAt(j) == '2'
                        || m.charAt(j) == '3' || m.charAt(j) == '4' || m.charAt(j) == '5' || m.charAt(j) == '6'
                        || m.charAt(j) == '7' || m.charAt(j) == '8'
                        || m.charAt(j) == '9')) {
                    nbFq = 0;
                } // pas d'étirement avec seulement 2 consonnes consicutifs identiques.
                else if ((m.charAt(j - 1) == m.charAt(j)) && (m.charAt(j) == 'b' || m.charAt(j) == 'B'
                        || m.charAt(j) == 'c' || m.charAt(j) == 'Ç' || m.charAt(j) == 'ç'
                        || m.charAt(j) == 'd' || m.charAt(j) == 'D'
                        || m.charAt(j) == 'f' || m.charAt(j) == 'F'
                        || m.charAt(j) == 'g' || m.charAt(j) == 'G'
                        || m.charAt(j) == 'h' || m.charAt(j) == 'H'
                        || m.charAt(j) == 'j' || m.charAt(j) == 'J'
                        || m.charAt(j) == 'k' || m.charAt(j) == 'K'
                        || m.charAt(j) == 'l' || m.charAt(j) == 'L'
                        || m.charAt(j) == 'm' || m.charAt(j) == 'M'
                        || m.charAt(j) == 'n' || m.charAt(j) == 'N'
                        || m.charAt(j) == 'p' || m.charAt(j) == 'P'
                        || m.charAt(j) == 'q' || m.charAt(j) == 'Q'
                        || m.charAt(j) == 'r' || m.charAt(j) == 'R'
                        || m.charAt(j) == 's' || m.charAt(j) == 'S'
                        || m.charAt(j) == 't' || m.charAt(j) == 'T'
                        || m.charAt(j) == 'v' || m.charAt(j) == 'V'
                        || m.charAt(j) == 'w' || m.charAt(j) == 'W'
                        || m.charAt(j) == 'x' || m.charAt(j) == 'X'
                        || m.charAt(j) == 'z' || m.charAt(j) == 'Z')) {
                    nbFq++;
                    if (nbFq == 2) {
                        etir++;
                    }
                } else {
                    nbFq = 0;
                }
                j++;
            }
            return etir;
        }
 
    }

**joel.drigo** · 12/10/2016, 17h39

Hiiiiirkkkk... ces tests...

Pour commencer, au moins une petite variable : char c = m.charAt(j);, juste pour éviter tous ces m.charAt(j) partout...

Mais sinon, pour les chiffres, tu as l'embarras du choix :
comparaison de char (le plus rapide probablement)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

'0'<=c and c<='9'

simple indexof

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

"0123456789".indexOf( c )>=0

Classe Character (ça ne matche pas que les symboles dit arabes, mais bon, ça pourrait justement être utilie de matcher les autres chiffres :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Character.isDigit(c);

avec expression régulière

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

static final Pattern PATTERN_DIGIT = Pattern.compile("^\\d$");

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

PATTERN_DIGIT.matcher( String.valueOf(c) ).matches()

Pour les voyelles, un indexof aussi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

"aeiouy".indexOf(c)>=0

Pour les lettres, tu peux virer les accents : c = Normalizer.normalize(String.valueOf( c ), Normalizer.Form.NFD).replaceAll("\\p{InCombiningDiacriticalMarks}+", "").charAt(0);puis faire de la comparaison

('a'<=c && c<='z') || ('A'<=c && c<='Z')
ou pour éviter de doubler les tests pour les majuscules et minuscules, tu as aussi Character.toLowerCase(c) ou Character.toUpperCase(c). Ce qui donne par exemple : 'a'<=Character.toLowerCase(c) && Character.toLowerCase(c)<='z'
ou Character.isLetter(c),
ou alors tester avec une expression régulière : Pättern.compile("^\\w$"),

et simplement exclure (and not...) les voyelles (même test que précedemment).

Puis tu mets ça dans une petite classe utilitaire avec des noms qui veulent dire quelquechose (genre estVoyelle(char), estChiffre(char), estLettre(char), et ton code devient beaucoup plus clair, et maintenable (et tu ne risques pas d'oubli) et ceux qui vont relire ton code risquent moins un AVC.

[EDIT]

Envoyé par joel.drigo

(et tu ne risques pas d'oubli)

Tiens d'ailleurs, je viens de voir que tu as oublié le 'C' !

**cheyma** · 13/10/2016, 13h53

Bonjour,
Ouii vous avez raison, il y a beaucoups de répétition à éviter.

Merci

Voila les changements réalisés

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
public static int etirement(String m) {
        int j = 1;
        int nbFq = 0;
        int etir = 0;
        char c = m.charAt(j);
        char minis = Character.toLowerCase(c);
        {
            while (j < m.length()) {
                // l'Etirement existe même avec seulement deux voyelles consicutives identiques 
                if ((m.charAt(j - 1) == c) && ("aeiouyîôûÿèïœüêéë".indexOf(minis) >= 0)) {
                    nbFq++;
                    if (nbFq == 1) {
                        etir++;
                    }
                } // pas d'étirement avec les chiffres.
                else if ((m.charAt(j - 1) == c) && ("0123456789".indexOf(c) >= 0)) {
                    nbFq = 0;
                } // pas d'étirement avec seulement 2 consonnes consicutifs identiques.
                else if ((m.charAt(j - 1) == c) && ("bcdfghjklmnpqrstvwxz".indexOf(minis) >= 0
                        || c == 'ç')) {
                    nbFq++;
                    if (nbFq == 2) {
                        etir++;
                    }
                } else {
                    nbFq = 0;
                }
                j++;
            }
            return etir;
        }
 
    }

compter le nombre de répétions succesives du même caractère

avec Java

Discussions similaires

Partager

Partager