Générateur d'une séquence avec expression régulières

Version imprimable

16/10/2012, 10h05
deuzef68

Générateur d'une séquence avec expression régulières

Bonjour à tous

j'aimerai pouvoir programmer un bout de code qui me permettrait de générer une (des) séquence(s) de nombres...cette (ces) séquence(s) pourrait être définis dans le "style" des expressions régulières...
de matière light bien sur...
On donnerait l'expression pour la génération de la séquence et la taille de la séquence.
dans le style
genere("(12){3}",3) donnerait -> 12 12 12
genere("(12){3}",2) donnerait -> 12 12

genere("(12)+",5) donnerait -> 12 12 12 12 12 12

genere("(12){3}(5)+",7) donnerait -> 12 12 12 5 5 5 5

on pourrait préciser (avec les expressions) le début de la séquence...la fin et bien évidemment le milieu

ainsi on pourrait écrire une expression du "style" ^((12){2})5+$(33)

genere("^((12){2})5+$(33)",7) donnerait -> 12 12 5 5 5 5 33
genere("^((12){2})5+$(33)",10) donnerait -> 12 12 5 5 5 5 5 5 5 33

etc...

Je n'ai pas d'idées sur le "comment" le développer... les expressions régulières sont ici des exemples... et pas réellement définies pour l'instant...
il faudrait voir ce qui serait le mieux... si quelqu'un a une idée de spécification...

Pensez-vous qu'il y aurait déjà un code qui reprendrait ce principe, ou s'y approcherait ?
Si non comment quelqu'un aurait-il une idée ?

Merci d'avance

Fred
16/10/2012, 11h48
DotNetMatt

Pas simple à première vue ! En tout cas je pense que ce thread pourra t'aiguiller : http://stackoverflow.com/questions/3...-regex-pattern

Tu trouveras sur ce thread une série d'articles qui parlent de ceci plus en détails : http://stackoverflow.com/questions/4...ion-in-c-sharp (dans la première réponse)

Je ne sais pas si ça t'aidera, mais ça a l'air de correspondre à ce que tu cherhces à faire ;)
16/10/2012, 12h31
deuzef68

Citation:

Envoyé par Matt07

Pas simple à première vue ! En tout cas je pense que ce thread pourra t'aiguiller : http://stackoverflow.com/questions/3...-regex-pattern

Merci...oui apparemment ça renvoie sur
Xeger:
"Think of it as the opposite of regular expression matchers. This library allows you to generate text that is guaranteed to match a regular expression passed in"

Citation:

Envoyé par Matt07

Tu trouveras sur ce thread une série d'articles qui parlent de ceci plus en détails : http://stackoverflow.com/questions/4...ion-in-c-sharp (dans la première réponse)

Je ne sais pas si ça t'aidera, mais ça a l'air de correspondre à ce que tu cherhces à faire ;)

...là désolé mais je n'ai pas trouvé ce que tu voulais me dire...la première réponse ?

Je vais regarder déjà Xeger... même si le java je ne raffole pas... ça me donnera peut être une piste en tout cas...
si tu as d'autres idées je suis preneur
merci d'avance

Petite précision... il est évident que je ne cherche pas à gérer tous les cas possibles comme dans la syntaxe des expressions régulières...
juste les opérateurs:
-commençant par
-se terminant par

les parenthèses de groupement
le quantificateur +
le quantificateur borné {n}

Il me semble que cela suffit pour générer une suite

Fred
16/10/2012, 12h48
DotNetMatt

Ce n'était peut-être pas très clair en effet :aie: Regarde la réponse de Leniel Macaferi, qui commence par "Take a look at my series of posts about this subject:".

Ensuite il donne une série de liens qui renvoie vers une implémentation en C#.

Tu peux utiliser un outil de microsoft : Rex

Code:

1
2
3
4
5
6
7
8
            string regex = @"^([0-9]{1,5})$";
            RexSettings settings = new RexSettings(regex) { k = 10, encoding = CharacterEncoding.ASCII };
            var results = RexEngine.GenerateMembers(settings);
 
            foreach (var result in results)
            {
                Console.WriteLine(result);
            }

Il faut compiler ton programme en x86 pour que ca fonctionne.

