Citation : bluestorm

on est d'accord, c'est bizarre

Citation : bluestorm

Il a besoin de la taille parce qu'il alloue un gros tableau (char t[fsize(file)], iirk !) de cette taille là pour y coller tout le fichier.

Citation : 21

et vous nous inondez de termes un peu inutile...

Citation : Shareman

En quoi une solution plus naïve mais moins efficace serait plus utile

Citation : 21

shareman, quand je parlais de termes inutiles c'était un peu tout votre dialogue, perso je comprend rien à ce que vous dîtes...

Citation : Arthurus

Citation : 21

shareman, quand je parlais de termes inutiles c'était un peu tout votre dialogue, perso je comprend rien à ce que vous dîtes...

Si tu juges inutiles tout ce que tu ne comprends pas, ça c'est une autre histoire...

Citation : shareman

Une solution (en C99 là) ressemblant de loin à celle d'rz0, utilisant un automate à états :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <ctype.h>

#define LSIZE 2000

int fsize(FILE* f) {
    fseek(f, 0, SEEK_END);
    long r = ftell(f);
    fseek(f, 0, SEEK_SET);
    return r;
}

void getcont(char* dest, FILE* file) {
    while(fgets(dest, LSIZE, file))
        dest += strlen(dest);
}

int main(int argc, char** argv) {
    if(argc < 3)
        return 1;

    FILE* file;
    if(!(file = fopen(argv[2], "r")))
        return 1;

    char t[fsize(file)], *begin, *i;
    int column = 0, row = 1, state = 0, occ = 0;

    getcont(t, file);

    for(i = t; *i != '\0'; ++i, ++column) {
        if(!state) {
            if(isalnum(*i))
                state = 1, begin = i;
            if(*i == '\n')
                ++row, column = -1;
        }
        else if(state == 1) {
            if(!isalnum(*i))
                state = 2;
        }
        else { // state == 2
            char ret = *(i-1);
            *(--i) = '\0';
            if(!strcmp(argv[1], begin))
                printf("Case %i : row %i, column %i \n", ++occ, row, column-strlen(begin));
            if(ret == '\n')
                ++row, column = 0;
            state = 0, --column;
        }
    }

    fclose(file);

    return 0;
}

if(!strcmp(argv[1], begin))

xxxxxxx toto

int toto(char *texte, char *clef)

La grammaire :

Calculs de directeurs :

Code :

#ifndef _PROG_H
#define _PROG_H

int lig = 1, col = 0;
char cour;
FILE* fich;
char motcour[100];
char* motcherche;
int occ = 0;
int i=0;

void next(void);
void texte(void);
void mot(void);
void BB(void);
void sep(void);
void AA(void);
void car(void);
void charsep(void);

#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "prog.h"

void next(void) {
	cour = fgetc(fich);
	if (cour == '\n') {
		lig++;
		col=0;
	}
	col++;
}

void texte(void) {
	if (isalnum(cour)) {
		i=0;
		mot();
		motcour[i]='\0';
		if(!strcmp(motcour,motcherche)) {
			occ++;
			printf("Occ : %d, lig : %d, col : %d\n",occ,lig,col-strlen(motcour)-1);
		}
		sep();
		texte();
	} else if (cour != EOF) {
		printf("Erreur interne func texte\nlig : %d, col : %d\n",lig,col);
		exit(1);
	}
}

void mot(void) {
	if (isalnum(cour)) {
		car();
		BB();
	}
}

void BB(void) {
	if (isalnum(cour)) {
		mot();
	}
}

void sep(void) {
	if (!isalnum(cour)) {
		charsep();
		AA();
	}
}

void AA(void) {
	if ((cour != EOF) && !isalnum(cour)) {
		sep();
	}
}

void car(void) {
	if (isalnum(cour)) {
		motcour[i++]=cour;
		next();
	} else {
		printf("Erreur interne func car\nlig : %d, col : %d\n",lig,col);
		exit(1);
	}
}

void charsep(void) {	
	if (!isalnum(cour)) {
		next();
	} else {
		printf("Erreur interne func charsep\nlig : %d, col : %d\n",lig,col);
		exit(1);
	}
}

int main (int argc,char* argv[]) {
	if (argc != 3) {
		printf("Erreur de paramètre\n");
		exit(1);
	}
	fich=fopen(argv[2],"r");
	if (!fich) {
		printf("Erreur de lecture du fichier\n");
		exit(1);
	}
		
	motcherche = argv[1];
	next();
	texte();
	printf("%d occurence(s) trouvée(s)\n",occ);
	return 0;

}

