Discussion :

[rgomes]

Hello,

Je recherche une expression régulière pour trouver les patents (numéro de brevets) dans du texte libre sachant qu'un patent number à le format suivant :

LLnnnnn
LLnnnnnL
LLnnnnnLn

où L est une lettre [A-Z] et n un entier entre 0 et 9.

exemple :
"La recherche brevet a permis d'isoler fr14521 fr45877A 999 AU50000B1." donnerait :
fr14521
fr45877A
AU50000B1

Merci pour toute aide !

Un début de piste :
([A-Z]{2})([0-9]{1,})([A-Z][0-9]|[A-Z]+[^[A-Z]{2}])?

[visiwi]

Salut,

Ne serait-ce pas quelque chose comme ça ?

Code :

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

[a-zA-Z]{2}[0-9]{5}[a-zA-Z]{0,1}[0-9]{0,1}

[rgomes]

Hélas non, car
fr7227965 au2006230693
me donne :
FR7227965A uniquement

Comment mettre la condition que si 2lettres+au moins 1 nombre alors ne pas le prendre, c'est un nouveau "patent number" ?

Merci

[visiwi]

Et bien du donne les formats suivant :

LLnnnnn
LLnnnnnL
LLnnnnnLn

J'ai compris :

2 lettres + 5 chiffres + 0 ou 1 lettres + 0 ou 1 chiffre

Ce qui visiblement n'ai pas le cas, puisque tu dit que au2006230693 est un patent. Qu'elle est la règle précise qui définit un patent ?

Serait-ce :
2 lettres + n chiffres + 0 ou 1 lettre + 0 ou 1 chiffre

[rgomes]

Primo, merci pour ton aide !
Alors :

FR123 est valide
FR123A est valide
FR132A1 est valide

Voila les 3 cas possibles, par contre si tu as FR123FR456 il ne faut pas avoir juste FR123F, car apres ensuite il ne reste donc que R456 et le match failed.

Il faut la condition supplémentaire : "si apres la serie de chiffre on a une lettre, on ne la prend que si elle n 'est pas suivie par une autre lettre et au moins un chiffre", car sinon c 'est le début d'un nouveau pn...

[adiGuba]

Salut,


Ce que visiwi veut dire c'est qu'il faudrait connaitre le format exact même en langage parlé !

Ceci afin de déterminer le pattern de tes patents.


Ce n'est qu'ensuite que l'on pourra utiliser les negative lookahead/lookbehind pour interdire de découper les mots...

a++

[visiwi]

C'est surement très clair pour toi qui connait ces "patents", mais pour moi ça ne l'est pas. Je ne connais pas les "patents".

Cela correspond donc au schéma suivant :
2 lettres + n chiffres + 0 ou 1 lettre + 0 ou 1 chiffre
Non ?

Plutôt que de donner des exemples, essai de décrire ce qui caractérise une chaine de caractère de "patent".

Ensuite quand tu dit :

Voila les 3 cas possibles, par contre si tu as FR123FR456 il ne faut pas avoir juste FR123F, car apres ensuite il ne reste donc que R456 et le match failed.

C'est que tu peux avoir 2 patents qui se suivent et qui ne sont pas séparés par un espace ?
FR123
FR456
qui peuvent se trouver dans ton texte sous la forme "FR123FR456" ?

[rgomes]

Le format exact :

CCxxxxxxK

CC : code pays sur 2 lettres
xxxxxxx : numéro de patent, série de chiffres enter 1 et 13 chiffres
K : kind, une lettre ou 1 lettre+1chiffre

[rgomes]

Oui exactement, les pn peuvent se suivre.

Je peux avoir :
"FR13456FR999" => FR13456 et FR999
''FR000A1FR999" => FR000A1 et FR999
''FR000AFR999" => FR000A et FR999

[rgomes]

Comment exprimer la règle :
- conserver une lettre qui si elle est suivie de 2 lettres ?

\w+(?!\w{2}) mais ne fonctionne pas..

Merci pour votre aide.

[visiwi]

A mon avis ce n'est pas possible uniquement avec les expressions régulières. Puisque tu doit regarder si une règle est rempli en dhors du découpage (deux lettres après).
Mais je ne suis pas un pro de Regex.

De mon point de vue, cela doit être couplé a un chtit algo.

[visiwi]

