Problème sur les Regexs

Version imprimable

12/01/2008, 12h22
Elendhil

Problème sur les Regexs
Voila j'ai un dico avec 360k mots:

Et je veux pouvoir tester avec chaque mot si l'on trouve le motif du mot dans mon pattern . Et si oui ou commence le motif du mot.

ex :
Code:

1 2 3 4 5 6 Pattern p= Pattern.compile(".br.c....ba...."); Matcher m = p.matcher("broc"); m.find(); m= p.matcher("ballon"); m.find();
Sauf que la c'est l'inverse de ce que je veux faire moi ce que je voudrais c'est ca :
Code:

1 2 3 4 5 6 7 Pattern p1= Pattern.compile("broc"); Pattern p2= Pattern.compile("ballon"); Matcher m = p1.matcher(".br.c.....ba..."); m.find(); m=p2..matcher(".br.c.....ba..."); m.find()
Problème c'est que la chaine passée en paramètre pour lui ce sont des points
et p.matcher(Pattern mot) ca existe pas snif.

Je pense qu'il doit bien avoir une solution mais je ne vois pas comment faire.
12/01/2008, 12h26
djo.mos

Bonjour,
:koi: ... veux tu reformuler s'il te plaît ?

:merci:
12/01/2008, 12h40
Elendhil

En gros j'ai une liste de mot par exemple: {ballon, broc,ect...} (dans mon appli la liste de mot est de 360 000).

je veux savoir si cette chaine de caractere existe dans mon pattern:

mon pattern c'est ca : ".br.c....ba...." sachant que le '.' représente n'importe quel caractère, en faite il vaudrait mieux [a-z] enfin c'est le même principe.

Donc la je voudrais que ca me dise oui la chaine ballon existe dans le pattern , elle commence à l'index 9. Ou encore la chaine broc existe bien dans le pattern elle commence a l'index 1.

Voila je sais pas si c'est plus clair.
12/01/2008, 12h49
djo.mos

Ok,
Là, je ne crois pas qu'il y'a une solution efficace (à moins d'extraire toutes les séquences possibles du pattern et de parcourir les 360k mots pour les vérifier avec chaque sous-pattern ... les possibilités sont énormes).
A moins donc que tu trouves un moyen efficace de scinder ton pattern.
Au fait, d'où vient ce pattern (bizarroïde) ?
12/01/2008, 13h05
Elendhil

bah c'est une ligne d'un plateau de scrabble , ca pourrait etre n'importe quelle lettre avec des espaces .

bon c'est pas très joli et ça suppose que tu parcours tes 360k mots pour chaque ligne... mais bon c'est peut-être un début

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
String[] patterns = {"([b\\.][r\\.][o\\.][s\\.])",
    "([b\\.][r\\.][o\\.][c\\.])",
    "([b\\.][a\\.][l\\.][l\\.][o\\.][n\\.])",
    "([b\\.][a\\.][l\\.][l\\.][o\\.][n\\.][s\\.])"};
String line = ".br.c.....ba....";
for (String pattern : patterns) {
    Pattern p = Pattern.compile(pattern);
    Matcher m = p.matcher(line);
    if (m.find()){
        if (m.groupCount() > 0){
            for (int i = 1; i <= m.groupCount(); i++) {
               // Mais reste le probleme des mots uniquement composes de points...
                    if (m.group(i).replaceAll("\\.", "").length() > 0){
                        System.out.println("pattern "+pattern+" "+m.group(i)+", start: "+m.start(i)+", end: "+m.end(i));
                    }
               }
        }
    }
}

12/01/2008, 14h31
Elendhil

Oui merci gardyen c'est un bon début ca !! , trop bonne idée , j'y aurai pas pensé . Merci
13/01/2008, 17h07
Elendhil

Gardyen pourquoi par exemple quand on a le mot : ([b\\.][a\\.][s\\.][e\\.])

ta méthode trouve uniquement la premiere occurence avec 4 points mais pas la deuxieme avec "ba.." ? count renvoi toujours 1 je ne comprend pas pourquoi.

Merci
14/01/2008, 10h55
Gardyen

parce qu'il faut utiliser

Code:

while (m.find){

et non pas if comme je l'avais mis :D

quand je disais que c'était un début :aie:

Oui c'est ce que j'ai fait . Et le groupCount sert a rien dans mon cas , vu qu'il ya que 2 parenthèses ?

Le debut a bien avancé , j'applique ta technique , en fonction de n'importe quelles lettres placées sur le plateau , je prend en compte les lettres du chevalet et je gere les lettres en double.Et je teste si le mot placé a pas une lettre collé derriere ou devant pour avoir bien tout les mots réellement plaçable.

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
 
	public ArrayList<String> findAllPossibilitiesOnOneLine(String line, String lettersBoard, String lettersPlayer)
	{
 
	char [] tmpLetters=lettersBoard.toCharArray(),baseChar;
	StringBuilder strBuff= new StringBuilder();
			Pattern p;
			Matcher m;
			String base;
			int i=0,j=0,z=0;
			boolean test,testValidate=true;
			ArrayList<String> listWords = new ArrayList<String>();
			int word=0;
 
			for (Integer key : dico.keySet()) {
				if(key<=lettersBoard.length()){
				for(String pattern : dico.get(key)){
					strBuff.setLength(0);
					tmpLetters= lettersBoard.toCharArray();
					test=true;
					strBuff.append('(');
					for(j=0;j<pattern.length();j++){
						if(!containsChar(tmpLetters,pattern.charAt(j))){
							j+=15;
							test=false;
						}else{
 
							strBuff.append('[').append(pattern.charAt(j)).append("\\.]");
						}
					}
					if(test){
						strBuff.append(')');
						p = Pattern.compile(strBuff.toString());
						m = p.matcher(line);
					    while(m.find()){
					        if (m.groupCount()> 0){
					        	testValidate= true;
					        	base =m.group(i).replaceAll("\\.", "");
					               if (base.length()>0){
					                	  baseChar = base.toCharArray();
					                  	  for(z=0;z<pattern.length();z++){
					                  		  if(!containsChar(baseChar,pattern.charAt(z))){
					                   			  if(!lettersPlayer.contains(Character.toString(pattern.charAt(z)))){
					                   				 testValidate=false;
					                   			  }
					                   		  }
					                   	  }
					                   	  if((m.start(i)!=0)){
					                   		  if((line.charAt((m.start(i)-1))!='.')){
					                   			  			testValidate = false;
					                   		  }
					                   	  }
					                   	 if((m.end(i)!=15)){
					                   		  if((line.charAt(m.end(i))!='.')){
					                   			  			testValidate = false;
					                   		  }
					                   	  }
					                   	  if(testValidate){
					                   		 listWords.add(pattern);
					                   		 System.out.println("Motif: "+strBuff+" trouvé sur la ligne: "+line+ 
					                   				 "occurence du motif: "+m.group(i)+" start à: " +m.start(i)+" finis à: "+m.end(i));
					                   		 word++;
					                   	  }
					                }
					        }
					    }
					}
				}
				}
			}
			System.out.println("Il ya "+word+" mots possible avec \n");
		return listWords;

Le seul problème c'est que c'est un peu trop lent. Il faut a peu pres 180 à 200
milisecondes sur mon pc pour executer la fonction.