Calcul les premiers et les suivant java

Version imprimable

Bonsoir tout le monde

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

Code:

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:

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 !?

09/01/2016, 03h52
joel.drigo

C'est quoi exactment les premiers et les suivants ? Peux-tu montrer le résultat que tu devrais obtenir ?
09/01/2016, 09h41
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}
09/01/2016, 13h27
joel.drigo

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

voila ce que j'ai fait

Code:

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:

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

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

Code:

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:

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

09/01/2016, 14h17
joel.drigo
Ta boucle for provoque cette ArrayIndexOutOfBoundException, à la fin :
Code:

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:

for(String part : parts) {

Ainsi,tu n'auras aucun risque de ArrayIndexOutOfBoundException, et c'est plus lisible en plus.
09/01/2016, 14h19
abbescr7

je l'ai déja modifier merci , ta pas une idéee pour le deuxieme probleme , ?
09/01/2016, 14h28
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...
09/01/2016, 18h16
abbescr7

je fais comment pour avoir juste

Code:

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 !!

C'est de ça que tu parles :

Code:

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

En faisant :

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
 
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:

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 );

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
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

09/01/2016, 19h23
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 !

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:

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:

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:

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:

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) );
 
   				}
 
     			}
 
 
 
   		}