Résultat :

arthurus@arthurus:~/exozero$ ./prog les foo
Occ : 1, lig : 3, col : 36
Occ : 2, lig : 4, col : 1
Occ : 3, lig : 4, col : 15
Occ : 4, lig : 5, col : 50
4 occurence(s) trouvée(s)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

__attribute__((noreturn)) void die(const char* message) {

	fprintf(stderr, "Erreur ! %s\n", message);
	exit(EXIT_FAILURE);

}

int main(int argc, char** argv) {

	if (argc != 3)
		die("Mauvais nombre d'arguments.");

	char* zSearchedWord = argv[1];
	unsigned zWordMaxSize = strlen(zSearchedWord),
			zCount = 0, zWordSize = 0;

	{
		unsigned i;
		for(i = 0; i < zWordMaxSize; i++)
			if (!isalpha(zSearchedWord[i]))
				die("Argument avec un mauvais formattage.");
	}

	char* zFoundWord = calloc(zWordMaxSize+1, sizeof(char));

	if (zFoundWord == NULL)
		die("Impossible d'allouer de la mémoire.");

	FILE* zFile = fopen(argv[2], "r");

	if (zFile == NULL) {
		free(zFoundWord);
		die("Impossible d'ouvrir le fichier.");
	}

	printf("Recherche du mot `%s' dans le fichier `%s'.\n\n", zSearchedWord, argv[2]);

	unsigned zRow = 1, zCol = 1;

	while(1) {

		const int zChar = fgetc(zFile);

		if (zChar == EOF) {
			printf("\n%d occurence%s au total.\n", zCount, zCount < 2 ? "" : "s");
			break;
		}

		if (isalpha(zChar)) {
			if (zWordSize < zWordMaxSize)
				zFoundWord[zWordSize++] = (char)zChar;
		} else {
			if (zWordSize == zWordMaxSize && strcmp(zSearchedWord, zFoundWord) == 0)
				printf(
						"Occurence %d:\tLigne: %d\tColonne: %d\n",
						++zCount,
						zRow,
						zCol - zWordSize - 1
				);
			zWordSize = 0;
			if (zChar == '\n')
				zRow += (zCol = 1);
		}

		zCol++;

	}

	fclose(zFile);
	free(zFoundWord);

	return EXIT_SUCCESS;

}

Citation : 21

J'suis sur que mon code n'est pas si mal finalement, vu les défauts mentionnés.

Citation : candide

Autre défaut mais de nature un peu différente : tu ne proposes pas une fonction, genre

int toto(char *texte, char *clef)

qui retourne le nombre d'occurrences de clef dans texte et affiche leur position ligne, colonne. Au passage, on pourrait travailler avec un pointeur sur une fonction qui envoie un flux d'octets plutôt qu'avec un tableau texte.
Personnellement il me semble indispensable de travailler avec des fonctions (qui résolvent le problème posé) plutôt qu'avec du code placé en vrac dans la focntion main(), ce qui rend souvent le code non réutilisable et/ou non autonome et/ou trop spécifique.

Citation : candide

C'est bien beau de sortir des automates mais quand on voit le coût exhorbitant de l'algorithme, on se dit que tu ferais mieux de te concentrer sur des questions plus basiques.

Citation : candide

*) tes if imbriqués sont inutilement compliqués, cf. lignes 35 et 36 (utiliser plutot un &&),

Citation : candide

*) l'instruction return 1; dans la fonction main() n'est pas portable,

Citation : candide

*) j'ai l'impression que les deux en-têtes #include <stdlib.h> et #include <fcntl.h> ne servent à rien.

Citation : shareman

Mais d'autres codes postés ici sont beaucoup plus "lourd" en terme de mémoire que le mien, je ne vois pas pourquoi faire une fixation sur mon code.

Citation

Et tu as très raison, pour le fait que j'aurais du utiliser realloc dans la boucle ce qui, en plus, m'aurait éviter de retailler le tableau à la fin.

Citation : 21

Ah bah si j'aurais fais comme lui, pourquoi quel est le problème avec cette technique ?

Citation : blueblue

C'est quoi le problème avec les listes chaînées ? Je comprends pas pourquoi les programmeurs en C se feraient dévorer vivants plutôt que d'utiliser cette structure de donnée

#include <stdio.h>
#include <ctype.h>



