Partage

zWc

4 avril 2010 à 12:22:42

Lithrein, je viens de relire ton post, si pour envoyer EOF, ut fais un retour a la ligne, ton programme devrait te compter 2 lignes... non? pour moi il y a quelques points obscurs dans cet enonce

Pouet_forever

4 avril 2010 à 12:29:19

Arrête de chipoter !
Poste ton code, on te dira si c'est bon.;-)

Adroneus

4 avril 2010 à 12:30:37

Non

je veux poster un code fonctionnel

GurneyH

4 avril 2010 à 14:18:30

Citation : Adroneus

Lithrein, je viens de relire ton post, si pour envoyer EOF, ut fais un retour a la ligne, ton programme devrait te compter 2 lignes... non? pour moi il y a quelques points obscurs dans cet enonce

Je dirais que normalement ce n'est pas un problême...
Il me semble que tous les codes postés suivent la même convention : on compte les lignes entamées, et le EOF ne rentre pas en ligne de compte.

Zeste de Savoir, le site qui en a dans le citron !

simpsonmaniac

4 avril 2010 à 15:09:44

Après coup, j'ai fait comme m'a conseillé lithrein et j'ai tout refait depuis le début. Je crois avoir vu ce qui clochait (j'avais sauté la préparation dans l'exercice 2) et j'ai raccourci le tout.
Voici ma solution pour les niveaux:
Niveau 1

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

char pluriel(int x)
{
    return (x == 1) ? '\0' : 's';
}

int main(int argc, char *argv[])
{
    int wordcount = 1;
    int charcount = 0;
    int linecount = 1;
    char c, temp;
    char separators[] = " \r\t\n";
    while((c = getchar()) != EOF){
        if(c == '\n'){
            linecount++;
        }
        if(strchr(separators, temp) && !strchr(separators, c)){
            wordcount++;
        }
        charcount++;
        temp = c;
    }
    printf("\n%d ligne%c, %d mot%c, %d caractere%c", linecount, pluriel(linecount), wordcount, pluriel(wordcount), charcount, pluriel(charcount));
    return 0;
}

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

char pluriel(int x)
{
    return (x == 1) ? '\0' : 's';
}

int main(int argc, char *argv[])
{
    if(argc == 2){
        FILE *fichier = fopen(argv[1], "r");
        if(!fichier){
            fprintf(stderr, "fopen: %s n'existe pas", argv[1]);
            exit(EXIT_FAILURE);
        }
        int wordcount = 1;
        int charcount = 0;
        int linecount = 1;
        char c, temp;
        char separators[] = " \r\t\n";
        while((c = getchar()) != EOF){
            if(c == '\n'){
                linecount++;
            }
            if(strchr(separators, temp) && !strchr(separators, c)){
                wordcount++;
            }
            charcount++;
            temp = c;
        }
        printf("\n%d ligne%c, %d mot%c, %d caractere%c", linecount, pluriel(linecount), wordcount, pluriel(wordcount), charcount, pluriel(charcount));
    }
    else{
        fprintf(stderr, "Usage : %s [FICHIER]", argv[0]);
        exit(EXIT_FAILURE);
    }
    return 0;
}

Niveau 2:

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

void find_args(int *args, char *options, char *from, size_t count)
{
    int i = 0;
    for(; i < count; i++){
        if(strchr(from, options[i])){
            args[i] = 1;
        }
    }
}

int main(int argc, char *argv[])
{
    int i = 0;
    int options[4] = {0,0,0,0};
    for(; i<argc; i++){
        if(argv[i][0] == '-'){
            find_args(options, "abcd", argv[i], 4);
        }
    }
    for(i=0; i<4; i++){
        printf("option %c: %s\n", i+'a', (options[i]) ? "activee" : "desactivee");
    }
    return 0;
}

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

typedef struct{
    const char *name;
    int count;
} counter;

char pluriel(int i)
{
    return (i == 1) ? '\0' : 's';
}

void help()
{
    fprintf(stderr, "Usage : wc [-l] [-w] [-c] [FICHIER]\n");
    exit(EXIT_FAILURE);
}

