Discussion :

[abbescr7]

Bonsoir tout le monde

pour cette grammaire je veux calculer les premiers et les suivant de chaque Vn

Code :

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

1
2
3
4
 
S -> a|A|B|e
A -> S|bc|j|b
B -> d

grâce a l'aide d'un cher amis j'ai pu détecter les Vn et les Vt

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
 
Matcher matcher = Pattern.compile("(.+)->(.+)").matcher(chaine);
 
        List<String> listVn = new ArrayList<>();
        List<String> listVtpro = new ArrayList<>();
        while( matcher.find() ) { 
           listVn.add( matcher.group(1).trim() ); 
           listVtpro.add( matcher.group(2).trim() );
        }
 
        List<String> listVt = new ArrayList<>();
 
           for(String Vtpro : listVtpro) {
 
           for(String vt :  Vtpro.split("")) {
      if(( !listVn.contains(vt)) &&( !listVt.contains(vt))&&  (!vt.equals("|"))      ){
	   listVt.add(vt);
      }
           }
 
        }
           System.out.println( " les Vn sont ");
  		 for( int i  = 0; i < listVn.size(); i++)
  		    {
  		    System.out.println( listVn.get(i));
  		    } 	
  		 System.out.println( " les Vt sont ");
  		  for( int i  = 0; i < listVt.size(); i++)
  		    {
  		    System.out.println( listVt.get(i));
  		    }

quelqu'un a une idée !?

[joel.drigo]

C'est quoi exactment les premiers et les suivants ? Peux-tu montrer le résultat que tu devrais obtenir ?

[abbescr7]

Bonjour Joel

pour les premiers on regarde toujours ceux qui sont après la fleche mais avec des condition par exemple

S -> a|A|B|e
A -> S|bc|j|b
Vn : S, A, B
Vt : a,b,c,d,e,j

si le caractère après la flèche est un Vt alors le premiers du Vn avant la fleche est ce meme Vt
si le caractere apres la fleche est un Vn et que ce n'est pas le même qu'avant la fleche alors les premiers du Vn celui qu'avant la flèche sont les premiers du Vn trouvé
si après la flèche on trouve une chaine de caractère on prend juste le premiers caractère et on applique les deux précédentes règles

plus clair : (j'espere que tu n t'es pas perdu )

S -> a|A|B|e

on a S qui donne soit a ou bien A ou bien B ou bien e

donc les premiers de S sont (a et e) vu qui sont des vt et premiers ( S) = premiers (A) = premiers (B)

A -> S|bc|j|b

on A qui donne S ou bien bc ou bien j ou bien b

on commence par les vt

A qui donne j ou bien b

les premiers de A sont (b et j)

A qui donne bc on prend juste le premier caractere "b" c'est un vt et il existe deja dans les premier de A

A qui donne S : donc les premiers de A sont les premiers de S


donc on a :
les premier de S={a,e}
les premier de A= {b,j}

et comme on a dans la première règle de production (S->A) :
les premier de S sont les premier de A
on ajoute : les premiers de S ={a,e,b,j}
et dans la deuxième A->S
on ajoute aussi : les premiers de A={b,j,a,e}

[joel.drigo]

Et donc, quel est le problème pour encoder ça en Java ?

[abbescr7]

voila ce que j'ai fait

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
Matcher matcherr = Pattern.compile("(.+)->(.+)").matcher(chaine);
 
  		while( matcherr.find() ) {
 
  			String[] parts=	matcherr.group(2).trim().split("");
  			for(int i = 0 ; i<=parts.length ; i++ )
  			{
 
           if( listVt.contains(parts[i])){
        	   System.out.println("les premiers de " +matcherr.group(1) + "sont " + parts[i] );
           } 
  			}
         }

pour Les premiers de S sa marche
seulement jutse apres y a une erreur

Code :

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

1
2
3
les premiers de S sont a
les premiers de S sont e
java.lang.ArrayIndexOutOfBoundsException: 7

[abbescr7]

c bon c reglé seulement j'ai un souci avec le A

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
Matcher matcherr = Pattern.compile("(.+)->(.+)").matcher(chaine);
 
  		while( matcherr.find() ) {
 
  			String[] parts=	matcherr.group(2).trim().split("");
  			for(int i = 0 ; i<parts.length ; i++ )
  			{
 
           if( listVt.contains(parts[i])){
        	   System.out.println("les premiers de " +matcherr.group(1) + "sont " + parts[i] );
           } 
  			}
         }

voila ce qui m'affiche

Code :

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

1
2
3
4
les premiers de A sont b
les premiers de A sont c
les premiers de A sont j
les premiers de A sont b

alors que que les premiers de A sont seulement b et j

[joel.drigo]

Ta boucle for provoque cette ArrayIndexOutOfBoundException, à la fin :

Code :

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

1
2
for(int i = 0 ; i<=parts.length ; i++ )
  			{

Les indices allant de 0 à parts.length-1, il n'y a pas d'élément d'indice parts.length : il faut donc faire i<parts.length. C'est pour ça qu'il est préférable d'utiliser un forEach, lorsque tu n'as pas besoin de l'indice dans le traitement.

Code :

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

for(String part : parts) {

Ainsi,tu n'auras aucun risque de ArrayIndexOutOfBoundException, et c'est plus lisible en plus.