Citation : Kushou

Bonjour,

Bon ben voilà une petite participation, mais je suis plutot mauvais en C (vous avez dit partout ?), donc mon code est surement moche. Pour pas faire une boucle comme tout le monde, et histoire qu'on ait de quoi discuter, j'ai décidé de faire ça en récurcif (tail-rec en plus %%). Donc le code est ici. On peut choisir les délimiteurs entre (), [] et {}, voilà. Le code est un peu plus long que celui des autres. Si j'avais réussi a faire fonctionner fflush, il auraut fait 42 lignes, c'est à souligner.

static char zBrassRec(char const *src, char open, char close, int lvl)
{
    /* Si le niveau d'imbrication est négatif, le parenthèsage est incorrect. */
    if (lvl < 0)
        return -1;
    /* Si on est à la fin de la chaîne et que le niveau d'imbrication courant
     * est nul, la chaîne est correctement parenthèsée.
     */
    if (*src == '\0')
        return !lvl ? 0 : -1;

    if (*src == open)
        lvl++;
    else if (*src == close)
        lvl--;

    return  zBrassRec(src + 1, open, close, lvl);
}

pth -> '(' pth ')' pth
     | c pth       // c représente tout caractère différent de '(' et de ')'
     | RIEN

// 1 : bien
// 0 : pas bien

/** pth -> ( pth ) pth | l pth | RIEN **/

unsigned int* incr(unsigned int* i)
{
    (*i)++; return i;
}

int pth(const char* str, unsigned int* i, unsigned int size)
{
    if((*i) >= size) {
        return 1;
    }
    if(   (str[*i] == '\0')
       || (str[*i] == '(' && pth(str, incr(i), size) && str[*i] == ')' && pth(str, incr(i), size))
       || (str[*i] != ')' && pth(str, incr(i), size))  )
        return 1;
    return 1;
}

int verif(const char* str)
{
    unsigned int i = 0;
    pth(str, &i);
    if(i != strlen(str))
        return 0;
    return 1;
}

Citation : ShareMan

int pth(const char* str, unsigned int* i)
{
    if(   (str[*i] == '\0')
       || (str[*i] == '(' && pth(str, incr(i)) && str[*i] == ')' && pth(str, incr(i)))
       || (str[*i] != ')' && pth(str, incr(i)))  )
        return 1;
    return 1;
}

#include <stdio.h>
#include <stdlib.h> /*exit*/

void fromTo(FILE* in, FILE* out) {
    char c;
    for(; (c = fgetc(in)) != EOF; fputc(c, out));
}

void lire(char* s) {
    FILE* f = (*s == '-') ? stdin : fopen(s, "r");
    if(f != NULL) {
        fromTo(f, stdout);
        fclose(f);
    } else {
        perror("E ");
        exit(1);
    }
}

void editer(char* s, char edit) {
    char mode[3] = "a+";
    FILE* f = fopen(s, mode);
    if(f == NULL) {
        perror("E ");
        exit(1);
    }
    if(edit != 'c')
        fromTo(stdin, f);
    fclose(f);
}

int format(char* name) {
    return fprintf(stderr, "Usage: %s -[r|e|c] FILE\n", name);
}

int main(int argc, char* argv[]) {
    if(argc < 3) {
        format(*argv);
        return 1;
    }
    switch(argv[1][1]) {
    case 'r': lire(argv[2]); break;
    case 'e': case 'c':
        editer(argv[2], argv[1][1]); break;
    default: format(*argv); return 1;
    }
    return 0;
}

% echo 'Et je rajoute une phrase' | ./p -e wat
% ./p -r wat
Et je rajoute une phrase
%

Citation : ShareMan

(même si hum, c'est évident, c'est un terme très courant en France)

Citation : ShareMan

je n'ai parlé à aucun moment de grammaire LL(1)

Citation : ShareMan

Et hum, je n'ai rien contre tes remarques, je ne suis jamais contre les retours d'avis.

Citation : ShareMan

penses-tu vraiment qu'il serait nécessaire de préciser le caractère LL(1) ?

Citation : ShareMan

Bah "à première vue" peut-être mais ça n'a rien de "compliqué pour rien".

Citation : Human-Behind

Voici ma "trés" modeste contribution :

Citation : Crehn

Bon voici ma version claire et propre:

#include <stdio.h>

int cb(char *s){int n=0;for(;*s;++s){if(*s==
'(')++n;if(*s==')')if(--n<0)break;}return n;}

int main(int argc, char **argv) {
    if(cb(argv[1])) {
        puts("Ok.");
    } else {
        puts("Damn.");
    }

    return 0;
}

EDIT: Hop, et encore plus petit! Fonction de 90 caractères.

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

int isValid(const char* str);

int main(int argc, char** argv)
{
    const char* str = argv[1];
    if (isValid(str))
        printf("Statement %s is valid.\n", str);
    else
        printf("Statement %s is not valid.\n", str);

}

int isValid(const char* str) {
    int i = 0, o = 0, c = 0;
    
    for (i = 0 ; str[i] != '\0' ; i++) {
        switch(str[i]) {
            case '(': o++; break;
            case ')': c++; break;
            default: break;
        }

        if (c > o)
            return 0;
    }
    
    return (c == o);
}

main(k){float i,j,r,x,y=-16;while(puts(""),y++<15)for(x
=0;x++<84;putchar(" .:-;!/>)|&IH%*#"[k&15]))for(i=k=r=0;
j=r*r-i*i-2+x/25,i=2*r*i+y/10,j*j+i*i<11&&k++<111;r=j);}

Citation : undefined

Je n'ai rien compris au code de Shareman, ptet que demain ça ira mieux. :-/

Citation : shareman

On peut ici se passer d'une analyse lexicale et appliquer l'analyse syntaxique directement sur la chaîne d'entrée. Par contre, on ne construira pas d'arbre syntaxique parce que ce n'est pas cela qui nous intéresse ici : on veut juste savoir si l'analyseur syntaxique valide l'expression. La technique est assez simple : l'analyseur syntaxique itère sur la chaîne en "avalant" (ce qui revient à incrémenter l'itérateur) les lexèmes reconnus comme syntaxiquement corrects. Nous n'allons pas lancer d'erreurs dans les cas d'erreurs mais nous allons simplement laisser l'analyse syntaxique se dérouler puis vérifier à la fin uniquement s'il reste des caractères non-reconnus (donc si l'itérateur (qui sera de type unsigned int) est différent de la taille de l'expression).

Citation : Camp0us

C'est une fractale non ? (ensemble de Mandelbrot)

Citation : ShareMan

Pour le post de zx-spectrum :

Je ne vais même pas argumenter, ça ne servirait à rien. cf ici.