ok merci Rzo , le sujet a l'air complexe(je suis débutant ) , mais je vais essayer de faire l'exercice , pour m'entrainer .


PS : quand ont a fini c'est ici qu'ils faut poster notre réponse ?

Je vais mettre à jour, rz0.

brain1995 : Oui, c'est ici.

j'ai vraiment du mal a trouver une idée ,

je pensais lire les caractères et dès que je rencontre un L ou l je fais une condition pour que si c'est un e après et encore une condition après pour voir si c'est un s , alors si toutes les conditions sont rénunis alors je met la coordonnées du cruseur dans un tableau qui contient toutes les coordonnées , mais je ne sais pas si ont peut noter dans une variable ou un tableau la position du curseur ? Et a la fin je met toutes les coordonés des "les" .

Merci a celui qui répondras a ma question



EDIT : C'est bon j'ai trouvé la fonction^^

Citation : brain1995

mais je ne sais pas si ont peut noter dans une variable ou un tableau la position du curseur ?

Bon je vois que tu as fait un edit, je suppose que c'est de ftell() que tu parles, mais je voudrai quand même te prévenir que dans cet exo, on n'aura pas besoin de la position du curseur.
Car une colonne se met à 1 dès qu'un saut à la ligne est rencontré.
La position du curseur cependant va continuer à s'incrémenter.

En fait un fichier texte est une très longue chaine... Les sauts à la ligne ne sont que des caractères

Salut tout le monde, j'ai essaye de faire cette fonction , mais la seule chose que mon programme affiche est :

Trouve 0 occurrences

Voici mon code :

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

void zGrep(const char* chemin, const char* chaine, int* occurence, int *tableau);

int main(int argc, char* argv[])
{
	int *tab = NULL, i = 0, *occurence = 0;
	if(argc == 3)
		zGrep(argv[1], argv[2], occurence, tab);
	else
		printf("Erreur sur le nombre de commandes");

	printf("Trouver %ld occurrences.\n", occurence);
	for(i = 0; i < occurence; i++)
		printf("occurrence %ld -> ligne %ld, colonne %ld", *(tab + i + 0), *(tab + i + 1), *(tab + i + 2));

	free(tab);

	system("PAUSE");
	return 0;
}

void zGrep(const char* chemin, const char* chaine, int* occurence, int *tableau)
{
	FILE* fichier;
	int i, j, chaineActuelle[100], tailleChaine, colonne[100], ligne[100], caractereActuel = 0, colonnes = 0, lignes = 0, vrai;
	fichier = fopen(chemin, "r");
	if(fichier != NULL)
	{
		caractereActuel = fgetc(fichier);
		while(caractereActuel != EOF)
		{
			colonnes++;
			if(caractereActuel = '\n')
			{
				lignes++;
				colonnes = 1;
			}
			while(caractereActuel != ' ' && caractereActuel != ',' && caractereActuel != '.')
			{
				tailleChaine++;
				chaineActuelle[tailleChaine] = caractereActuel;
			}
			vrai = 1;
			for(i = 0; i < tailleChaine; i++)
			{
				if(chaine[i] != chaineActuelle[i])
					vrai = 0;
			}
			if(vrai == 1)
			{
				*occurence++;
				ligne[j] = lignes;
				colonne[j] = colonnes;
			}
			else
				printf("Erreur");
			fclose(fichier);
		}
		tableau = malloc(sizeof(int) * *occurence * 3);
		for(i = 0; i < *occurence; i++)
		{
			*(tableau + i) = i;
			*(tableau + i + 1) = colonne[i];
			*(tableau + i + 2) = ligne[i];
		}
	}
}

Si quelqu'un a une idée ? s-v-p

C'est int occurence et zGrep(...,&occurence). Mais je ne sais pas si c'est la seule erreur, je n'ai pas lu le reste du code.

Tu ne derais pas passer un pointeur par paramètre mais plutôt demander à zGrep de retourner un entier contenant la valeur. C'est plus naturel (bien que légèrement moins symétrique avec le traitement de tableau) et ça t'aurais évité le bug.