16/10/2012, 13h02
MaximePalmisano
Je pense pas que ça soit si compliqué que ça si tu veux gérer que des cas assez "basiques".

Déjà je te conseille de partir en TDD, vu que tu as déjà pas mal de usecases, ça permettra d'avoir une non reg constante pour un coût assez faible.

Ensuite, est ce que tu pourrais écrire une spec plus clair que des usecases histoire que l'on comprenne à quoi sert chaque "opérateur" ?
Code:

1 2 genere("(12){3}",3) donnerait -> 12 12 12 genere("(12){3}",2) donnerait -> 12 12
Je vois pas bien l'utilité du {3} la en fait
16/10/2012, 13h22
deuzef68
Citation:
Envoyé par MaximePalmisano

Code:

1 2 genere("(12){3}",3) donnerait -> 12 12 12 genere("(12){3}",2) donnerait -> 12 12

Je vois pas bien l'utilité du {3} la en fait
Pour essayer de faire simple... on va dire qu'il serait possible de générer plusieurs suite de nombres...

l'expression pourrait être la même mais la longueur (taille ?) augmenterait

exemple 1
pour (12){3} (sachant qu'implicitement la séquence aura une taille max de 3 ici)

pour
taille 1 -> 12
taille 2 -> 12 12
taille 3 -> 12 12 12
taille 4 -> 12 12 12 ici on a pas de 4ème nombre bien évidement

exemple 2
si on a 12+... la séquence est infinie bien sur mais on on ne lui demande pas d'afficher une séquence infinie... la série sera une suite de 12...

exemple 3
(12 13 14)+ (la syntaxe est ici à "l'essai" car non totalement défini... c'est pour l'exemple)

taille 1 -> 12
taille 2 -> 12 13
taille 3 -> 12 13 14
taille 4 -> 12 13 14 12
taille 5 -> etc à l'infini....

Fred

Citation:
Envoyé par meziantou
Tu peux utiliser un outil de microsoft : Rex
Code:

1 2 3 4 5 6 7 8 string regex = @"^([0-9]{1,5})$"; RexSettings settings = new RexSettings(regex) { k = 10, encoding = CharacterEncoding.ASCII }; var results = RexEngine.GenerateMembers(settings); foreach (var result in results) { Console.WriteLine(result); }
Il faut compiler ton programme en x86 pour que ca fonctionne.
j'ai bien été sur le lien... c'est un outil en version web... et au download on récupère un outil en ligne de commande... je ne vois pas de source ici

Fred

16/10/2012, 14h37
meziantou

Citation:

Envoyé par deuzef68

j'ai bien été sur le lien... c'est un outil en version web... et au download on récupère un outil en ligne de commande... je ne vois pas de source ici

Fred

En effet il n'y a pas de source. Tu peux tout de même ajouter l'exécutable en référence de ton projet et utiliser le code que j'ai indiqué précédemment.
16/10/2012, 15h07
deuzef68

Citation:

Envoyé par MaximePalmisano

Je pense pas que ça soit si compliqué que ça si tu veux gérer que des cas assez "basiques".

Déjà je te conseille de partir en TDD, vu que tu as déjà pas mal de usecases, ça permettra d'avoir une non reg constante pour un coût assez faible.

Je viens de lire un article sur la TDD :
http://despeludo.developpez.com/arti...estsunitaires/
bon ben ok... pas sur que ça m'aide :)

Citation:

Envoyé par MaximePalmisano

Ensuite, est ce que tu pourrais écrire une spec plus clair que des usecases histoire que l'on comprenne à quoi sert chaque "opérateur" ?

ok pour une spécif plus précise... c'est un premier jet

*nombres constitué de chiffres acceptés pour les valeurs

*les caractères espace ou virgule sont acceptés pour séparer chaque valeurs de la série

*l'expression régulière devra obligatoirement commencer par un "^"
et se terminer par un "$"

*les parenthèses "(" et ")" englobe un groupe d'une ou plusieurs valeurs ou d'autres groupes de valeurs
ex: (12) ou (12 13) ou ((12 13) (14 15)) (ce dernier cas ne sert pas à grand chose ici mais avec le "+" ou "{n}" associé si)

*le "+" (de 1 à n répétition) s'applique sur une valeur
ou un groupe de valeurs si il y a une parenthèse englobant ce groupe
ex:
12+ répétition du 12
(12 13 )+ répétition de la séquence 12 13...

*le {n} s'applique sur une valeur
ou un groupe de valeurs si il y a une parenthèse englobant ce groupe
ex:
12{3} répétition du "12" 3 fois
(12 13){5} répétition de la séquence "12 13" 5 fois

on peux demander n'importe quel taille de séquence à générer... mais si l'expression ne le permet pas on n'ajoute rien

ex: ^12$
séquence de longueur 1 donnera -> 12
séquence de longueur 2 donnera -> 12
séquence de longueur 3 donnera -> 12

par contre ^(12 )+$ (il y a un espace c'est voulu)
séquence de longueur 1 donnera -> 12
séquence de longueur 2 donnera -> 12 12
séquence de longueur 3 donnera -> 12 12 12
etc

Fred
16/10/2012, 15h12
deuzef68

Citation:

Envoyé par meziantou

En effet il n'y a pas de source. Tu peux tout de même ajouter l'exécutable en référence de ton projet et utiliser le code que j'ai indiqué précédemment.

Ok

Mais les RexSettings et RexEngine.GenerateMembers

il ne va pas hurler à la génération ? il les connait comment ????

question annexe... tu les as trouvé où ces définitions ?

Fred
16/10/2012, 15h21
meziantou

Citation:

Envoyé par deuzef68

Mais les RexSettings et RexEngine.GenerateMembers
il ne va pas hurler à la génération ? il les connait comment ????

Il les connait car on ajoute une référence au projet.
http://msdn.microsoft.com/fr-fr/libr...v=vs.100).aspx

Citation:

Envoyé par deuzef68

question annexe... tu les as trouvé où ces définitions ?
Fred

En décompilant (le programme n'est pas très gros). Je n'ai pas trouvé de doc sur ces points là. J'ai peut être mal cherché.
16/10/2012, 16h07
MaximePalmisano

Citation:

bon ben ok... pas sur que ça m'aide

Je pense que si. Ca te permettra d'être sur de pas péter une fonction en en rajoutant une autre. De plus, tu sauras exactement le périmètre couvert par ton outil à un instant t et tu seras sur que les use cases que tu as déterminés seront faits.

Le sujet me parait assez intéressant, j'en ferais peut être un dans mon coin si j'ai 2 minutes.

Je vois ce que tu cherches à faire maintenant, et je confirme que ça ne doit pas être si complèxe que ça.

La plus grosse difficulté sera d'écrire une bonne fonction de parsing récursif de la chaîne originale et le reste est assez simple à mon avis. (Récursive pour décomposer les sous ensemble entre paranthèses)
16/10/2012, 21h36
deuzef68

Citation:

Envoyé par MaximePalmisano

Je vois ce que tu cherches à faire maintenant, et je confirme que ça ne doit pas être si complèxe que ça.

La plus grosse difficulté sera d'écrire une bonne fonction de parsing récursif de la chaîne originale et le reste est assez simple à mon avis. (Récursive pour décomposer les sous ensemble entre paranthèses)

je suis en train de regarder du côté de lex/yacc j'ai ressorti ma doc sur la grammaire pour yacc... à creuser

Fred
16/10/2012, 21h40
deuzef68

Citation:

Envoyé par meziantou

En décompilant (le programme n'est pas très gros). Je n'ai pas trouvé de doc sur ces points là. J'ai peut être mal cherché.

tu utilise quoi comme décompilo ?
16/10/2012, 21h41
meziantou

J'utilise dotpeek
http://www.jetbrains.com/decompiler/

Bon, ça m'a turlupiné alors j'ai essayé de le faire rapidos, voici ce que ça donne:

Code:

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
 
private const string SEPARATOR = " ";
		private const string INFINITE_MULTIPLIER = "+";
		private const string PATTERN = @"\(([0-9]+)\)" + @"(\{[0-9]+\}|\+|)";
 
		public string Generate(string numberRegex, int maxLength)
		{
			if(numberRegex == null)
				throw new ArgumentNullException();
 
			if(numberRegex == string.Empty)
				throw new ArgumentException();
 
			if(maxLength <= 0)
				throw new ArgumentOutOfRangeException();
 
			return Parse(numberRegex, maxLength)
				.Aggregate((s1, s2) => s1 + SEPARATOR + s2);
		}
 
		private IEnumerable<string> Parse(string numberRegex, int maxLength)
		{
			List<string> result = new List<string>();
			MatchCollection matches = Regex.Matches(numberRegex, PATTERN);
 
			if(matches.Count == 0)
				throw new ArgumentException();
 
			foreach(Match match in matches)
			{
				if(match.Groups.Count < 2)
					throw new ArgumentException();
 
				string number = match.Groups[1].Value;
				string multiplierString = match.Groups[2].Value;
 
				int multiplier = GetMultiplier(multiplierString, maxLength);
 
				for(int i = 0; i < multiplier; i++)
					result.Add(number);
			}
 
			return result.Take(maxLength);
		}
 
		public string GetFirstNumberFrom(string s)
		{
			Match match = Regex.Match(s, "^[0-9]+");
 
			if(!match.Success)
				throw new ArgumentException();
 
			return match.Value;
		}
 
		public int GetMultiplier(string s, int maxLength)
		{
			if(s.Length == 0)
				return 1;
 
			if(s.EndsWith(INFINITE_MULTIPLIER))
				return maxLength;
 
			string multiplier = Regex.Match(s, "[0-9]+").Value;
			return int.Parse(multiplier);
		}

Et les tests:

Code:

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
 
private NumberRegex regex;
 
		[TestInitialize]
		public void Init()
		{
			regex = new NumberRegex();
		}
 
		[TestMethod]
		public void Generate_12_3_3()
		{
			string output = regex.Generate("(12){3}", 3);
			Assert.AreEqual("12 12 12", output);
		}
 
		[TestMethod]
		public void Generate_12_3_2()
		{
			string output = regex.Generate("(12){3}", 2);
			Assert.AreEqual("12 12", output);
		}
 
		[TestMethod]
		public void Generate_12_Plus_2()
		{
			string output = regex.Generate("(12)+", 2);
			Assert.AreEqual("12 12", output);
		}
 
		[TestMethod]
		public void Generate_12_Plus_5()
		{
			string output = regex.Generate("(12)+", 5);
			Assert.AreEqual("12 12 12 12 12", output);
		}
 
		[TestMethod]
		public void Generate_12_Plus_4_5_Ignore()
		{
			string output = regex.Generate("(12)+(4)", 5);
			Assert.AreEqual("12 12 12 12 12", output);
		}
 
		[TestMethod]
		public void Generate_12()
		{
			string output = regex.Generate("(12)", 5);
			Assert.AreEqual("12", output);
		}
 
		#region Exception cases
 
		[TestMethod]
		[ExpectedException(typeof(ArgumentOutOfRangeException))]
		public void Generate_MaxLength_Negative()
		{
			regex.Generate("12", -2);
		}
 
		[TestMethod]
		[ExpectedException(typeof(ArgumentOutOfRangeException))]
		public void Generate_MaxLength_Zero()
		{
			regex.Generate("12", 0);
		}
 
		[TestMethod]
		[ExpectedException(typeof(ArgumentException))]
		public void Generate_StringEmpty()
		{
			regex.Generate("", 5);
		}
 
		[TestMethod]
		[ExpectedException(typeof(ArgumentNullException))]
		public void Generate_StringNull()
		{
			regex.Generate(null, 5);
		}
 
		#endregion

C'est pas super bien écrit et les cas sont loin d'être tous gérés mais ça te donne une base pour commencer à voir ce que tu veux faire réellement. Bon courage :)

17/10/2012, 08h33
deuzef68

Citation:

Envoyé par MaximePalmisano

Bon, ça m'a turlupiné alors j'ai essayé de le faire rapidos, voici ce que ça donne:

C'est pas super bien écrit et les cas sont loin d'être tous gérés mais ça te donne une base pour commencer à voir ce que tu veux faire réellement. Bon courage :)

Merci c'est sympa... je vais regarder tout ça dès que j'aurais un moment pour l'intégrer.

Encore merci.

Question subsidiaire: ayant ressorti ma doc lex/yacc il me semble (sauf si on me dit le contraire) qu'on doit pouvoir aussi le réaliser en lex/yacc.
Il y a t'il un lex/yacc pour c# ?

Fred