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;
}