problème de construction regex

voilà,
j'ai un regex comme suit :
(A) (B)(\sC)?(\sD)?(\sE)?

sauf que il est possible que la chaine à matcher soit :
- A B
- A B C
- A B D
- A B E
- A B D E
- A B C E
- A B D C
...
- A B C D E
- A B D E C
- A B E C D
- ...

en gros que les 3 derniers soient échangeables, c’est à dire formulé dans n'importe qu'elle sens, jusque là ça semble facile,
la difficulté est de faire en sorte que ce ne soit formulé qu'une seule fois, c'est à dire pas de doublon de C D ou E.
et je n'arrive pas à trouver un schéma dans ma tête qui correspondrait à çà. auriez vous des propositions ? merci

Bonjour,
une solution pas très sexy serait de lister les cas possible ainsi :

AB(CDE|CED|DCE|DEC|ECD|EDC)

Pour trouver les différentes combinaisons possibles, tu peux créer une petite fonction qui prend un string en entré, et te sort toutes les possibilités.
Perso quand je galère sur une REGEX, j'utilise http://regexr.com/ :D

J'espère que ma réponse t'aidera ;)

Dans un cas aussi simple l'énumération de toutes les possibilités est en effet envisageable.

Mais quand on en arrive à ce genre de choses, il est temps de se dire que les regex ne feront qu'une partie du boulot et que le programme doit faire le reste.

Exemple, reconnaître avec une regex :

(A) (B)(\struc){0,3}

Avec truc qui peut reconnaître C, D ou E, et vérifier qu'aucun n'apparaît plus d'une fois avec du code qui les compte.

merci pour vos réponses.
j'ai trouvé la solution

^(A) (B)(?:\s((C)|(D)|(E))(?!.*\3))*$

A B -> OK
A B C -> OK
A B C C -> NO
A B C D E -> OK
A B D E D -> NO

bref ça marche bien

Salut,

Tu peux la simplifier en ^A B(?:\s(C|D|E)(?!.*\1))*$. Ce serait même plutôt ^A B(?:\s(C|D|E)(?!.*\1)){0,3}$.

merci déjà essayé mais dans ce cas il ne me donne pas tous les groupes voulus a b c d e

et j'ai essayé avec {0,3}, mais en fait ca revient au même puisque de toute manière, on a que c d e comme choix, donc forcement il y a un doublon si on dépasse la longueur. au final les 2 sont possibles

Citation:

---

Envoyé par dark poulpo

merci déjà essayé mais dans ce cas il ne me donne pas tous les groupes voulus a b c d e

---

Mmm, quoi ? Lesquels ne donne-t-il pas ? (A) est équivalent à A, sauf que ça capture.

(c|d|e) est différent de (c)|(d)|(e) dans ce cas là. dans le 1er il n'en fera qu'un seul groupe au final remplit par le dernier utilisé, dans le 2eme cas, il distinguera bien 3 groupes différents à exploiter. Pour reformuler, ta méthode fonctionne juste pour du match, mais si on veut exploiter le contenu de group() c'est mort car on perd une partie des infos.

Oui, mais enfin, l'important c'est le groupe qu'on référence. Dans ton cas, tu références le groupe 3, donc celui capturé par les parenthèses marquées en rouge :

^(A) (B)(?:\s((C)|(D)|(E))(?!.*\3))*$

Et moi, le groupe 1 :

^A B(?:\s(C|D|E)(?!.*\1))*$

Quelle différence ?

bien déjà je perds le groupe a et B que je ne peux pas donc exploiter. mais passons sur ceux...

je te donne un exemple :

A B C D E -> avec ton exemple j'aurais un seul group remplit avec E, je perds donc C et D que je ne peux pas exploiter du coup.
A B C D E -> avec mon exemple j'ai un groupe pour c, un pour d, un pour e, donc je peux récupérer le contenu de chacun pour l'utiliser.

fait l'essai avec http://www.regexplanet.com/advanced/java/index.html

^(A) (B)(?:\s((C)|(D)|(E))(?!.*\3)){0,3}$


j'ai par exemple en résultat pour A B E C D
0: [0,9] A B E C D
1: [0,1] A -> exploitable
2: [2,3] B -> exploitable
3: [8,9] D
4: [6,7] C -> exploitable
5: [8,9] D -> exploitable
6: [4,5] E -> exploitable

Citation:

---

Envoyé par dark poulpo

A B C D E -> avec mon exemple j'ai un groupe pour c, un pour d, un pour e, donc je peux récupérer le contenu de chacun pour l'utiliser.

---

Ah, mais tu veux dire que tu as besoin de les exploiter ensuite ? Je croyais que tu voulais juste vérifier que ça matche. Effectivement, dans ce cas, là. M'enfin, à un moment, un split(" ") ça marche aussi...

oui ca marche aussi dans le contexte que j'ai donné.

mais là j'ai simplifié, la réalité c'est que ces lettres sont en fait des bouts de phrases, tu comprends mieux pourquoi ce n'est pas si simple.