Discussion :

[sefir974]

Bonjour à tous,
Je suis ce que j'appelle un débutant++, dans le sens ou je pratique le C depuis quelques mois, mais sans grande expérience.
Pour m'entrainer, je crée donc des petits programmes sans intérêts.
Mon principal problème, c'est que je ne sais jamais si je suis dans le vrai ou non, n'ayant pas de correcteur.
Je souhaite donc vous soumettre un programme fonctionnel, avec je l'espere des retours sur ma façon de coder.
Comme le titre l'indique, il s'agit juste d'un programme qui permet à l'utilsateur de saisir des lettres, afin que le programme lui donne
tous les mots qu'il est possible de générer.
Merci d'avance.

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
 
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>
 
/*
 *Fake Scrabble renvoi des mots que l'on peut faire à partir de lettre fourni par l'utilisateur. (en Anglais)
 *Ces mots apportent des points selon leur compléxité.
*/
 
/* Constante */
#define MAX_WORD_LENGTH 45
 
/* Variable Globale */
char word_result[MAX_WORD_LENGTH + 1];
 
/* Declaration des fonctions */
static void purger(void);
static void clean(char *chaine);
static int find_word_with_pattern(const char *word, const char *pattern);
static void usage(void);
static void valid_alpha(char *pattern);
static int score(char *word);
 
/* main */
int main(int ac, char **av)
{
    FILE *fp;
    char *pattern;
 
    if (ac == 2)
    {
        fp = fopen("./words.txt", "r");
        if (fp == NULL)
            printf("fopen failed : %s\n",strerror(errno));
        else
        {
            while (!feof(fp))
            {
                pattern = av[1];
 
                valid_alpha(pattern);
                fgets(word_result, sizeof(word_result), fp);
                clean(word_result);
                if (find_word_with_pattern(word_result, pattern) == 1)
                {
                    if(strlen(word_result) == 1) //Une seul lettre
                        printf("\nLetter : %c\n\n", toupper(word_result[0]));
                    else if(strlen(word_result) > 1)
                        printf("Valid result : [%s] ----> %d point(s)\n",word_result, score(word_result));
                }
                memset(word_result, 0, MAX_WORD_LENGTH + 1);
            }
        }
    }
    else
    {
        usage();
        exit(EXIT_FAILURE);
    }
    fclose(fp);
    return 0;
}
 
 
/* Implémentations des fonctions */
 
 
/* vider le buffer de getchar() */
static void purger(void)
{
    int c;
 
    while ((c = getchar()) != '\n' && c != EOF);
}
 
static void clean(char *chaine)
{
    char *p = strchr(chaine, '\n');
 
    if (p)
        *p = 0;
    else
        purger();
}
 
 
/* On compare les lettres fournies à chaque mot dans le dico */
static int find_word_with_pattern(const char *word, const char *pattern)
{
    char *word_dup;
    char *pattern_dup;
    int i;
 
    word_dup = strdup(word);
    pattern_dup = strdup(pattern);
 
    if (word == NULL || pattern == NULL)
        return -1;
    for (i = 0; i < strlen(pattern_dup); i++)
    {
        for (int j = 0; j < strlen(word_dup); j++)
        {
            if (word_dup[j] == '*')
                continue;
            if (word_dup[j] == pattern_dup[i])
            {
                word_dup[j] = '*';
                break;
            }
        }
    }
    i = 0;
    while (word_dup[i])
    {
        if (word_dup[i] != '*')
            return -1;
        i++;
    }
    free(word_dup);
    free(pattern_dup);
    return 1;
}
 
static void usage()
{
    printf("Only one paramater is needed (pattern)");
}
 
 
/* On verifie si la chaine ne contient que des caracteres alphabétiques */
static void valid_alpha(char *pattern)
{
 
    while (*pattern)
    {
        if(!isalpha(*pattern))
        {
            printf("pattern must contain only alphabetical characters\n");
            exit(EXIT_FAILURE);
        }
        pattern++;
    }
 
}
 
