package regexp;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class TP1 {
	// les // representent un code ou des expressions régulières alternatives

	public static void test1() {
		 String patternString = "\\d+";
		 String text = "rge5r43";
		 Pattern p = Pattern.compile(patternString);
		 Matcher m = p.matcher(text);
		 System.out.println("R.E.: " + patternString);
		 System.out.println("Test: " + text);
		 boolean found = m.find();
		 if (found) {
		 System.out.println("Position début : " + m.start());
		 System.out.println("Avant : " + text.substring(0,m.start()));
		 System.out.println("Sélection : " + m.group());
		 System.out.println("Position fin : " + m.end());
		 System.out.println("Après : " + text.substring(m.end()));
		 }
		}
	  public static void q_1() {
		    /**
		     * 1. Nombre entier positif ou négatif.
		     * Un nombre entier ne contient pas de point et ne commence pas par un zéro
		     * (sauf 0).
		     */
		  	String patternString = "\\b0\\b|[+-]?[1-9]\\d*";
		  	//String patternString = "\\p{Blank}(\\b0\\b|[\\+\\-]?\\b[1-9][0-9]*\\b)\\p{Blank}";
		    //String patternString = "0|-?[1-9][0-9]*";
		  	String text = "2749  ; 0 ; -300 ; 00"; 
		    Pattern p = Pattern.compile(patternString);
		    Matcher m = p.matcher(text);
		    while (m.find()) {
		      System.out.println("Sélection : " + m.group());		     
		    }
		  }
	  public static void q_2() {
		    /**
		     * 2. Un nombre strictement décimal.
		     * Il possède une partie décimale séparée par un point et celle-ci est non
		     * nulle.
		     */
		  	String patternString = "[+-]?\\d+[.](\\d*[1-9]\\d*)";
		  	//String patternString = "\\p{Blank}[+-]?(0|[1-9]\\d*)\\.\\d*[1-9]+\\p{Blank}";
		  	String text = " -256.08 ; 45.302 ; 21.00 ; 0 ; -300 "; 
		    Pattern p = Pattern.compile(patternString);
		    Matcher m = p.matcher(text);
		    while (m.find()) {
		      System.out.println("Sélection : " + m.group());
		    }
		  }
	  public static void q_3() {
		    /**
		     * Un mot contenant « le » strictement à l’intérieur.
		     */		    
		  	String patternString = "\\w*\\Ble\\B\\w*";
		    //String patternString = "\\p{Alpha}+le[a-zA-Z]+";
		    //String patternString = "(?i)([a-z]+[l][e][a-z]+)";
		    String text = " le ; parlement ; lent ; le ;alerte; cycle; lelelele ";
		    Pattern p = Pattern.compile(patternString);
		    Matcher m = p.matcher(text);
		    while (m.find()) {
		      System.out.println("Sélection : " + m.group());
		    }
		  }
	  public static void q_4() {
		    /**
		     * Une suite de chiffres à l’intérieur d’un mot.
		     */
		  	String patternString = "(?i)\\w+?(\\d+)\\w+";
		  	//String patternString = "\\b\\p{Alpha}+\\d{2,}\\p{Alpha}+\\b";
		  	//String patternString = "\\b\\p{Alpha}+\\d+\\p{Alpha}+\\b";

		    String text = " Ax25By ; 225 ; 4567 ; _e78e ; ";
		    Pattern p = Pattern.compile(patternString);
		    Matcher m = p.matcher(text);
		    while (m.find()) {
		      System.out.println("Sélection : " + m.group());
		    }
		  }
	  
	  public static void q_5() {
		    /**
		     * JSON
		     * Les deux nombres du tableau valeur du champ args dans une chaîne JSON.
		     */
		    String patternString = "\"args\"\\p{Blank}*:\\p{Blank}*\\[(\\d+),(\\d+)\\]";
		    String text = "{\"argss\" : [10,20]}";
		    System.out.println("le texte"+ text);
		    Pattern p = Pattern.compile(patternString);
		    Matcher m = p.matcher(text);
		    if (m.find()) {
		      System.out.println("1: " + m.group(1));
		      System.out.println("2: " + m.group(2));
		      System.out.println(" : " + m.group());
		    }
		  }
	  public static void q_6() {
		    /**
		     * Une suite de caractères quelconques précédée d’un caractère qui n’est pas un
		     * chiffre
		     * et d’un chiffre et suivie par deux chiffres :
		     * une suite soit la plus longue possible, soit la plus courte possible.
		     */
		    String patternString = "(?<=\\D\\d).+(?=\\d{2,})"; // le plus grand
		    //String patternString = "(?<=\\D\\d).+?(?=\\d{2,})"; // passif (le plus petit)
		    String text = "25.3a512b.3.5135";
		    Pattern p = Pattern.compile(patternString);
		    Matcher m = p.matcher(text);
		    if (m.find()) {
		      System.out.println(": " + m.group());
		    } else
		      System.out.println("not found");
		  	}

		  public static void q_7() {
		    /**
		     * Un mot ne contenant ni a ni e.
		     */
		    String patternString = "(?i)\\b[b-df-z]+\\b";
		    String text = " pourrir ";
		    // String text = "train";
		    Pattern p = Pattern.compile(patternString);
		    Matcher m = p.matcher(text);
		    if (m.find()) {
		      System.out.println("Résultat true: " + text);
		    } else
		      System.out.println("Résultat false: " + text);
		  }
		  public static void q_8() {
			    /**
			     * Un mot composé de deux parties identiques
			     * chacune comprenant de deux à cinq lettres.
			     */
			    String patternString = "(?i)\\b(\\w{2,5})\\1\\b";
			    String text = "borabora";
			    Pattern p = Pattern.compile(patternString);
			    Matcher m = p.matcher(text);
			    if (m.find()) {
			      System.out.println("Résultat true: " + text);
			    } else
			      System.out.println("Résultat false: " + text);
			  }

			  public static void q_9() {
			    /**
			     * Un mot avec exactement un i, et au moins un e.
			     */
			    String patternString = "(?i)\\b(?=[a-hj-z]*i[a-hj-z]*\\b)(?=\\w*e)[a-z]+\\b";
			    String text = "minimiser";
			    Pattern p = Pattern.compile(patternString);
			    Matcher m = p.matcher(text);
			    if (m.find()) {
			      System.out.println("Résultat true: " + text);
			    } else
			      System.out.println("Résultat false: " + text);
			  }

			  public static void q_10() {
			    /**
			     * Un mot commençant et se terminant par les deux mêmes caractères.
			     */
			    String patternString = "(?i)(\\w)(\\w)\\w*(\\1\\2|\\2\\1)";
			    String text = "resserrer";
			    // String text = "repartir";
			    Pattern p = Pattern.compile(patternString);
			    Matcher m = p.matcher(text);
			    if (m.find()) {
			      System.out.println("Résultat true: " + text);
			    } else
			      System.out.println("Résultat false: " + text);
			  }

			  public static void exam2012() {
			    /**
			     * compter les mots sans h ni z avec exactement un i et au moins un e
			     */
			    String patternString = "(?i)\\b(?=[a-gj-y]*i[a-gj-y]*\\b)(?=\\w*e)[a-gi-y]+\\b";
			    String text = "La  Gazelle, le Lion, le Hibou, le Singe, le Mistigri, la Licorne";
			    Pattern p = Pattern.compile(patternString);
			    Matcher m = p.matcher(text);
			    int nb = 0;
			    while (m.find()) {
			      nb++;
			      System.out.printf("Mot : %s\n", m.group());
			    }
			    System.out.printf("Nombre d'occurences : %d\n", nb);
			  }

			  public static void exam2015() {
			    /**
			     * Donner une expression régulière et un programme permettant d'afficher
			     * les mots d'une chaîne, de longueur 5 ou 7 avec au centre une lettre
			     * entourée de deux voyelles identiques
			     * 
			     */
			    String patternString = "\\b\\w([aeiou])[a-z]\\1\\w\\b|\\b\\w{2}([aeiou])[a-z]\\2\\w{2}\\b";
			    String text = "lever la tete devant le canal et rester present";
			    Pattern p = Pattern.compile(patternString);
			    Matcher m = p.matcher(text);
			    System.out.println("R.E.:  " + patternString);
			    System.out.println("Test:  " + text);
			    while (m.find()) {

			      System.out.println("Sélection : " + m.group());
			    }
			  }

	  public static void main(String[] args)  {
		  //test1();
		  //q_1();
		  //q_2();
		  //q_3();
		  //q_4();
		  //q_5();
		  q_6();		  
		  }
	
}