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.

[abbescr7]

je l'ai déja modifier merci , ta pas une idéee pour le deuxieme probleme , ?

[joel.drigo]

Le problème vient de ton split : String[] parts= matcherr.group(2).trim().split("");. Avec ça, tu obtiens comme parts : S, |, b, c, |, j, | et b.
Avec split("\\|"), tu obtiendras S, bc, j et b...

[abbescr7]

je fais comment pour avoir juste

Code :

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

les premiers de S sont a, les premeirs de A,les premeirs de B,e

j'ai fais sorti le println de la boucle toujours rien !!

[joel.drigo]

C'est de ça que tu parles :

Code :

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

1
2
3
if( listVt.contains(parts[i])){
        	   System.out.println("les premiers de " +matcherr.group(1) + "sont " + parts[i] );
           }

En faisant :

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
 
Matcher matcherr = Pattern.compile("(.+)->(.+)").matcher(chaine);
 
  boolean first=true;
  while( matcherr.find() ) {
 
      if ( first ) { // pour avoir une virgule, sauf pour le premier
           first=false;
      } 
      else {
           System.out.print(", ");
      }
      String[] parts = matcherr.group(2).trim().split("|");
      System.out.print("les premiers de " +matcherr.group(1) + "sont");
      boolean firstpart=true;
      for(String part : parts) {
          if ( firstpart ) { // pour avoir une virgule, sauf pour le premier
              firstpart=false;
          } 
          else {
              System.out.print(", ");
           }
           if( listVt.contains(part)){
        	  System.out.print(part );
           }
      }
 
   }
   System.out.println();

Ou avec un stream en Java 8 :

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
StringBuilder stringBuilder=new StringBuilder();
Matcher matcherr = Pattern.compile("(.+)->(.+)").matcher(chaine);
  while( matcherr.find() ) {
            if ( stringBuilder.length()!=0 ) {
                  stringBuilder.append(", l");
            }
            else {
                  stringBuilder.append("L");
            }
            stringBuilder.append("es premiers de ");
            stringBuilder.append(matcherr.group(1));
            stringBuilder.append(" sont ");
            String[] parts = matcherr.group(2).trim().split("\\|");
            stringBuilder.append(Arrays.stream(parts).filter(part-> listVt.contains(part)).collect(Collectors.joining(", ")));
   }
System.out.println( stringBuilder );

[abbescr7]

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
32
33
34
35
36
37
38
39
40
41
42
43
Matcher matcherr = Pattern.compile("(.+)->(.+)").matcher(chaine);
  		boolean first=true;
  		while( matcherr.find() ) {
 
  	      if ( first ) {
  	           first=false;
  	      } 
  	      else {
  	           System.out.print(",");
  	      }
 
  			String[] parts=	matcherr.group(2).trim().split("\\|");
  			System.out.print("les premiers de " +matcherr.group(1) + "sont");
  	        boolean firstpart =  true;
  	      int i ;
  			for( i=0  ; i<parts.length ; i++ )
 
  				 if ( firstpart ) { // pour avoir une virgule, sauf pour le premier
  		              firstpart=false;
  		          } 
  		          else {
  		              System.out.print(", ");
  		           }
 
		if( (listVt.contains(parts[i])) ){
			System.out.print(parts[i] );           } 
           else if (listVn.contains(parts[i])){
        	   System.out.print("les premiers de" + parts[i] );        	   
 
           }
           else if(parts[i].length()!=1){
        	   String mot = parts[i].substring(0, 1);
 
        	   { if( (listVt.contains(mot)) ){
        		   System.out.print(mot );               } 
               else if (listVn.contains(mot)){
            	   System.out.print("les premiers de" + mot );             	   
 
               }}
 
           }
 
         }     System.out.println();

ça m'affiche une erreur !

les premiers de S sont, , , java.lang.ArrayIndexOutOfBoundsException: 4

[joel.drigo]

Ton for n'a pas de bloc (accolades) : c'est quelque chose que tu peux voir rapidement en soignant ton indentation. Et tu aurais une erreur de compilation si tu avais comme je te l'ai dit utilisé un foreach au lieu d'un for !

[abbescr7]

Salut
grâce a vous je l'ai presque fini ! seulement j'ai un soucis et j'a pas trouvé de solution
voila ce que j'ai comme affichage

Code :

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

1
2
3
4
5
6
7
8
9
 
les premiers de E sont {les premiers de S} 
les premiers de S sont {a, les premiers de A, e} 
les premiers de A sont {les premiers de S, les premiers de B, j, b} 
les premiers de B sont {d}
les suivants de S sont $
les suivants de A sont les premiers de B
les suivants de S sont les suivants de A 
les suivants de B sont b

je veux avoir comme résultat :

Code :

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

1
2
3
4
5
6
7
8
9
 
les premiers de E sont {a,e,j,b,d} 
les premiers de S sont {a, b,d, e} 
les premiers de A sont {a,e,d, j, b} 
les premiers de B sont {d}
les suivants de S sont $
les suivants de A sont {d}
les suivants de S sont {d}
les suivants de B sont b

voila mon code

code des premiers

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
32
33
34
35
36
37
38
39
40
41
42
43
	Matcher matcherr = Pattern.compile("(.+)->(.+)").matcher(chaine);
  		boolean first=true;
  		while( matcherr.find() ) {
 
  			if ( first ) {
   	           first=false;
   	      } 
   	      else {
   	           System.out.print("}");
   	      }
 
  			String[] parts=	matcherr.group(2).trim().split("\\|");
  			System.out.print(" \n les premiers de " +matcherr.group(1) + "sont {");
  	        boolean firstpart =  true;
  	      int i ;
  			for( i=0  ; i<parts.length ; i++ ){
 
  				 if ( firstpart ) { 
  		              firstpart=false;
  		          } 
  		          else {
  		              System.out.print(", ");
  		           }
 
		if( (listVt.contains(parts[i])) ){
			System.out.print(parts[i] );           } 
           else if (listVn.contains(parts[i])){
        	   System.out.print("les premiers de " + parts[i] );        	   
 
           }
           else if(parts[i].length()!=1){
        	   String mot = parts[i].substring(0, 1);
 
        	   { if( (listVt.contains(mot)) ){
        		   System.out.print(mot );               } 
               else if (listVn.contains(mot)){
            	   System.out.print("les premiers de " + mot );             	   
 
               }}
 
           }
 
         }    } System.out.println("}");

Code des suivant

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
32
33
34
 
         Matcher matcherrr = Pattern.compile("(.+)->(.+)").matcher(chaine);
 
   		while( matcherrr.find() ) {
 
   			String[] parts=	matcherrr.group(2).trim().split("\\|");
   			int i ;
   			for( i=0  ; i<parts.length ; i++ ){
   				if(parts[i].length()!=1){
   					String mot = parts[i].substring(0, 1);
 
   					String mott = parts[i].substring(1, 2);
 
   		   				if((listVn.contains(mot)) && (listVt.contains(mott))){
 
   		   					System.out.println(" les suivants de "+ mot + " sont " + mott);
 
 
   		   			}
   		   				else if ((listVn.contains(mot)) && (listVn.contains(mott))){
 
   		   					System.out.println(" les suivants de " + mot + " sont les premiers de " + mott);
   		   				}
   				}
   				else if((parts[i].length()==1)&& (listVn.contains(parts[i]))){
   				System.out.println(" les suivants de " + parts[i] + " sont les suivants de "+ matcherrr.group(1) );
 
   				}
 
     			}
 
 
 
   		}