Discussion :

[ouvrebouteille]

Bonjour à tous,

Je cherche une fonction qui me permette de faire un matching approximatif sur des string en utilisant des regex.

Je m'explique :

String a = Voiture;

Pattern p = Toiture; // les pattern utilise la synthax standard des regex

donc juste la première lettre est différente

j'aimerais bien une fonction qui me renvoie un boolean si le pattern p match avec le string a en autorisant maximum 1 erreur

exemple : matching(1,a,p) me renvera True car 1 erreur comparé au pattern p

et si :

String c = Bordure // ici 3 erreurs comparé au pattern p
matching ( 1,c,p) me renverra false


Est-ce qu'il existe une APi me permettant de faire cela ?



Merci d'avance

[adiGuba]

Salut,


Quel est ton problème précisément ? Il suffit de comparer les chaines caractères par caractères...

a++

[herch]

je doute qu'il y ait une fonction qui fasse ce que tu veux, mais il est facile de la faire toi-même

Quel est ton problème précisément ? Il suffit de comparer les chaines caractères par caractères...

comme ça a été dit, tu compares ta chaine et ton modèle caractère par caractère, et à chaque différence, tu incrémente un compteur d'erreurs
un exemple

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
 
public class MatchingApproximatif
{	
	public static void main(String[] args)
	{
		String modele = "Toiture";
		String strAComparer = "Bordure";
		boolean resultat = matching(modele, strAComparer, 3);
		System.out.println(resultat);
	}
 
	static boolean matching(String modele, String strAComparer, int nbErreursPermis)
	{
		int nbErreursTrouves = 0;
		//On teste s'il y a une différence de taille des 2 chaines, 
		//un caractère de plus ou de moins est une erreur
		int diffTailleChaines = modele.length() - strAComparer.length();
		nbErreursTrouves += Math.abs(diffTailleChaines);
		if (nbErreursTrouves > nbErreursPermis)
			return false;
		//La différence de taille n'est pas supérieur au nombre d'erreurs permis, 
		//on compare les chaines caractère par caractère
		for (int i = 0; i < modele.length(); i++)
		{
			if (modele.charAt(i) != strAComparer.charAt(i))
			{
				nbErreursTrouves++;
				if (nbErreursTrouves > nbErreursPermis)
					return false;
			}
		}
 
		return true;
	}
}

dans l'exemple,
pattern = "Toiture"
chaine = "Bordure"
la fonction renverrait false s'il n'y a qu'une erreur de permis, mais j'ai passé 3, alors elle renverra true

[ouvrebouteille]

en fait ca doit prendre en compte les expressions régulières. http://fr.wikipedia.org/wiki/Expression_rationnelle

Je travaille sur un fichier qui match des patterns dans des séquences protéiques.

Par exemple :

Sattern p = A.[AG][^A]A{2}.{2,4}
String s = ATGGAAATGA

si on essaie de matcher p sur s ca marche ( en utilisant la lib regex )

Par contre si on veut autoriser un mismatch ( une erreur ) , donc par exemple pour le meme pattern , matcher le string TTGGAAATGA, cela ne marchera pas.

Ce que je rechercher c'est une fonction qui prenne ma regex, mon string et un nombre de mismatch permis comme argument et qui me renvoie true ou false si ca match

je sais pas si vous avez compris :p

[jean.2edi]

Je ne pense pas que les expressions rationnelles te servent.
En utilisant les expressions rationnelles, il faudrait à partir de ton motif générer les motifs voisins, avec une erreur, mais leur nombre est déjà grand :

Code :

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

1
2
 
A.[AG][^A]A{2}.{2,4}

donne :

Code :

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

1
2
3
4
5
..[AG][^A]A{2}.{2,4}
A..[^A]A{2}.{2,4}
A.[AG].A{2}.{2,4}
etc...

Si tu veux faire les expressions avec 2 erreurs, le nombre est encore plus grand...

Tu veux plutôt mesurer la distance entre deux chaînes, à la manière d'un correcteur orthographique, ou d'un algorithme de recherche phonétique...
Je ne connais pas de librairie qui fait ça, mais à mon avis tu as deux possibilités :
1. Si les positions de tes protéines sont fixes tu peux :

• Supprimer tous les caractères dont tu ne te sers pas : le deuxième, du septième au dernier...
• Pour chacun des autres, vérifier s'il suit la règle de sa position (1=A, 2=A ou G, etc...) et compter les erreurs.

2. Sinon, utiliser un algorithme de correcteur orthographique : Ecrire un dictionnaire qui contient tous les mots possibles (toutes les séquences !) et pour chacun, calculer la distance avec ta chaîne : tu trouveras des algorithmes par google...

Bon courage !