Пример #1
0
int main()
{
        char *target = "abababaababacb";
        char *pattern = "ababacb";
        char *p = NULL;
        char *test = "ababababca";
        int *ta = NULL;
        int i = 0;

        ta = (int *)malloc(strlen(test) *sizeof(int));

        compute_prefix_function(test, ta);

        printf("Target    : %s\nPattern : %s\n", target, pattern);
        p = kmp_matcher(target, pattern);
        if (p)
                printf("Pattern found at position : %d\n", p - target);
        else
                printf("Pattern not found!\n");


        for(i = 0; i < 10; i++)
        {
                printf("%d\t", *(ta + i));
        }

        printf("\n");
        
                
	return 0;
}
Пример #2
0
int kmp_matcher(char *t, int tsize,  char *p, int psize) 
{
	int i, q = -1;
	int *pi = compute_prefix_function(p, psize);
	
	for (i = 0; i < psize; i++) 
		printf("%d\t", pi[i]);
	printf("\n");

	if (pi == NULL) 
		return -1;
	
	for (i = 0; i < tsize; i++) {
		while (q > -1 && p[q+1] != t[i]) 
			q = pi[q];
		if (t[i] == p[q+1])
			q++;

		if (q == psize - 1) {
			free(pi);
			return i-q;
		}
	}
	free(pi);
	return -1;
}
Пример #3
0
// {{{ int main(int argc, char *argv[])
int main(int argc, char *argv[])
{
	struct stat fst;

	// check parameter
	if(argc != 3 && argc != 5){
		printf("Usage: ./%s DIR PATTERN [MATCH REPLACE]\n", PROGNAME);
		exit(0);
	}else if(argc == 5){
		needreplace = true;
		match_str = argv[3];
		replace_str = argv[4];
		pi = compute_prefix_function(match_str);
	}else{
		needreplace = false;
	}
	// chdir to argv[1]
	if(chdir(argv[1]) == -1){
		fprintf(stderr, "Can't chdir to %s: ", argv[1]);
		perror(NULL);
		exit(1);
	}
	pattern = argv[2];
	// insert i-node of argv[1] into hash table
	if(stat(".", &fst) == -1){
			fprintf(stderr, "Can't get stat of %s: ", argv[1]);
			perror(NULL);
	}else{
		insert(fst.st_ino, fst.st_dev);
	}
	// trace directory
	gogodir();
	return 0;
} // }}}
Пример #4
0
char *
kmp_matcher(const char *target, const char *pattern)
{
        int i = 0;
        int j = 0;
        int targetlen;
        int patternlen;
        int *next = NULL;
    
        targetlen = strlen(target);
        patternlen = strlen(pattern);
 
        next = (int *)malloc(patternlen * sizeof(int));
        if (NULL == next)
                return NULL;
 
        compute_prefix_function(pattern, next);
 
        while (i < targetlen && j < patternlen)
        {
                if (-1 == j || target[i] == pattern[j])
                {
                        ++i;
                        ++j;
                }
                else
                {
                        j = next[j];
                }
                
        }

        free(next);
        next = NULL;
 
        if (j >= patternlen)
        {
                
                return (char *)&target[i - patternlen];
        }
        else
        {
                return NULL;
        }
        
}
Пример #5
0
int kmp_matcher(char *source, int n, char *patt, int m) {
    int *pi = (int *)malloc(sizeof(int) * m);
    compute_prefix_function(patt, pi, m);
    int count = 0;
    int i, k = 0;

    for(i=0;i<n;i++) {
        while(k!=0 && patt[k] != source[i])
            k = pi[k-1];
        if(patt[k] == source[i]) {
            if(++k >= m) {
                count++;
                k = pi[k-1];
            }
        }
    }
    return count;
}
int kmp(char *target, int tsize, char *pattern, int psize)
{
	int i;
	int *pi = compute_prefix_function(pattern, psize);
	int k = -1;
	if (!pi)
		return -1;
	for (i = 0; i < tsize; i++) {
		while (k > -1 && pattern[k+1] != target[i])
			k = pi[k];
		if (target[i] == pattern[k+1])
			k++;
		if (k == psize - 1) {
			kfree(pi);
			return i-k;
		}
	}
	kfree(pi);
	return -1;
}
Пример #7
0
int kmp(const char *target, int tsize, const char *pattern, int psize)
{
	int i;
	int *pi = compute_prefix_function(pattern, psize);
	int k = -1;
	if (!pi)
		return -1;
	for (i = 0; i < tsize; i++) {
		while (k > -1 && pattern[k+1] != target[i])
			k = pi[k];
		if (target[i] == pattern[k+1])
			k++;
		if (k == psize - 1) {
			//free(pi);
			printf("Found match at %d\n",i-k);
			//return i-k;
		}
	}
	free(pi);
	return -1;
}
Пример #8
0
int i_getKmpStrings(){

    unsigned int i=0,j;
    FILE * kmpReadFp;
 
    kmpReadFp=fopen(PATTERNFILELOCATION,"r");
    if(NULL == kmpReadFp){
    	printf("Error in opening probable Strings file\n");
    	return 0;
    }else{
     
        kmpFind=(kmp**)malloc(sizeof(kmp*)*ui_numStrings);
    
        for(i=0;i<ui_numStrings;i++){
            kmpFind[i]=(kmp*)malloc(sizeof(kmp)*ui_numStrings);
            kmpFind[i]->kmpStrings=(char*)malloc(sizeof(char)*(PATTERNLENGTH+1));
            kmpFind[i]->pi=(int*)malloc(sizeof(int)*(PATTERNLENGTH+1));
            memset((void *)kmpFind[i]->kmpStrings,'\0',PATTERNLENGTH+1);
            memset((void *)kmpFind[i]->pi,0,4*(PATTERNLENGTH+1));
        }
        
        for(i=0;i<ui_numStrings;i++){
            fscanf(kmpReadFp,"%s %u \n",kmpFind[i]->kmpStrings+1,&(kmpFind[i]->exp_count));
            kmpFind[i]->pi=compute_prefix_function(kmpFind[i]->kmpStrings,i);
        }

        for(i=0;i<ui_numStrings;i++){
            for(j=1;j<PATTERNLENGTH+1;j++){
#if KMP_DEBUG
                printf("%d\t",kmpFind[i]->pi[j]);
#endif
            }
        }
        
        
        return 1;
    }
    
}