Tu as 2 erreurs qui se compensent...

La première c'est que tu passes un pointeur nul à ta fonction.

La deuxiemme est quand tu fais :
*occurrence++;

Ceci correspond à
*(occurrence++);

Et non à
(*occurrence)++;

C'est pour ça qu'il n y a pas segfault

Par ailleurs au survol, on dirait que tailleChaine n'est pas initialisé, et que tu oublies de le réinitialiser entre les différents mots.

Tu devrais découper ta grosse boucle en fonctions intermédiaires, au lieu de mettre toutes tes variables et tout ton code en gros tas, ça permettrait de mieux voir ces problèmes.

Voila, j'ai modifié ma fonction pour qu'elle renvoie occurence, mais le résultat reste le même :

Si quelqu'un a une idée ?

Salut,
Tu devrais créer un nouveau sujet...

while(caractereActuel != ' ' && caractereActuel != ',' && caractereActuel != '.')
	{
		tailleChaine++;
		chaineActuelle[tailleChaine] = caractereActuel;
	}

La condition ne change jamais --> Boucle infinie.

Citation : rz0

À mon avis c'est contre nature de vouloir stocker les occurrences ; autant afficher un message pour chaque occurrence trouvée et afficher le total seulement à la fin ; les outils de traitement en flux font ça. Ça évite de se trimbaler une liste ou un tableau.

Personnellement j'ai préféré les stocker car ça me semble beaucoup plus logique et utilisable, crois tu que les logiciels qui ont tous un Ctrl+F ne stocke ça nulle part ?

Citation : shareman

Pour info, j'ai édité le code de la correction de zBrace. Il est plus logique d'évaluer la condition testant si le compteur est strictement négatif uniquement si l'on vient de décrémenter ce dernier.

Ah oui j'avais fait ça moi aussi.

Citation : 21

Citation : rz0

À mon avis c'est contre nature de vouloir stocker les occurrences ; autant afficher un message pour chaque occurrence trouvée et afficher le total seulement à la fin ; les outils de traitement en flux font ça. Ça évite de se trimbaler une liste ou un tableau.

Personnellement j'ai préféré les stocker car ça me semble beaucoup plus logique et utilisable,

Je pense qu'il n'y a pas de réponse unique, ça dépend des besoins. Ce que tu peux faire, c'est donner en paramètre à ta fonction un pointeur sur fonction et ensuite tu insatncie avec printf() ou fprintf() ou autre chose encore.

Citation : 21

crois tu que les logiciels qui ont tous un Ctrl+F ne stocke ça nulle part ?

Fais l'expérience en produisant un énorme fichier texte contenant la chaîne toto un millions de fois, fais une recherche et surveille une variation de la taille mémoire de l'exécutable. Mais, bon, ce que je dis est peut-être naïf.

Moi je dirais que ça dépend, j'ai l'impression que gedit mémorise la recherche complète (à cause de la coloration de la clé) et que le Bloc-Notes lui fait un traitement par lot.

Un éditeur, qui est un logiciel semi-persistant n'a rien à voir avec un outil de traitement de flux à exécution ponctuelle.

Le but d'un éditeur d'éventuellement stocker ce genre de données est de pouvoir les traiter après ; en l'occurrence, un outil de traitement de flux a pour but de transformer le flux en entrée en un autre flux en sortie car le traitement suivant sera effectué par un autre outil sur le flux en sortie.

Un éditeur sera peut-être considéré efficace s'il affiche une coloration particulière de toutes les occurrences du fichier dans les plus brefs délais, et aura donc peut-être intérêt à stocker ces infos quelque part, car l'utilisateur est susceptible d'enchaîner la même recherche incrémentiellement.

Ici, l'outil doit produire des statistiques en sorties, et le plus vite sera le mieux : si tu stockes et affiches à la fin, cela veut dire que quiconque désire travailler sur les données en sortie devra attendre que tu aies finis tout ton travail.