/* Rappel : Chaque lettre au scrabble vaut n points, score() calcule la somme pour chaque mot trouvé */
static int score(char *word)
{
    int value_of_letter[26] = {1,3,3,2,1,
        4,2,4,1,8,
        5,1,3,1,1,
        3,10,1,1,1,
        1,4,4,8,4,10}; // a vaut 1 pts (value_of_letter[0]), b vaut 3 pts (value_of_letter[1]), etc...
    int total_score = 0 , i = 0;
 
    while (word[i])
    {
        total_score = value_of_letter[tolower(word[i]) - 'a'] + total_score;
        i++;
    }
    return total_score;
}

[jopopmk]

Salut,

je ne parlerai pas d'algo (c'est ta tambouille, si c'est fonctionnel c'est bien)
ni de mise en forme (j'utilise pas du tout les mêmes règles que toi).

Quelques remarques plus ou moins intéressantes (plus moins que plus) :
- dans find_word_with_pattern tu devrais faire tes strlen une fois pour toute et pas les mettre dans tes boucles for, sinon la fonction sera appelé à chaque itération,
- dans cette même fonction tu as des cas où la mémoire n'est pas désallouée,
- je sais pas comment fonctionnent tes words/patterns, mais le cas qui fait un continue me semble dispensable/intégrable,
- la fonction purger, plutôt minimaliste, n'est appelée que dans clean : autant n'en faire qu'une seule fonction (en C on évite de surdécouper et d'empiler les appels de fonction),
- a priori le memset dans ta fonction main n'a pas de raison d'être, fgets ajoute le trailing zero qui va bien.

Quelques remarques pas intéressantes :
- l'avantage des ++v++ c'est de pouvoir s'incruster dans n'importe quelle instruction, profites en (cf. tes while),
- tu peux utiliser l'opérateur += pour ton calcul de score total,
- ta fonction valid_alpha est bien violente : si ça passe pas le test tu quittes carrément l'appli.

Enfin, y'a peut-être un peu de blindage à faire par-ci par-là.

Bon continuation

[dalfab]

Bonjour,

Sur la présentation :
* beaucoup de bonne pratiques, c'est clair.
* la fonction clean(), le nom n'est pas assez explicite, difficile de voir qu'elle agit aussi sur le flux stdin (mais ne voulais-tu pas vider le flux du fichier?!)
* quand j'ai débuté l'informatique on conseillait 2 lignes de commentaires pour une ligne de code. Aujourd'hui c'est moins nécessaire, mais les commentaires d'explication sont un plus. Ton code est quand même supérieur à la moyenne.

Sur le code :
* la fonction feof() ne dis pas que l'on est à la fin du fichier, mais que la dernière opération s'est mal passée. Ici un fgets() est effectué après avoir extrait la dernière ligne, d'où une chaîne non remplie (c'est peut-être la raison du memset()?)
* pourquoi faire un pattern_dup alors que tu fais que lire le pattern?
* la fonction a un return avant les free(), aïe un memory leak.
* quand un paramètre pointeur n'est pas utilisé pour écrire, il est plus qu'utile de l'indiquer const. C'est fait pour certaines fonctions pas pour d'autres.
* la table value_of_letter est clairement constante et consomme une copie inutile, il faut la déclarer : static int const value_of_letter[]...
* le valid_alpha() qui arrête l'application sur erreur de saisie, c'est violent. Ici c'est parce qu'il s'agit une donnée en ligne de commande, mais il est plus sain de remonter l'erreur au main(). Son nom peut explicite pourrait te tenter de l'utiliser indûment ailleurs.
* la fonction score() utilise sans contrôle les caractères reçus, on ne peux pas se fier à isalpha() car en locale C détecte bien 26 lettres, mais en locale fr_FR il pourra accepter d'autres caractères.

Dalfab

[ternel]

Pour feof(), je rectifie: la fonction permet de savoir si la cause du dernier échec sur un fichier est bien une fin de fichier. Ca pourrait ne pas être le cas.

En général, FILE est une structure contenant une série de champ d'état (souvent des bitfields), et feof() vérifie l'un d'entre eux.