void find_args(int *args, char *options, char *from, size_t count)
{
    unsigned int i = 0;
    for(; i < count; i++){
        if(strchr(from, options[i])){
            args[i] = 1;
        }
    }
}

void wordcount(FILE * stream, int options[4])
{
    int i;
    int isFirstLine = 1;
    int isFirstWord = 1;
    int isFirstArgument = 1;
    counter linecount = {"ligne", 0};
    counter wordcount = {"mot", 0};
    counter charcount = {"caractere", 0};
    counter *counters[3] = {&linecount, &wordcount, &charcount};
    char c, temp;
    char separators[] = " \r\t\n";
    while((c = fgetc(stream)) != EOF){
        if(isFirstLine || c == '\n'){
            linecount.count++;
            isFirstLine = 0;
        }
        if(isFirstWord || (strchr(separators, temp) && !strchr(separators, c))){
            wordcount.count++;
            isFirstWord = 0;
        }
        charcount.count++;
        temp = c;
    }
    putchar('\n');
    if(!options[0] && !options[1] && !options[2]){
        printf("%d ligne%c, %d mot%c, %d caractere%c", linecount.count, pluriel(linecount.count), wordcount.count, pluriel(wordcount.count), charcount.count, pluriel(charcount.count));
        return;
    }
    for(i=0; i<3; i++){
        if(options[i]){
            if(!isFirstArgument){
                printf(", ");
            }
            printf("%d %s%c", counters[i]->count, counters[i]->name, pluriel(counters[i]->count));
            isFirstArgument = 0;
        }
    }
    putchar('\n');
}

int main(int argc, char *argv[])
{
    int i;
    int options[4] = {0,0,0,0};
    FILE *input_stream = stdin;
    if(argc > 1){
        for(i=1; i<argc; i++){
            if(argv[i][0] == '-'){
                find_args(options, "lwch", argv[i], sizeof(options)/sizeof(*options));
                if(options[3]){
                    help();
                }
            }
        }
        if(argv[argc-1][0] != '-'){
            if(!(input_stream = fopen(argv[argc-1], "r"))){
                fprintf(stderr, "fopen: %s n'existe pas\n", argv[argc-1]);
                exit(EXIT_FAILURE);
            }
        }
    }
    wordcount(input_stream, options);
    return 0;
}

Edit : Corrections (chaîne vide, divers warnings exposés par GurneyH)

Adroneus

4 avril 2010 à 15:18:32

Juste une remarque a faire, lorsque l'on rentre une chaine vide, il met : 1 ligne, 1 mot, 0 caracteres

vala, c'est tout
Ah non, autre chose mais la c'est chipoter (ben oui puisque j'ai commence je finis

) Tu respecte pas l'affichage demande par Lithrein

Edit sinon, j'aime bien la maniere dont tu as resolu cet exercice,simple et concis

(moi je suis plus partisan de une action == une fonction, mais ton code est clair...)

simpsonmaniac

4 avril 2010 à 15:46:08

Merci beaucoup (au passage j'ai corrigé ce petit problème de la chaîne vide

)

Adroneus

4 avril 2010 à 15:55:42

Pas de quoi, Lithrein, faut il afficher un messge d'erreur si on utilise un flag non reconnu? doit on simplement ignorer les caracteres excedentaires si il y en a?

GurneyH

4 avril 2010 à 15:59:11

@simpsonmaniac:
Plusiseurs warnings...

