Exercices pour débutants en C

/* Algorithme de Boyer-Moore simple*/
#include <stdio.h>
#include <limits.h>

/* retourne la longueur d'une chaîne caractères */
static size_t my_strlen(char const *src)
{
    char const *cpy = src;
    while (*cpy++);

    return --cpy - src;
}


char *my_strstr(char const *haystack, char const *needle)
{
    char *res = NULL;
    int tab[UCHAR_MAX + 1];
    int i;
    int nLen = my_strlen(needle);
    int hLen = my_strlen(haystack);
    if (nLen && hLen)
    {
        for (i = 0; i < UCHAR_MAX + 1; i++)
            tab[i] = nLen;
        for (i = 0; i < nLen - 1; ++i)
            tab[(size_t)needle[i]] = nLen - 1 - i;

        while (hLen >= nLen && !res)
        {
            i = nLen - 1;
            while(haystack[i] == needle[i] && !res)
            {
                if (!i)
                    res = (char *)haystack;
                --i;
            }
            if (!res)
            {
                hLen     -= tab[(size_t)haystack[nLen - 1]];
                haystack += tab[(size_t)haystack[nLen - 1]];
            }
        }
    }
    return res;
}


int zStrSearch(const char *haystack, const char *needle)
{
    const char *occ = haystack;
    int cpt = 0;

    while(occ)
    {
        occ = my_strstr(occ, needle);
        if (occ != NULL)
        {
            printf("Une occurence a la position %d\n", 1 + occ - haystack);
            occ++;
            cpt++;
        }
        else
        {
            if (!cpt)
                printf("Pas d'occurence.\n");
        }
    }
    return cpt;
}

int main(void)
{
    const char *meule = "blffoobarblofoohaha";
    const char *aiguille = "foo";

    printf("%d occurences trouvees\n", zStrSearch(meule, aiguille));
    return 0;

}

void findString(const char* str, const char* underStr)
{
    int i = 0, j = 0, back = 0, strike = 0, done = 0;
    for (i = 0 ; str[i] != '\0' ; i++)
    {
        if (str[i] == underStr[0])
	{
	    for (j = 1 ; underStr[j] != '\0' && !strike ; j++)
            {
	        if (str[i+j] == underStr[0] && !done)
		{
		    back = i+j;
		    done = 1;
	        }
		else if (str[i+j] != underStr[0] && !done)
		    back = i+j+1;

		if (str[i+j] != underStr[j])
		    strike = 1;
            }
            if (!strike)
	        printf("%d  ", i);
			
            i = back > i ? back-1 : i;
	}
	strike = 0;
        done = 0;
    }
}

void findString(const char* str, const char* underStr)
{
    int i = 0, j = 0, strike = 0;
    for (i = 0 ; str[i] != '\0' ; i++)
    {
        if (str[i] == underStr[0])
	{
	    for (j = 1 ; underStr[j] != '\0' && !strike ; j++)
	    {
		if (str[i+j] != underStr[j])
	            strike = 1;
            }
            if (!strike)
                printf("%d  ", i);
	}
	strike = 0;
    }
}

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

int lenString ( char *chaine)
/*en entrée : une chaine de caractere nommé chaine*/
/*en sortie : donne le nombre de caractere de la chaine*/
/*traitement :calcule la longueur d'une chaine*/
{
    int len =0;
    while ( chaine[len] != '\0' )
    {
        len ++ ;
    }
    return len;
}

int occurence (char *chaine1, char *chaine2)
{
    int nb_occurence =0;/*pour compter les occurences*/
    int len1,len2;/*pour les longueurs de chaines à traiter*/
    int i=0,j=0;/*compteurs de boucle de boucle*/
    int trouve;/*la chaine est identique si trouve = len2*/
    len1 = lenString(chaine1);
    len2 = lenString(chaine2);
    int z = len1-len2+1;
    if (len2 !=0) /*dans le seul cas ou la chaine contient rien*/
    {
        i=0;
        while (i< z)
        {
            trouve = 0;
            for (j=i;j<i+len2;j++)
            {
                if ((j-i) !=0) printf("%d  ",j-i);/*ligne test j-i*/
                if (chaine1[j]==chaine2[j-i]) trouve++;
                else
                {
                  /* i=i+len2; */
                  break;
                }
            }

            if (trouve == len2)
            {
                nb_occurence ++ ;
                printf ("en position N.: %d\n",i+1);
            }

            i++;
        }
    }
    return nb_occurence;
}
int main(void)
{
    char chaine[]="ZxHello word ! Zx-Spectrum soluce, exercice may 2009. Easy soluce by Zx";
    char ch[]="soluce";

    printf("%s\n-->%s<--\n",chaine,ch);
    printf("nous avons %d occurence(s) trouvee(s)",occurence (chaine,ch));
    return 0;
}

/* Renvoie 1 si la chaîne est bien parenthésée
        0 sinon */
static int
bien_pth (const char *s)
{
  int nbPth = 0;

  while (*s != '\0')
    {
      if (*s == '(')
	nbPth++;
      else if (*s == ')')
	nbPth--;
      if (nbPth < 0)
	return 0;
      s++;
    }

  if (nbPth == 0)
    return 1;
  return 0;
}

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

/* Renvoie 1 si la chaîne est bien parenthésée
           0 sinon */
static int
bien_pth (const char *s)
{
  int nbPth = 0;

  while (*s != '\0')
    {
      if (*s == '(')
	nbPth++;
      else if (*s == ')')
	nbPth--;
      if (nbPth < 0)
	return 0;
      s++;
    }

  if (nbPth == 0)
    return 1;
  return 0;
}

static void 
usage (const char *name)
{
  printf ("%s : << chaine >>\n", name);
  exit (EXIT_FAILURE);
}