Pour la ptite anecdote, c'est marrant que quelqu'un me reprenne sur ce sujet. Actuellement, je bosse sur mon Summer of Code, sur des outils de traitement de XML en flux ; on pourrait se dire que ça existe déjà tout ça, mais en vérité, la concurrence utilise des modèles types DOM ou hybrides, du coup c'est pas viable pour du flux. Sur un fichier XML représentant un dictionnaire de langue anglaise, mon traitement en flux consomme cent fois moins de mémoire que l'alternative principale, et s'il faut attendre environ quatre secondes pour que l'un ou l'autre des deux programmes finisse, il est possible d'enchaîner en sortie de mon engin un quelconque autre outil qui pourra débuter son travail au fur et à mesure que le mien effectue le sien.

tu es en train de dire qu'un autre programme pourrait récolter les printf et faire autre chose avec ça ensuite en même temps ?
Et ça c'est plus rapide que d'envoyer un tableau une fois le travail terminé ?

Ouep, c'est le principe de fonctionnement du traitement de flux séquentiel, très présent sous Unix, quand tu utilises des pipes (|). Bien sûr, ce n'est pas si simple en pratique, car il y a des tampons de part et d'autre de la chaîne, donc un programme peut attendre la sortie d'un autre ; c'est par blocs. Mais le principe c'est juste de produire au plus vite le résultat voulu. Si le but de ton programme est une sortie texte et rien d'autre alors afficher ce texte en sortie le plus vite possible est dans ton intérêt, tout comme ton éditeur de texte n'attend pas d'avoir scanné le fichier entier pour te montrer les occurrences de la recherche actuelle dans ton champ de vision.

Enfin, voilà mon argument.

Oki je comprend à peu près, mais j'avais jamais pensé à faire ce genre de truc.

Cependant ce que j'ai remarqué c'est que par exemple les printf() ralentissent considérablement le programme alors j'ai du mal à comprendre comment ta technique peut être plus rapide.

Le temps que perd mon programme à stocker les trucs dans un tableau, serait peut être équivalent à ton programme qui transfert les infos vers un autre programme non ?

Sauf que si j'ai bien compris avec ta technique on pourrait voir le début du résultat avant que le tout soit fait, mais est ce important ? j'ai pas d'exemple qui m'incite à croire que ça vaille le coup de faire comme ça.

Oui, les entrées/sorties prennent du temps, et c'est pour ça qu'en pratique on utilise des tampons d'entrée/sortie, mais c'est juste un artefact de l'implémentation, ça, l'algo resterait le même. En l'occurence, si ton algo traite comme je le suggère, « à la volée », les données, et les affiche immédiatement, alors la quantité de mémoire requise dépend uniquement de ce que tu lis à l'instant.

En revanche, si tu stockes, ce n'est pas que ce soit lent de stocker, mais outre le fait que sur un gros fichier tu doives attendre la fin de ton programme, le coût en mémoire dans ton cas varie proportionnellement au nombre d'occurrences trouvées.

Ici, ce n'est pas fondamentalement important (hormis que cela simplifie le code), mais à mon avis, c'est un concept important en général.

Si tu veux comparer, voici un code de moi, pour ce même exo :

Salut tout le monde, merci pour vos conseils qui m'ont été très utiles, grâce à vous, mon code marche... non, il fonctionne . Le voici :

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

int zGrep(FILE *fichier, char const *chaine);

int main(int argc, char *argv[])
{
	FILE* fichier = NULL;
	int occurence = 0;

    if(argc == 3)
    {
        fichier = fopen(argv[1], "r");
        if (fichier == NULL)
        {
            printf("Erreur d'ouverture du fichier ");
        }
        else
		{
            occurence = zGrep(fichier, argv[2]);
		}

        fclose(fichier);
    }

	system("PAUSE");
    return 0;
}