main.c||In function `find_args':|
main.c|24|warning: comparison between signed and unsigned
main.c||In function `wordcount':|
main.c|35|warning: initialization discards qualifiers from pointer target type
main.c|36|warning: initialization discards qualifiers from pointer target type main.c|37|warning: initialization discards qualifiers from pointer target type
main.c|38|warning: initializer element is not computable at load time|
main.c|38|warning: initializer element is not computable at load time|
main.c|38|warning: initializer element is not computable at load time|
main.c|76|warning: passing arg 2 of `find_args' discards qualifiers from pointer target type|
||=== Build finished: 0 errors, 8 warnings ===|

Celui qui me dérange le plus est celui ci:

warning: initializer element is not computable at load time|

Pour moi, c'est valide en C99, mais pas dans les versions antérieures.
Dans tous les cas, c'est une forme d'initialisation peu courante.

Pour les autre warnings tu as une comparaison entre i entier et cout size_t, et

counter linecount = {"ligne", 1};

avec

typedef struct{
    char *name;
    int count;
} counter;

Le compilateur te fait remarquer que si tu as la mauvaise idée de modifier la chaîne litéralle pointée par .name, tu est en présence d'un comportement indéfini.
Pour eviter ça

char const *name;

Sur le fonctionnement

Hello
^Z


2 lignes, 2 mots, 6 caracteres
Process returned 0 (0x0)   execution time : 2.656 s
Press any key to continue.

Pour les 2 mots, je ne suis pas trop d'accord.
Pour le nombre de caractères, pour moi c'est ok, on compte le '\n'.
Pour le nombre de lignes, c'est la question d'adroneus juste avant.
Pour moi ici, on ne doit compter qu'une ligne, mais ça se discute...

Zeste de Savoir, le site qui en a dans le citron !

Adroneus

4 avril 2010 à 16:02:20

Moi ca compilait sans warning (vieille croute de C::B! (cf Marc

) vivement que je retourne sous nunux)

Sinon, pour les lignes, on devrait plutot faire :

Hello^Z
^Z

simpsonmaniac

4 avril 2010 à 16:25:06

Citation : Adroneus

Moi ca compilait sans warning (vieille croute de C::B!)

Pareil

, sinon j'ai corrigé ce que tu as pointé mais je ne comprends pas ce warning:

Citation

main.c|40|warning: initializer element is not computable at load time|

J'ai vu que ça concernait mon tableau

counter *counters[3] = {&linecount, &wordcount, &charcount};

Mais je ne vois pas vraiment où est le problème o_O

GurneyH

4 avril 2010 à 16:40:48

Je suis sous code::blocks moi aussi.

Mais on peut régler les options de compilation...

Citation : simpsonmaniac

Mais je ne vois pas vraiment où est le problème

Un extrait de code simple qui reproduit le problème

int i = 2, j = 4;
int tab[2] = {i, j};

Tu vois souvent ce genre de choses?

Zeste de Savoir, le site qui en a dans le citron !

Pouet_forever

4 avril 2010 à 16:48:00

Tu compiles avec quelles options pour obtenir ça ?

J'ai des options strictes pourtant et j'arrive pas (avec l'exemple que tu as donné) à avoir ce warning.

GurneyH

4 avril 2010 à 17:01:57

je te redis ça...

Par contre j'ai dis une bètise ce n'est pas du c99...

Je vérifie l'option provoquant ce warning.

edit: avec pedantic -> warning

J'ai vérifié avec le compilateur C de microsoft qui ne supporte pas le standard 99.
Ca passe également avec des warnings.
A priori, ce type d'initialisation est une extension non standard de certains compilateurs(dont GCC).

Je cherche à en savoir plus.

Zeste de Savoir, le site qui en a dans le citron !

simpsonmaniac

4 avril 2010 à 17:19:17

C'est marrant il ne m'affiche pas de warnings si je mets:

counters[0] = &linecount;
counters[1] = &wordcount;
counters[2] = &charcount;

Quelle est la différence entre la notation

int tab[2];
tab[0] = i;
tab[1] = j;

int tab[2] = {i,j};

Adroneus

4 avril 2010 à 18:24:29

moi avec -pedantic, pas de warn...

Edit:

bon voila un code sans pretention pour l'exo 1, je sais pas si je ferais le 2 :

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

#define Count(what, str, flux) Count_##what##_##flux(str)

typedef unsigned int u_int;

void    getStr(char **);
int     isSeparator(char);
size_t  Count_Letter_Stdin(char *);
size_t  Count_Letter_File(FILE *);
size_t  Count_Word_Stdin(char *);
size_t  Count_Word_File(FILE *);
size_t  Count_Line_Stdin(char *);
size_t  Count_Line_File(FILE *);
size_t  Count_Line_Stdin(char *);
void    PrintAttrib(char *);
void    actWithNoArg(void);
void    actWithArg(FILE *);

void    getStr(char **str)
{
  char  *string;
  int   c;
  int   iter;

  iter = 1;
  string = malloc(sizeof(char));
  if (string == NULL)
    return;
  while ((c = fgetc(stdin)) != EOF)
    {
        ++iter;
        string = realloc(string, iter * sizeof(char));
        if (string == NULL)
            return;
        string[iter - 2] = c;
    }
  string[iter - 1] = '\0';
  *str = string;
}

int    isSeparator(char c)
{
  if (c == ' ' || c == '\t' || c == '\n' || c == '\r' )
    return (1);
  return (0);
}

size_t  Count_Letter_Stdin(char *str)
{
  char  *s;

  s = str;
  while (*s)
    s++;
  return ((size_t)(s - str));
}

size_t  Count_Letter_File(FILE *file)
{
  int       c;
  size_t    iter;

  iter = 0;
  fseek(file, 0, SEEK_SET);
  while ((c = fgetc(file)) != EOF)
    ++iter;
  return (iter);
}

size_t  Count_Word_Stdin(char *str)
{
  size_t    nb;

  nb = 0;
  while (*str)
    {
        while (isSeparator(*str))
            str++;
        if (*str)
            ++nb;
        while (!isSeparator(*str) && *str)
            str++;
    }
  return (nb);
}

size_t  Count_Word_File(FILE *file)
{
  int       c;
  size_t    nb;

  nb = 0;
  fseek(file, 0, SEEK_SET);
  while ((c = fgetc(file)) != EOF)
    {
        while (isSeparator(c))
            c = fgetc(file);
        if (c != EOF)
            ++nb;
        while (!isSeparator(c) && c != EOF)
            c = fgetc(file);
    }
  return (nb);
}

size_t  Count_Line_Stdin(char *str)
{
  size_t    nb;

  nb = 0;
  while(*str)
    {
        if (!nb)
            ++nb;
        if(*str == '\n')
            ++nb;
        str++;
    }
  return (nb);
}

size_t  Count_Line_File(FILE *file)
{
  int       c;
  size_t    nb;

  nb = 0;
  fseek(file, 0, SEEK_SET);
  while ((c = fgetc(file)) != EOF)
    {
        if (!nb)
            ++nb;
        if (c == '\n')
            ++nb;
    }
  return (nb);
}

void    PrintAttrib(char *str)
{
  printf("\t%u ligne(s), ", (u_int)Count(Line, str, Stdin));
  printf("%u mot(s), ", (u_int)Count(Word, str, Stdin));
  printf("%u caractere(s)", (u_int)Count(Letter, str, Stdin));
}

void    actWithNoArg()
{
  char  *test;

  getStr(&test);
  PrintAttrib(test);
}

void    actWithArg(FILE *file)
{
  printf("\t%u ligne(s), ", (u_int)Count(Line, file, File));
  printf("%u mot(s), ", (u_int)Count(Word, file, File));
  printf("%u caractere(s)", (u_int)Count(Letter, file, File));
}

int  main(int argc, char *argv[])
{
  FILE  *file;

  if (argc <= 1)
    actWithNoArg();
  else
    {
        file = fopen(argv[1], "r");
        if (file == NULL)
            printf("Erreur : Aucun fichier trouvé");
        else
            {
                actWithArg(file);
                fclose(file);
            }
    }
  return (0);
}

Alors, je vois de suite venir LA critique supreme :

Citation : Un geek en colere

POURQUOI TU PARCOURS TROIS FOIS TON FICHIER!!!!

Eh bien parce que j'aime bien programmer tout en suivant l'idee que : 1 tache == 1 fonction ... Ce que je fais dans mon code.
Apres j'ai fais le test, pour un fichier de 2 Go, sur un ordi pourri, mon programme mets 10 minutes, un programme ne parcourant qu'une fois le fichier mets 3.3 minutes...

Je me suis dit que comme c'etait un exercice et qu'il n'y avait pour but de faire des verifications sur des gros fichiers... ca ne valait pas la peine de changer cela...

Sinon, s'il y a d'autres reflexions, je suis preneur!!

GurneyH

4 avril 2010 à 18:43:35

Citation : Adroneus

moi avec -pedantic, pas de warn...

Ca me surprend un peu.
Je viens de retester en enlevant toutes les options -> pas de warning.
avec -pedantic -> warning.
o_O

Zeste de Savoir, le site qui en a dans le citron !

Adroneus

4 avril 2010 à 18:51:18

Je compile avec : -g -W -Wall -ansi -pedantic

Sinon, j'ai edite mon post et j'ai mis du code... A vous les critiques!

Pouet_forever

4 avril 2010 à 20:34:40

@ Adroneus : Exemple pour la fonction Count_Letter_File :

#define Count_prototype(type, what, flux, typep, par)	\
	type Count_ ## what ## _ ## flux (typep par);


Count_prototype(size_t, Letter, File, FILE *, file)

#define Letter_File(par)			\
	int       c;					\
	size_t    iter;					\
									\
	iter = 0;						\
	fseek(par, 0, SEEK_SET);		\
		while ((c = fgetc(par)) != EOF)	\
			++iter;					\
	return (iter);

#define Count_genere_fct(type, what, flux, typep, par)	\
	type Count_ ## what ## _ ## flux (typep par) {		\
		what ## _ ## flux (par)							\
}

#define Count_what(what, flux, par)	\
	Count_ ## what ## _ ## flux (par)

Count_genere_fct(size_t, Letter, File, FILE *, file)


...

printf("%u caractere(s)", Count_what(Letter, File, file));

Adroneus

4 avril 2010 à 20:43:10

T'es fou

mais jvais regarder ca merci

IATGOF

4 avril 2010 à 21:13:27

Citation : Adroneus

Citation : Un geek en colere

POURQUOI TU PARCOURS TROIS FOIS TON FICHIER!!!!

Eh bien parce que j'aime bien programmer tout en suivant l'idee que : 1 tache == 1 fonction ... Ce que je fais dans mon code.

Non sérieux, parcourir le fichier 3 fois c'est mal (j'argumente pas, ça sert à rien).

Adroneus

4 avril 2010 à 21:19:40

Pour un projet serieux je suis tout a fait d'accord... mais bon la je pense pas que quelqu'un soit shocked parce que mon programme mets 1.5 seconde a analyser la phrase alors que les autres en mettent 0.7... et pour les gros fichiers jlai dit plus haut...

Je suis d'accord avec cet argument... mais je demande des commentaires sur le code

GurneyH

4 avril 2010 à 21:40:55

Citation : adroneus

mais je demande des commentaires sur le code

Le problème, adroneus, c'est que tu codes plutôt bien....
Et, tu sais défendre ton code...

Un truc ou je ne suis pas d'accord :
Une fonction à un rôle!
Là on est d'accord, mais finalement ce n'est pas rare de trouver ds fonctions qui remplissent leur rôle:!Ici : ce qu'on lui demande afficher le nomre de lignes, le nombre de mots, le nombre de caractères...

Parcourir 3 fois la même chaîne, pardon, mais je ne peux pas...

Mais ça reste mon avis... D'ailleurs, des fois je ne sais pas pourquoi je le donne!

Zeste de Savoir, le site qui en a dans le citron !

Adroneus

4 avril 2010 à 21:42:52

Mouais, bon non, la je me dis que ca fait trop de gens contre moi, quand j'ai tord je sais le reconnaitre

. Merci a GurneyH, IATGOF et Pouet_Forever pour la remarque, je corrigerai dans la soiree ou demain au plus tard

. Et si, continue a donner ton avis! il est toujours constructif!!

Edit et merci du compliment

IATGOF

4 avril 2010 à 21:50:59

Citation : GurneyH

Le problème, adroneus, c'est que tu codes plutôt bien....
Et, tu sais défendre ton code...

Ouais voilà, y'a pas grand chose à dire, mis à part le fait de parcourir trois fois le fichier et de récupérer une chaine de caractère en réallouant à chaque tour.
En plus, tu t'efforces de respecter la norme Epitech, la classe quoi -ou presque-

Adroneus

4 avril 2010 à 21:53:23

Ben... faut bien rester en condition

Arcanis, une tronche d'EPITECH maintenant il s'est tape des -28 a la piscine a cause de la norme... alors que sur le fond... il code vachement bien. Je ferais les correctifs IATGOF, tape pas

GurneyH

4 avril 2010 à 21:55:31

Citation : Adroneus

Ben... faut bien rester en condition Arcanis, une tronche d'EPITECH maintenant il s'est tape des -28 a la piscine a cause de la norme... alors que sur le fond... il code vachement bien.

Tout ce que j'aime! :-°

Zeste de Savoir, le site qui en a dans le citron !

Lithrein

4 avril 2010 à 22:30:16

Citation : Adroneus

Lithrein, t'as pas repondu... est ce correct d'avoir : 1 ligne, 0 mot, 1 caractere si on entre une chaine vide?

Je réponds un peu tard. :-°

Non, ce n'est pas normal, la chaine vide donne 0 ligne, 0 mot, 0 caractere

Citation : Adroneus

Pas de quoi, Lithrein, faut il afficher un messge d'erreur si on utilise un flag non reconnu? doit on simplement ignorer les caracteres excedentaires si il y en a?

De manière générale en cas d'option inconnue on affiche l'usage du programme c'est-à-dire ce qu'affiche le programme avec l'option -h.

Adroneus

4 avril 2010 à 22:33:46

Oui oui, avec ce programme ca fait 0, 0, 0... jme suis dit que c'etait mieux fin bon

je le referais tfacon

IATGOF

4 avril 2010 à 22:39:42

Citation : Adroneus

Ben... faut bien rester en condition Arcanis, une tronche d'EPITECH maintenant il s'est tape des -28 a la piscine a cause de la norme... alors que sur le fond... il code vachement bien.

Et encore, ton code là prendrait assez cher à la norme.
Sinon mon implémentation rapide:

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

#define	OPENFAIL "Cannot open the specified file"
#define	USAGE "usage: ./zwc file"

#define	BUFSZ 1024

enum {
  NB_LINE,
  NB_WORD,
  NB_CHAR,
  NB_MAX
};

# define	ENTIRELINE 1
# define	INWORD 2

void		try_word(char c, unsigned int *v, int *flags)
{
  if (isspace((unsigned char)c))
    {
      if (*flags & INWORD)
	*flags &= ~INWORD;
    }
  else if (!(*flags & INWORD))
    {
      *flags |= INWORD;
      v[NB_WORD]++;
    }
}

void		try_end_of_line(char c, unsigned int *v, int *flags)
{
  if (c == '\n')
    {
      v[NB_LINE]++;
      *flags |= ENTIRELINE;
    }
}

void		proceed(FILE *f, unsigned int *v)
{
  char		buf[BUFSZ];
  int		i;
  int		flags;

  while ((fgets(buf, BUFSZ, f)))
    {
      flags = 0;
      i = -1;
      while (buf[++i])
	{
	  v[NB_CHAR]++;
	  try_word(buf[i], v, &flags);
	  try_end_of_line(buf[i], v, &flags);
	}
    }
  if (v[NB_CHAR] && !(flags & ENTIRELINE))
    v[NB_LINE]++;
}

void		disp(unsigned int *v)
{
  printf("\t%u\t%u\t%u\n", v[NB_LINE], v[NB_WORD], v[NB_CHAR]);
}

int		main(int ac, char **av)
{
  FILE		*f;
  unsigned int	val[NB_MAX];

  if (ac > 1)
    {
      if ((f = fopen(av[1], "r")))
	{
	  memset(val, 0, sizeof val);
	  proceed(f, val);
	  disp(val);
	  fclose(f);
	}
      else
	puts(OPENFAIL);
    }
  else
    puts(USAGE);
  return (0);
}

Par contre mon wc système se réfère uniquement aux \n pour compter les lignes, c'est à dire qu'un fichier contenant toto sans \n ne compte pas comme une ligne pour lui. Je trouve que le comportement est discutable et mon implémentation comptabilisera une ligne.
Pour reproduire le comportement du "vrai" wc, il suffit d'enlever les lignes

if (v[NB_CHAR] && !(flags & ENTIRELINE))
    v[NB_LINE]++;

<< 1 2 3 4 5 >>

zWc

× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.

× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.

zWc

zWc

Supprimer

Modérer

Signaler le message aux modérateurs