Discussion :

[teletexte]

Bonjour,

J'aimerai pouvoir récupérer la petite chaine de caractère qui commence par 'd' fini par 'a' et contient 'o'

Exemple : "fondjswxaeqobdnoajezbpfrehanxi" => "dnoa"

Voilà mon code :

Code :

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

1
2
3
4
5
6
 
Pattern pattern = Pattern.compile("d.*?o.*?a");
Matcher matcher = pattern.matcher("fondjswxaeqobdnoajezbpfrehanxi");
while (matcher.find()) {
  system.out.println(matcher.group());
}

Ce code affiche "djswxaeqobdnoa" et non "dnoa".

Comment faire pour bien retourner la plus petite ?

Merci

[teletexte]

La solution :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
String shortest = null;
Pattern pattern = Pattern.compile("(?=(d.*?o.*?a))");
Matcher matcher = pattern.matcher("ondjswxaeqobdnoajezbpfrehanxi");
while (matcher.find()) {
for (int i = 1; i <= matcher.groupCount(); i++) {
    if (shortest == null || matcher.group(i).length() < shortest.length()) {
        shortest = matcher.group(i);
    }
}

[thelvin]

Joli trick avec le positive lookahead pour forcer find() à avancer caractère par caractère .

Mais il est inutile de boucler sur les groupes : il n'y en a qu'un, et c'est le numéro 1. Il suffit de faire ça :

Code :

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

1
2
3
4
5
6
7
8
9
String shortest = null;
Pattern pattern = Pattern.compile("(?=(d.*?o.*?a))");
Matcher matcher = pattern.matcher("ondjswxaeqobdnoajezbpfrehanxi");
while (matcher.find()) {
  String candidate = matcher.group(1);
  if (shortest == null || candidate.length() < shortest.length()) {
    shortest = candidate;
  }
}

Comme je n'aime pas trop les tricks et je préfère garder un programme simple à lire et qui exprime clairement mon intention, voici comment j'aurais fait sans modifier la regex :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
String shortest = null;
Pattern pattern = Pattern.compile("d.*?o.*?a");
Matcher matcher = pattern.matcher("ondjswxaeqobdnoajezbpfrehanxi");
 
int start = 0;
while (matcher.find(start)) {
  String candidate = matcher.group();
  if (shortest == null || candidate.length() < shortest.length()) {
    shortest = candidate;
  }
  start = matcher.start()+1;
}

Pareil, find() n'avance que d'un caractère à la fois.

[tchize_]

Ou plus simplement

Code :

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

1
2
3
4
5
Pattern pattern = Pattern.compile("d[^d]*?o.[^a]*?a");
Matcher matcher = pattern.matcher("fondjswxaeqobdnoajezbpfrehanxi");
while (matcher.find()) {
  system.out.println(matcher.group());
}

[thelvin]

Hum. Je comprends pas trop l'intérêt du [^a], je suppose que c'est une erreur d'inattention.

Mais sinon je vois l'idée : "invalider la recherche si on trouve un d entre le premier d et le o, pour s'assurer d'avoir le plus court."
Ouais, ok, mais alors... Entre le o et le a, il faut rejeter toute séquence valide de d suivi de o... Ça peut se faire, avec un negative lookbehind. Mais "plus simplement" je suis pas convaincu.

La regex donnée en exemple ne trouve pas le plus court. (précisément parce qu'on tombe sur une séquence de d suivi de o, qui elle-même est suivie d'une autre séquence de d suivi de o, avant de tomber sur le a.)

[tchize_]

Ha oui tiens, au temps pour moi

[CosmoKnacki]

Une solution sans lookarounds:

Code :

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

d[^do]*o[^da]*(?>d[^oa]*)*a

[thelvin]

Euh, ouais, mais indépendant ou lookaround, la différence en termes de clarté...

Enfin je dis ça, l'indépendant est là que pour des raisons de performances finalement. La même solution serait d[^do]*o[^da]*(d[^oa]*)*a... Qui marche !
Mais à nouveau, en termes de clarté...