int zGrep(FILE *fichier, char const *chaine)
{
	char *mot = NULL;
	int vrai = 1, caractereActuel, largeur = 0, colonne = 0, longueur = 0, longueurChaine, occurence = 1, ligne[100] = {0}, colonnes[100] = {0}, i = 0;
	
	longueurChaine = strlen(chaine);

    mot = malloc(longueurChaine * sizeof *mot);
    if (mot != NULL)
    {
        caractereActuel = fgetc(fichier);
        while (caractereActuel != EOF)
        {
            colonne++;
            if (isalnum(caractereActuel) && vrai)
            {
                mot[longueur++] = (char)caractereActuel;
                vrai = !(longueur > longueurChaine || mot[longueur - 1] != chaine[longueur - 1]);
            }
            else
            {
                if (longueur == longueurChaine && vrai)
                {
					ligne[occurence] = largeur + 1;
					colonnes[occurence] = colonne - longueur;
                    occurence++;
                }

                if (caractereActuel == '\n')
                {
                    largeur++;
                    colonne = 0;
                }
                longueur = 0;
                vrai = 1;
            }
			caractereActuel = fgetc(fichier);
        }
		printf("%ld occurence(s) trouvee(s) :\n", occurence);
		for(i = 0; i < occurence; i++)
		{
			printf("Occurence %ld trouvee a la ligne %ld, colonne %ld\n", i, ligne[i], colonnes[i]);
		}
    }
    if (mot)
        free(mot), mot = NULL;

    return occurence;
}

rz0 > très joli, le freopen, j'ai pas l'habitude de la prog système. Est-ce que le fait d'ajouter cet argument a un intérêt, à part pour répondre à l'énoncé ?

Je serais tenté de dire que ça ajoute juste un peu de complexité, alors qu'un chevron de redirection ferait aussi bien l'affaire. Mais tu as l'expérience du shell, tu as peut-être une rationale crédible ? De loin je vois éventuellement l'utilisation avec xargs qui est facilitée, et la possibilité de traitement filename-aware (pour les messages toussa), mais c'est pas très convaincant.

Edit : par contre je trouve le goto légèrement provoc', et peu intéressant par rapport à une condition de boucle : intuitivement j'aurais tendance à penser qu'un for (;(c = getchar()) != EOF;) est plus sémantique, est-ce moins idiomatique ?

Citation : bluestorm

rz0 > très joli, le freopen, j'ai pas l'habitude de la prog système. Est-ce que le fait d'ajouter cet argument a un intérêt, à part pour répondre à l'énoncé ?

Je serais tenté de dire que ça ajoute juste un peu de complexité, alors qu'un chevron de redirection ferait aussi bien l'affaire. Mais tu as l'expérience du shell, tu as peut-être une rationale crédible ? De loin je vois éventuellement l'utilisation avec xargs qui est facilitée, et la possibilité de traitement filename-aware (pour les messages toussa), mais c'est pas très convaincant.

Oui, il y a de petites raisons cosmétiques, mais là c'était surtout pour respecter l'énoncé. À la base, je ne l'avais pas mis.

Citation

Edit : par contre je trouve le goto légèrement provoc', et peu intéressant par rapport à une condition de boucle : intuitivement j'aurais tendance à penser qu'un for (;(c = getchar()) != EOF;) est plus sémantique, est-ce moins idiomatique ?

C'est plus idiomatique (à part que l'on utiliserait un while et pas un for avec les deux membres aux extrêmités vides. Ceci dit, cela n'aurait pas le même comportement. Ici il y a du code qui s'exécute entre le getchar() et le goto. Si le fichier termine par EOF sans \n, mais sur un mot-clef cherché, on va l'afficher. Si on quitte la boucle dès que l'on rencontre EOF, on ne tient pas compte de ce cas.

Tu as raison, c'est un do .. while qui serait le plus adapté ici, mais ça implique de remettre le getchar() dans la boucle, ce qui est moins chouette.

À quand la boucle for avec pré et post-condition (par rapport à l'"incrémentation") ?

rz0, tu as oublié d'initialiser le numéro de la colonne à 1 (tu l'as fait au numéro de la ligne pourtant).

Et sinon avec ton code ce n'est pas très facile de rechercher cette chaine ci : "le.s" par exemple.