Voici un exemple. Ça n'est pas parfait mais cela te sera peut-être utile

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
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
 
public class CutPatents {
 
	private static final String CHAINE = "La recherche brevet a permis d'isoler fr14521 fr45877A*999 AU50000B1. FR13456FR999 et FR000A1FR998 et FR001AFR997";
	private static final String PATTERN1 = "[a-zA-Z]{2}[0-9]{1,13}";
	private static final String PATTERN2 = "[a-zA-Z]{2}[0-9]{1,13}[a-zA-Z]{1}";
	private static final String PATTERN3 = "[a-zA-Z]{2}[0-9]{1,13}[a-zA-Z]{1}[0-9]{1}";
 
	private StringBuilder strBuffer;
 
	private List<String> list = new ArrayList<String>();
 
	public static void main(String[] args) {
		CutPatents cutPatents = new CutPatents(CHAINE);
		cutPatents.scan();
		cutPatents.debug();
	}
 
	public CutPatents(String s) {
		strBuffer = new StringBuilder(s);
	}
 
	public void scan() {
		scan(PATTERN3);
		scan(PATTERN2);
		scan(PATTERN1);
	}
 
	private void scan(String s) {
		System.out.println("");
		System.out.println(s);
		System.out.println(strBuffer);
    	try {
			Pattern pattern = Pattern.compile(s);
			Matcher matcher = pattern.matcher(strBuffer.toString());
			int occurenceFinded = 0;
			while(matcher.find()) {
				occurenceFinded++;
				int start = matcher.start();
				int end = matcher.end();
				if (s == PATTERN2) {
					char c1 = ' ';
					char c2 = ' '; 
					if (strBuffer.length() > end + 1) {
						c1 = strBuffer.substring(end, end + 1).charAt(0);
					} 
					if (strBuffer.length() > end + 2) {
						c2 = strBuffer.substring(end + 1, end + 2).charAt(0);
					}
					if (!Character.isLetter(c1) ||
							(Character.isLetter(c1) && Character.isLetter(c2))) {
						String match = strBuffer.substring(start, end);
						System.out.println("match : " + match);
						list.add(match);
						strBuffer.replace(start, end, getSpaces(match.length()));
					}
				} else {
					String match = strBuffer.substring(start, end);
					System.out.println("match : " + match);
					list.add(match);
					strBuffer.replace(start, end, getSpaces(match.length()));
				}
			}
		} catch (PatternSyntaxException e) {
			e.printStackTrace();
		}      
    }
 
	private String getSpaces(int n) {
		String s = "";
		for (int i = 1 ; i <= n ; i++) {
			s += " ";
		}
		return s;
	}
 
	private void debug() {
		System.out.println("");
		System.out.println(CHAINE);
		System.out.println("");
		for (String s : list) {
			System.out.println(s);
		}
	}
 
}

[rgomes]

Merci pour vos réponses !
J'ai finalement trouvé grace à vous, avec les assertions (que je ne connaissais pas..).

((US(D|RE|PP|H)?)|([A-Z]{2}))([0-9]{1,})(([ABCDHUYST]{0,1}(?=([A-Z]{2})([0-9]{1,})))|(?=[A-Z]{4})|\\b|([ABCDHUYST][0-9]|([ABCDHUYST]\\b)))

Merci encore !

[tchize_]

Merci pour vos réponses !
J'ai finalement trouvé grace à vous, avec les assertions (que je ne connaissais pas..).

((US(D|RE|PP|H)?)|([A-Z]{2}))([0-9]{1,})(([ABCDHUYST]{0,1}(?=([A-Z]{2})([0-9]{1,})))|(?=[A-Z]{4})|\\b|([ABCDHUYST][0-9]|([ABCDHUYST]\\b)))

Merci encore !

J'ai mal à la tête

Sinon, cliquer sur le bouton "résolu" peut être?

[visiwi]

C'est vrai qu'avec regex y a parfois de quoi prendre une aspirine !
Sauf que cela ne semble pas reconnaitre les patents conjoint du type "FR000A1FR998". Seul "FR000A1" est reconnu.

[rgomes]

Non ça marche :
found=> FR000A1
found=> FR998

[visiwi]

Absolument. Milles excuses. J'utilise un outil, et j'ai été si vite que j'ai pas fait gaffe aux échappements... Très intéressant, merci d'avoir poster la réponse.