unsigned grep (FILE* fp, const char* search)
{
    const char* s;
    unsigned ret = 0, co, li;
    int c, prev = ' ';
    for (co=1, li=1; (c = fgetc(fp)) != EOF; co++)
    {
        if (c == '\n')
            li++, co = 0;
        if ( c == *search && isspace(prev) )
        {
            s = search;
            while ( (c = fgetc(fp)) == *++s);
            if (!*s && isspace(c))
                printf("Occurrence %u -> ligne %u, colonne %u\n", ++ret, li, co);
        }
        prev = c;
    }
    return ret;
}

int main(int argc, char** argv)
{
    FILE* fp = NULL;
    if (argc == 3)
        if ( (fp = fopen(argv[2], "rb")) != NULL )
        {
            printf("Trouve %u fois.", grep(fp, argv[1]));
            fclose(fp);
        }
    return 0;
}

Citation

Faut toujours trouver le juste milieu entre vitesse de calcul et la mémoire, la manière d'alexx est la mieux pour la mémoire, mais la pire pour le calcul donc.

#include <stdio.h>
#include <ctype.h>
#include <string.h>

typedef struct
{
	FILE *f;

	char car;

	char chn[10];

	int lig,
	    col;

	int cpt,
	    size,
	    flag;

} Structure;

void aff_occ(Structure *S)
{
	printf("Occurence ligne %d et colonne %d \n",
	                  S->lig,     S->col - S->size);
}

void test_spc(Structure *S)
{
	(S->col)++;

	if('\n' == (S->car))
	{
		(S->lig)++;
		(S->col) = 0;
	}
}

void test_occ(Structure *S)
{
	if(S->car == S->chn[S->cpt])
		S->cpt++;

	else
	{
		S->cpt  = 0;
		S->flag = 0;
	}

	if(S->cpt == S->size)
	{
	   aff_occ(S);
	   S->cpt = 0;
	}
}

int main(void)
{
    Structure S = {fopen("txt.txt", "r"), ' ', "les", 1, 0, 0, 0, 1};

    strncat(S.chn, " ", 1);

    S.size = strlen(S.chn);

	while((S.car = fgetc(S.f)) != EOF)
	{
		test_spc(&S);

		if(S.flag)
		   test_occ(&S);

		if(!S.flag)
		    S.flag = isspace(S.car);
	}

	fclose(S.f);

    return 0;
}

les lesives les les lesles sales     
 les les

Citation

il devrait être possible de détecter la chaine 'les' dans '_les_'

Citation : 21

yoch, je vois deux boucles imbriqués, est ce que dés que tu trouve le premier élément de la chaine à rechercher tu fais un while pour savoir si tout le reste est correct ?

Citation : 21

En fait ce while fait en sorte que l'on peut se passer des états alors.

Citation : Camp0us

PS : @ yoch > Avec le fichier texte suivant ton programme affiche un peu ce qu'il veut :

#include <stdio.h>
#include <ctype.h>



unsigned grep (FILE* fp, const char* search)
{
    const char* s;
    unsigned ret = 0, co, li, nb_col;
    int c, prev = ' ';
    for (co=1, li=1; (c = fgetc(fp)) != EOF; co++)
    {
        if (c == '\n')
            li++, co = 0;
        if ( c == *search && isspace(prev) )
        {
            s = search;
            for (nb_col=1; (c = fgetc(fp)) == *++s; nb_col++);
            if (c == '\n')
                li++, co = 0;
            if ( !*s && (isspace(c) || c == EOF) )
                printf("Occurrence %u -> ligne %u, colonne %u\n", ++ret, li, co);
            co += nb_col;
        }
        prev = c;
    }
    return ret;
}

int main(int argc, char** argv)
{
    FILE* fp = NULL;
    if (argc == 3)
        if ( (fp = fopen(argv[2], "rb")) != NULL )
        {
            printf("Trouve %u fois.", grep(fp, argv[1]));
            fclose(fp);
        }
    return 0;
}

Citation : yoch

Citation : 21

En fait ce while fait en sorte que l'on peut se passer des états alors.

De toute manières, il me semble que mon code reprend le principe d'automate.

Citation : yoch

J'ajoute simplement une vérification que le caractère précèdent l'occurrence trouvée est bien un espace.

Citation : candide

Ton algorithme (de même que celui de rz0) est optimal, en O(1), on fait tout à la volée.

Citation : GurneyH

Citation : candide

Ton algorithme (de même que celui de rz0) est optimal, en O(1), on fait tout à la volée.

J'ai peur de ne pas comprendre...
La fichier est parcouru entièrement une fois non ?
Ce n'est pas O(N), avec N le nombre du caractère du fichier ?