En même temps ce n'est pas dans l'énoncé, on ne cherche que des mots. Sinon ça revient à la "recherche de sous-chaîne" qui était le sujet de l'exercice précédent (ou celui d'avant, bref).

En même temps 'le_s' ou 'le.s' sont des chaines comme d'autres hein.

Sinon tu as toujours une bonne excuse toi hein, et sympathique en plus...

Citation : rz0

Boaf c'est juste un énoncé comme ça, le but c'est de vous faire pratiquer. Les variations sont tout à fait bienvenues, je pense.

Citation : bluestorm

En même temps ce n'est pas dans l'énoncé, on ne cherche que des mots. Sinon ça revient à la "recherche de sous-chaîne" qui était le sujet de l'exercice précédent (ou celui d'avant, bref).

Nan mais franchement...

Citation : 21

En même temps 'le_s' ou 'le.s' sont des chaines comme d'autres hein.

Mais "le.s" n'est pas un "mot", et le but de cet exercice, c'est de chercher des mots.

Edit : ni "le_s" d'après l'énoncé.

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


Il y a trois états :
État 0 : Avant la reconnaissance d'un mot. Si le caractère lu est alphanumérique, on passe à l'état 1, sinon, on reste à l'état 0.
État 1 : Pendant la reconnaissance d'un mot. Tant que le caractère est alphanumérique, on reste à l'état 1, dès que ce n'est plus le cas, on passe à l'état 2.
État 2 : Après la reconnaissance d'un mot. S'il y a correspondance entre le mot reconnu et argv[1], on affiche un message et on localise précisément l'occurrence ; on retourne à l'état 0.

C'est pas garanti 0-faille (la gestion ligne/colonne ne me plait pas), aussi si vous en rencontrez une, signalez-le moi.

Alors en vrac :
- tu fermes le descripteur trop tard, tu devrais le faire après getcont()
- pour des trucs du genre getcont() on utilise plutôt mmap d'habitude, après je ne connais pas les questions de portabilité
- ta solution dépense inutilement beaucoup de mémoire (taille du fichier, alors qu'on peut facilement faire linéaire en le nombre d'occurences voir constante)
- le !state n'est pas sémantique
- utilise un switch et des #define pour nommer tes constantes numériques d'état
- le passage de l'état 1 à l'état 2 n'est vraiment pas très joli, avec des effets de bord louches sur le pointeur de parcours, etc.

printf("Case %i : row %i, column %i \n", ++occ, row, column-strlen(begin));

Le strlen() pourrait être remplacé par une variable non ?


Puis si j'ai bien compris ton code tu commences par la fin du fichier ? alors si tu commences par la fin du fichier pourquoi as tu besoin de ça column-strlen(begin) ???

Bizarre vos manières de coder je trouve, mais je respecte.

Enfin le problème est quand même hyper simple quoi, et vous nous inondez de termes un peu inutile...
Le truc c'est on cherche le premier caractère de la chaine à rechercher, dès qu'on le trouve on vérifie si le caractère d'avant n'est pas alphanumérique, à ce moment on regarde si chaque caractère suivant correspond à la chaine à rechercher, puis des que l'on tombe sur la fin du mot, alors (on change d'état) et on regarde si le caractère suivant n'est pas alphanumérique, et à ce moment le numéro de la ligne on l'a, sauf que pour le numéro de la colonne faut revenir en arrière, et c'est là qu'intervient le strlen() de la chaine à rechercher (et le strlen on le stock dans une variable au début de la fonction). et hop on affiche le résultat ou alors on le stock dans le tableau comme j'ai fait.

Donc vu que toi shareman tu pars de la fin je comprend pas pourquoi tu utilise encore strlen().

Non 21, je ne pense pas que shareman commence par la fin. C'est sans doute le fseek qui t'as induit en erreur, il l'utilise pour compter la taille du fichier (on est d'accord, c'est bizarre, moi j'aurais utilisé un appel système mais je ne sais pas quelle est la solution correcte et portable, si elle existe), et reviens ensuite au début.

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.