int
main (int argc, char *argv[])
{
  if (argc != 2)
   usage (argv[0]);

  if (bien_pth (argv[1]) == 1)
    printf ("Oui\n");
  else
    printf ("Non\n");
     
  return EXIT_SUCCESS;
}

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

/**CONSTANTES DE L'ENNONCE**/
char expression[200];

void verifier(void)
{
   int differenceOuvranteFermante = 0;
   int i = 0;
   for(;expression[i] != '\0';i++)
	{
	   if(differenceOuvranteFermante < 0)
	   {
         printf("mal parenthese !\n");
         return;
	   }
	   if(expression[i] == '(')
	   {
	      differenceOuvranteFermante++;
	   }
	   else if(expression[i] == ')')
	   {
	      differenceOuvranteFermante--;
	   }
	}
	if(differenceOuvranteFermante == 0)
	{
	   printf("bien parenthese\n");
	   return;
	}
	printf("mal parenthese !\n");
}

int main(void)
{
   for(;;)
   {
      fgets(expression, 200, stdin);
      verifier();
   }
	return 0;
}

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

/**CONSTANTES DE L'ENNONCE**/
char expression[200];
char caracOuvrant;
char caracFermant;

void verifier(void)
{
   int differenceOuvranteFermante = 0;
   int i = 0;
   for(;expression[i] != '\0';i++)
	{
	   if(differenceOuvranteFermante < 0)
	   {
         printf("mal parenthese !\n");
         return;
	   }
	   if(expression[i] == caracOuvrant)
	   {
	      differenceOuvranteFermante++;
	   }
	   else if(expression[i] == caracFermant)
	   {
	      differenceOuvranteFermante--;
	   }
	}
	if(differenceOuvranteFermante == 0)
	{
	   printf("bien parenthese\n");
	   return;
	}
	printf("mal parenthese !\n");
}

int main(void)
{
   for(;;)
   {
      scanf("%c %c ", &caracOuvrant, &caracFermant);
      fgets(expression, 200, stdin);
      if(caracOuvrant == caracFermant)
      {
         printf("le caractere d'ouverture et de fermeture sont les memes\n");
      }
      else
      {
         verifier();
      }
   }
	return 0;
}

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

#include <stdio.h>

/* OK 0
 * KO 1 */

int check(const char *s);

int main(void)
{
        char str[BUFSIZ];

        fgets(str, sizeof str, stdin);
        str[BUFSIZ - 1] = '\0'; /* Sécurité pour la boucle for de check() */

        if(check(str) == 0)
                puts("Correct.");
        else
                puts("Incorrect.");

        return 0;
}

int check(const char *s)
{
        int cpt = 0, stop = 0;

        for(; *s && !stop; s++)
        {
                if(*s == '(')
                        cpt++;
                else if(*s == ')')
                        cpt--;
                if(cpt < 0)
                        stop = 1;
        }

        return cpt;
}

/* 11/07/09
By Monsieur_JaKy

But : vérifier si une expression est bien paranthésée

*/

#include <stdio.h>

static int check(const char* s)
{
    int occ = 0;
    while (*s != '\0')
    {
        if (*s == '(')
            occ++;
        else if (*s == ')')
            occ--;
        if (occ < 0)
            return 0;
        s++;
    }

    return occ == 0 ? 1 : 0;
}

int main()
{
    char s[50] = "";
    fgets(s, sizeof s, stdin);
    if (check(s) == 1)
        puts("Yes");
    else
        puts("No");

    return 0;
}

#include <stdio.h>

#define NELEM(a) (sizeof(a) / sizeof(*a))

static char zBrassRec(char const *src, char open, char close, int lvl)
{
    /* 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 = zBrassRec(src + 1, open, close, lvl + 1);
    else if (*src == close)
        lvl = zBrassRec(src + 1, open, close, lvl - 1);
    else
        lvl = zBrassRec(src + 1, open, close, lvl);

    return lvl;
}



/* char zBrass(char const *src, int lvl)
 * src    : Chaîne dont on veut vérifier le parenthèsage.
 * open   : Caractère representant la parenthèse ouvrante.
 * close  : Caractère représentant la parenthèse fermante.
 * Retour : 0 si la chaîne est ok, -1 sinon.
 */

char zBrass(char const *src, char open, char close)
{
    return zBrassRec(src, open, close, 0);
}



int main(void)
{
    struct test
    {
        /* Index du test courant */
        int id;
        /* Chaîne testée */
        char s[32];
        /* type de parenthèse */
        char open, close;
        /* Résultat attendu */
        int res;
    };

    static const struct test a[] =
    {
        {1, "(",		'(', ')', -1},
        {2, "()",		'(', ')',  0},
        {3, ")",	        '(', ')', -1},
        {4, "int main(void)",	'(', ')',  0},
        {5, "[a]a[aaa())))]",	'[', ']',  0},
        {6, "a}",	        '{', '}', -1},
        {7, "int main(void){}", '{', '}',  0},
    };
    size_t i;
    int terr = 0;
    for (i = 0; i < NELEM(a) && !terr; ++i)
    {
        struct test const *const p = a + i;
        int res = zBrass(p->s, p->open, p->close);

        if (res != p->res)
        {
            printf("ERR at test %d\n", p->id);
            terr = 1;
        }
    }
    if (!terr)
    {
        puts("\nP A S S E D\n");
    }

    return 0;
}

char zBrass(char const *src, char open, char close)

printf("%d", zBrass("((un test !...))", '(', ')'));

int brace(const char *str, const char start, const char end)
{
    int n = 0;
    for ( ; *str ; str++)
    {
        if (*str == start)
            n++;
        else if (*str == end)
            n--;
        if (n < 0)
            return 0;
    }
    return n == 0 ? 1 : 0;
}