Qnope

À propos de Antoine

Antoine Morrier

Date de naissance : 16 octobre

Envoyer un message

Biographie

Mes Zexos en C


ZMath : L'objectif de cet exercice est de réaliser un calculateur d'expressions sous la forme NPI (notation polonaise inverse) en vous servant des piles. Vous devez donc vous imaginer un algorithme qui permettrait d'évaluer un calcul en NPI en retournant le résultat. Il existe un tutoriel non-officiel sur ce site traitant des piles (structure de données), vous allez devoir le lire pour mener à bien cet exercice. ;)

Cette calculatrice gère les fonctions mathématique pow sqrt, log, exp, sin et cos.
Elle gère les nombres positifs, négatifs, entier, ou décimaux.

#define MAXVAL 10000
#define NOMBRE '0'
#define RESULTAT '='
#define NOM 'n'
#include <stdio.h>
#include <math.h>

double depiler(void);/*Renvoie la valeur en l'enlevant de la pile*/
double resultModul(double, double);/*Renvoie le modulo entre 2 double*/
void empiler(double n);/*empile une valeur*/
void foo_math(const char *s);/*Cherche une fonction*/
int strcmp(const char *s, const char *t);/*Cherche des erreurs*/
int lire_op(char *s);/*Lit la chaine rentrer*/
int isDigit(int n);/*renvoie 1 si c'est un nombre, 0 si c'est autre chose*/
int isOperator(int n);/*Renvoie 1 si c'est un operateur*/
int isLetter(int c);/*Renvoie 1 si c'est une lettre*/
double atof(const char *s);/*Convertie la chaine s en un double*/
int tolower(int c);/*Renvoie la lettre en minuscule*/

double PILE[MAXVAL] = {0};/*La pile*/
int p = 0;

void foo_math(const char *s)
{
    double op_2;

    if(!strcmp(s, "pow"))
    {
        op_2 = depiler();
        empiler(pow(depiler(), op_2));
    }

    else if(!strcmp(s, "sin"))
    {
        empiler(sin(depiler()));
    }

    else if(!strcmp(s, "cos"))
    {
        empiler(cos(depiler()));
    }

    else if(!strcmp(s, "sqrt"))
    {
        empiler(sqrt(depiler()));
    }

    else if(!strcmp(s, "exp"))
    {
        empiler(exp(depiler()));
    }

    else if(!strcmp(s, "log"))
    {
        empiler(log(depiler()));
    }/*Si la fonction est entrer*/

    else
    {
        printf("Erreur, cette fonction n'existe pas");
    }
}

double resultModul(double n1, double n2)
{
    int In1 = (int)n1, In2 = (int)n2;
    int modul = In1 % In2;

    return (double)modul;
}

double depiler(void)
{
    if(p > 0)
        return PILE[--p];

    else printf("Erreur, la pile est vide\n");

    return -1;
}

void empiler(double n)
{
    if(p < MAXVAL)
        PILE[p++] = n;

    else printf("Erreur, la pile est pleine\n");
}


int strcmp(const char *s, const char *t)
{
    int i = 0;

    while(s[i] && t[i])
    {
        if(s[i] > t[i])
            return 1;

        else if(s[i] < t[i])
            return -1;
        ++i;
    }
    return 0;
}

int isLetter(int n)
{
    return ((n >= 'a' && n <= 'z') || (n >= 'A' && n <= 'Z')) ? 1 : 0;
}

int tolower(int c)
{
    return (c >= 'A' && c < 'Z') ? (c - 'A' + 'a') : c;
}

double atof(const char *s)
{
    double n = 0;
    int diviseur = 10;
    char virgule = 0;
    int i = 0;
    int signe;

    signe = (s[i] == '-') ? -1 : 1;


    while(s[i])
    {
        if(s[i] == '.' || s[i] == ',')
            virgule = 1, ++i;

        if(!virgule)
        {
            if(s[i] >= '0' && s[i] <= '9')
            {
                n *= 10;
                n += (char)(s[i++] - '0');
            }

            else ++i;
        }

        else if(virgule)
        {
            if(s[i] >= '0' && s[i] <= '9')
            {
                n += (double)((s[i++] - '0') / (double)diviseur);
                diviseur *= 10;
            }
            else ++i;
        }
    }
    n *= signe;
    return n;
}

int isOperator(int n)
{
    return ((n == '%' || n == '+' || n == '-' || n == '/' || n == '*') ? 1 : 0);
}

int isDigit(int n)
{
    return ((n >= '0' && n <= '9') || n == '.' || n == ',') ? 1 : 0;
}

int lire_op(char *s)
{
    int i = 0, c = 0;
    static char buff[10] = {0};
    static int p_buff = 0;

    s[0] = '\0';

    while(c != RESULTAT)
    {
        if(p_buff)
            c = buff[--p_buff];

        else c = getchar();

        if(c == '-')
        {
            if(p_buff)
                c = buff[--p_buff];

            else c = getchar();

            if(isDigit(c))
            {
                s[i++] = '-';
                s[i] = '\0';
            }

            else
            {
                buff[p_buff++] = (char)c;
                c = '-';
            }
        }

        if(i > 0 && ((isDigit(s[i - 1])) && (c == ' ' || isLetter(c) || isOperator(c))))
        {
            if(isLetter(c) || isOperator(c))
                buff[p_buff++] = (char)c;

            return NOMBRE;
        }

        else if(i > 0 && ((isLetter(s[i - 1])) && (c == ' ' || c == '\n' || isOperator(c) || isDigit(c))))
        {
            if(isOperator(c) || isDigit(c))
                buff[p_buff++] = (char)c;

            else if(c == '\n')
                buff[p_buff++] = (char)c;

            return NOM;
        }

        if(isDigit(c))
        {
            s[i++] = (char)c;
            s[i] = '\0';
        }

        else if(isLetter(c))
        {
            c = tolower(c);
            s[i++] = (char)c;
            s[i] = '\0';
        }

        else if(isOperator(c))
        {
            return c;
        }

        if(c == '\n')
            return RESULTAT;
    }

    return c;
}

int main(void)
{
    int type = 0;
    double op_2;
    char s[500] = "";

    while(type != RESULTAT)
    {
        type = lire_op(s);
        switch(type)
        {
            case NOMBRE:
                empiler(atof(s));
            break;

            case NOM:
                foo_math(s);
            break;

            case RESULTAT:
                printf("%f\n", depiler());
            break;

            case '+':
                empiler(depiler() + depiler());
            break;

            case '*':
                empiler(depiler() * depiler());
            break;

            case '-':
                op_2 = depiler();
                empiler(depiler() - op_2);
            break;

            case '/':
                op_2 = depiler();
                if(op_2 < 0 || op_2 > 0)
                    empiler(depiler() / op_2);

                else printf("\nLa division par 0 est impossible\n");
            break;

            case '%':
                op_2 = depiler();
                if(op_2 < 0 || op_2 > 0)
                    empiler(resultModul(depiler(), op_2));

                else printf("\nLa division par 0 est impossible\n");
            break;

            default : break;
        }
    }
    return 0;
}


Exemple d'utilisation

125 -125- 10*100/Sqrt3poW3+
128.000000


125 -125-.
La pile contient les nombre 125 et -125, ont lit l'opérateur moins
cela donne 125 -(-)125 = 250
10*
La pile contient les nombres 250 et 10, ont lit l'opérateur *
cela donne 250 * 10 = 2500
100/
La pile contient les nombre 2500 et 100, on lit l'opérateur /
cela donne 2500 / 100 = 25

sqrt donne la racine carré de 25, la pile ne contient plus que 5.

3pow, on élève 5 au cube donc 125
3+ on ajoute 3 a 125 donc 128.

Faites attentions, si le moins est un opérateur, veuillez faire un espace après(ou une fonction mathématique mais pas de chiffre).


ZBinary : L'objectif de cet exercice est de réaliser un convertisseur de valeurs en base décimal (10) vers la base binaire (2). L'exo vous entraînera à l'algorithmique et à la compréhension de la base binaire. C'est un très bon exercice et tout ce qu'il vous faut se trouve sur ce site. Cherchez par exemple le tutoriel sur les conversions de bases ou essayer de trouver une autre méthode pour déterminer une valeur binaire. ;)

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

void binToDeci(int b);
void deciToBin(int n);
int my_Pow(int n, int e);

int my_Pow(int n, int e)
{
    int nombreBase = n;

     if(!e)
        return 1;

    while(e > 1)
    {
        e--;

        n *= nombreBase;
    }

    return n;
}

void deciToBin(int n)
{
    int b = 1;
    while((b * 2) <= n)
    {
        b *= 2;
    }

    while(b)
    {
        if(b <= n)
        {
            printf("1 ");
            n -= b;
        }
        else printf("0 ");

        b /= 2;
    }
}

void binToDeci(int b)
{
    int n = 0, multiplicateur = 0;

    while(b)
    {
        n += ((b % 2) * my_Pow(2, multiplicateur));
        ++multiplicateur;
        b /= 10;
    }

    printf("%d\n", n);
}

int main(void)
{
    binToDeci(11111110);

    deciToBin(255);

    return 0;
}


254
1 1 1 1 1 1 1 1


ZReader : L'objectif de cet exercice et que vous réalisiez un programme en mode console qui vous permettra d'ouvrir et donc de lire un fichier, de créer un fichier dont on aura le choix de l'extension, et d'écrire dans un fichier. Pour cet exercice, vous devez avoir lu le chapitre de m@teo21 sur la lecture et l'écrite dans les fichiers en C (si vous n'y connaissez encore rien, c'est l'occasion d'apprendre). La manipulation des fichiers est un domaine incontournable en programmation, c'est une opportunité pour vous de vous y préparer dés maintenant.

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

void creerFile(const char *path);
void ecrireChaine(char *s);
void lireFile(const char *path);
void ecrireFile(const char *path);
unsigned my_atoi(const char *s);

void ecrireFile(const char *path)
{
    FILE *file = fopen(path, "w");
    int c;
    if(!file)
        printf("Impossible de trouver le fichier"), exit(1);

    do
    {
        c = getchar();
        if(c != EOF)
            fputc(c, file);

    }while(c != EOF);
}

void lireFile(const char *path)
{
    FILE *file = fopen(path, "r");
    int c;
    if(!file)
        printf("Impossible de trouver le fichier"), exit(1);

    do
    {
        c = fgetc(file);
        printf("%c", c);
    }while(c != EOF);
}

unsigned my_atoi(const char *s)
{
    unsigned n = 0, i = 0;

    while(s[i])
    {
        n *= 10;
        n += (unsigned)s[i++] - '0';
    }

    return n;
}

void creerFile(const char *path)
{
    FILE *file = fopen(path, "w");
    fclose(file);
}

void ecrireChaine(char *s)
{
    int i = 0, c = 0;

    while((c = getchar())!= '\n')
        s[i++] = (char)c;

    s[i] = '\0';
}

int main(void)
{
    char s[100] = "";
    unsigned choix;
    printf("Veuillez entrez votre choix\n1. Creer un ficher\n2. Lire un fichier\n3. Ecrire dans un fichier\n");
    ecrireChaine(s);
    choix = my_atoi(s);

    while(choix >= 1 && choix <= 3)
    {
        switch(choix)
        {
            case 1:
                printf("Veuillez entrer le nom de votre fichier\n");
                ecrireChaine(s);
                creerFile(s);
            break;

            case 2:
                printf("Veuillez entrer le nom de votre fichier\n");
                ecrireChaine(s);
                lireFile(s);
            break;

            case 3:
                printf("Veuillez entrer le nom de votre fichier\n");
                ecrireChaine(s);
                ecrireFile(s);
            break;

            default : break;
        }

        printf("Veuillez entrez votre choix\n1. Creer un ficher\n2. Lire un fichier\n3. Ecrire dans un fichier\n");
        ecrireChaine(s);
        choix = my_atoi(s);
    }
    return 0;
}


zStrcapitalize : Vous devez coder la fonction strcapitalize: elle met en majuscule la premiere lettre d'une phrase, et tout le reste en minuscule. Il y a néanmoins une contrainte: vous devrez recoder toute fonctions utilisees, donc choisissez les bien :p

#include <stdio.h>

void ecrireChaine(char *s);
void my_puts(const char *s);
int tolower(int c);
int toupper(int c);
int isspace(int c);
void strcapitalize(char *s);

int isspace(int c)
{
    return(c == ' ' || c == '\t' || c == '\n') ? 1 : 0;
}

void strcapitalize(char *s)
{
    unsigned i = 0;

    while(isspace(s[i]))++i;

    s[i] = toupper(s[i]);
    ++i;
    while(s[i])
    {
        s[i] = (char)tolower(s[i]), ++i;
    }
}

int tolower(int c)
{
    return (c >= 'A' && c <= 'Z') ? (c - 'A' + 'a') : c;
}

int toupper(int c)
{
    return (c >= 'a' && c <= 'z') ? (c - 'a' + 'A') : c;
}

void my_puts(const char *s)
{
    unsigned i = 0;
    while(s[i])
        putchar(s[i++]);
}

void ecrireChaine(char *s)
{
    int i = 0, c = 0;

    while((c = getchar())!= '\n')
        s[i++] = (char)c;

    s[i] = '\0';
}

int main(void)
{
    char s[1100];

    ecrireChaine(s);

    strcapitalize(s);

    my_puts(s);
    return 0;
}


zAddition : L'objectif de zAddition est tout simple (ou pas) : Coder une fonction qui concatène deux matrices. Pour rappel : une matrice est un tableau à deux dimensions. Pour cet exercice, ne vous embêtez pas avec le type des données : prenez des int. ;) Une concaténation est une "fusion", c'est à dire que l'on réunit les deux matrices en une seule et ce grace à la fonction que vous allez devoir coder.
J'utilise pas de malloc, c'est pourquoi mes tableaux font tous la même taille ;-)
#include <stdio.h>
#include <time.h>

unsigned randNext = 0;

void srand(unsigned);
int rand(void);
void afficheTab(int t[][8], int y, int x);
void concatene(int t[][8], int t1[][8], int t2[][8], int Y, int xt1, int xt2);
void initTab(int t[][8], int y, int x);/*Remplit de nombres pseudo aléatoire*/

void initTab(int t[][8], int y, int x)
{
    int i, j;

    for(j = 0; j < y; j++)
    {
        for(i = 0; i < x; i++)
        {
            t[j][i] = rand() % 32768;
        }
    }
}

int rand(void)
{
    randNext *= 11035878;
    randNext += 1234543;
    randNext /= 65536;

    return (int)randNext;
}

void srand(unsigned amorce)
{
    randNext = amorce;
}

void concatene(int t[][8], int t1[][8], int t2[][8], int Y, int xt1, int xt2)
{
    int i;
    while(Y)
    {
        for(i = 0; i < xt1; ++i)
            t[Y - 1][i] = t1[Y - 1][i];

        for(; i < (xt1 + xt2); ++i)
            t[Y - 1][i] = t2[Y - 1][i - xt1];

        --Y;
    }
}

void afficheTab(int t[][8], int y, int x)
{
    int i, j;
    for(j = 0; j < y; j++)
    {
        for(i = 0; i < x; i++)
        {
            printf("%d ", t[j][i]);
        }
        printf("\n");
    }
    printf("\n");
}

int main(void)
{
    int matrice1[10][8] = {{0}};
    int matrice2[10][8] = {{0}};
    int matrice3[10][8] = {{0}};/*déclare 3 tableaux de 10 d'ordonnées, et de 8 abcisses*/

    srand((unsigned)time(NULL));

    initTab(matrice1, 10, 5);
    initTab(matrice2, 10, 3);

    afficheTab(matrice1, 10, 5);
    afficheTab(matrice2, 10, 3);

    concatene(matrice3, matrice1, matrice2, 10, 5, 3);

    afficheTab(matrice3, 10, 8);

    return 0;
}


zGame : L'exercice de ce mois-ci sera : un jeu : zGame !
Ce jeu sera d'un niveau simple afin qu'un maximum de débutants en C puissent le coder. Il est dans le même style que le jeu du pendu proposé par M@teo21 ici (lien). Il va vous permettre de pratiquer, mais pas contre, il n'y a pas de thème bien particulier, vous allez devoir réutiliser quasiment tout ce que vous savez (variables, conditions, boucles, nombres pseudo-aléatoires, calculs, etc.).

En plus, vous ne perdez rien, en vous entraînant, vous réalisez un jeu amusant et utile ! :) Let's go.

Le but du jeu


zGame est un grand classique parmi les jeux que l'on réalise pour s'entraîner.

Le programme vous tire une série de dix calculs mathématiques sur les tables de multiplication (oui, ceux qu'on bosse en primaire ^^ ). Le but du jeu est de trouver la bonne réponse à ces calculs le plus rapidement possible et en faisant le moins d'erreurs possibles.
#include <stdio.h>
#include <time.h>

unsigned int randNext = 0;

void zgame(int *nErreur);
void ecrireN(char *s, int limite);
int my_atoi(char *s);
int rand(void);
void srand(unsigned amorce);

int rand(void)
{
    randNext *= 11035878;
    randNext += 1234543;
    randNext /= 65536;

    return (int)randNext;
}

void srand(unsigned amorce)
{
    randNext = amorce;
}

int my_atoi(char *s)
{
    int signe, n = 0, i = 0;

    signe = (s[i] == '-') ? -1 : 1;

    while(s[i])
    {
        n *= 10;
        if(s[i] >= '0' && s[i] <= '9')
            n += (int)s[i++] - '0';

        else ++i;
    }

    return n * signe;
}

void ecrireN(char *s, int limite)
{
    int c, i = 0;
    while(i < limite && (c = getchar()) != '\n')
        s[i++] = (char)c;

    s[i] = '\0';
}

void zgame(int *nErreur)
{
    char s[12];
    int n, compteur = 10, chiffre1, chiffre2;
    *nErreur = 0;

    while(compteur)
    {
        chiffre1 = rand()%11;
        chiffre2 = rand()%11;
        printf("%d * %d = ", chiffre1, chiffre2);
        ecrireN(s, 12);
        n = my_atoi(s);
        if(n != (chiffre1 * chiffre2))
            (*nErreur)++;

        --compteur;
    }
}

int main(void)
{
    time_t t1;
    time_t t2;
    int nombreErreur;

    printf("Bienvenue dans Z Game\nCe jeu va vous faire 10 exos de calcul mental en vous faisant calculer 2 facteur\nIl va ensuite vous donner le temps mis et le nombre d'erreur\n");
    t1 = time(NULL);
    srand((unsigned)t1);
    zgame(&nombreErreur);

    t2 = time(NULL);

    printf("Vous avez fait %d erreur(s) en %u secondes", nombreErreur, (t2 - t1));

    return 0;
}


ZstrStat : Le but de l'exercice est de comptabiliser le nombre d'occurences de chaque caractère alphanumérique (lettres majuscules et minuscules, chiffre) dans une phrase donnée, phrase ne comportant aucun accent. Tout autre caractère ne devra pas être pris en compte.

#include <stdio.h>
#include <time.h>

void ecrireChaine(char *s, int limite);
void fillTab(char *s, int *t);
void afficheTab(int *t);

void afficheTab(int *t)
{
    int i;
    for(i = 0; i < 26; i++)
    {
        if(t[i])
            printf("Il y a %d %c\n", t[i], (i + 'a'));
    }

    for(; i < 36; i++)
    {
        if(t[i])
            printf("Il y a %d %c\n", t[i], (i + '0' - 26));
    }
}

void fillTab(char *s, int *t)
{
    int i = 0;
    while(s[i])
    {
        if(s[i] >= 'A' && s[i] <= 'Z')
            t[s[i] - 'A']++;

        else if(s[i] >= 'a' && s[i] <= 'z')
            t[s[i] - 'a']++;

        else if(s[i] >= '0' && s[i] <= '9')
            t[s[i] - '0' + 26]++;

        ++i;
    }
}

void ecrireChaine(char *s, int limite)
{
    int c, i = 0;
    while(i < limite && (c = getchar()) != '\n')
        s[i++] = (char)c;

    s[i] = '\0';
}

int main(void)
{
    char s[1000];
    int t[36] = {0};

    ecrireChaine(s, 1000);
    fillTab(s, t);
    afficheTab(t);
    return 0;
}


ZstrSearch :
#include <stdio.h>
#include <time.h>

void my_strstr(const char *s, const char *t, int *nombreOccurence, int *tab);
void afficheTab(int *t, int taille);

void afficheTab(int *t, int taille)
{
    int i;

    if(!taille)
        printf("Aucune occurence trouver\n");
    for(i = 0; i < taille; ++i)
        printf("%d ", t[i]);
}

void my_strstr(const char *s, const char *t, int *nombreOccurence, int *tab)
{
    int i, j = 0;

    *nombreOccurence = 0;

    for(i = 0; s[i] != '\0'; ++i)
    {
        for(j = 0; ; ++i, ++j)
        {
            if(t[j] == '\0')
            {
                tab[*nombreOccurence] = i - j + 1;
                (*nombreOccurence)++;
            }

            else if(s[i] != t[j])
                break;

        }
        i-=j;
    }
}

int main(void)
{
    char s[] = "blafoobarblofoohafouhafou";
    char t[] = "foo";
    int tab[1000] = {0};
    int nombreOccurence;

    my_strstr(s, t, &nombreOccurence, tab);

    afficheTab(tab, nombreOccurence);

    return 0;
}


zBrace : L'idée de cet exercice peut se résumer en quelques mots : coder un algorithme qui vérifie qu'une expression est correctement parenthésée. Une expression désigne ici n'importe quoi, en réalité, tous les caractères sauf '(' et ')' peuvent être utilisés et ces deux derniers seront utilisés pour la représentation des parenthèses. Vous pouvez permettre à l'utilisateur de choisir les caractères de ses parenthèses (c'est plus pratique et plus générique) comme '[' ']' ou encore '{' '}'.

#include <stdio.h>
#include <time.h>

int zBrace(const char *s);

int zBrace(const char *s)
{
    int parentheseOuverte = 0;
    int parenthesefermee = 0;
    int accoladeOuverte = 0;
    int accoladeFermee = 0;
    int crochetOuvert = 0;
    int crochetFermee = 0;
    int i = 0;

    while(s[i])
    {
        if(s[i] == '(')
           parentheseOuverte++;

        else if(s[i] == ')')
            parenthesefermee++;

        else if(s[i] == '{')
            accoladeOuverte++;

        else if(s[i] == '}')
            accoladeFermee++;

        else if(s[i] == '[')
            crochetOuvert++;

        else if(s[i] == ']')
            crochetFermee++;

        if((parenthesefermee > parentheseOuverte) || (accoladeFermee > accoladeOuverte) || (crochetFermee > crochetOuvert))
            return ((parenthesefermee - parentheseOuverte) + (accoladeFermee - accoladeOuverte) + (crochetFermee - crochetOuvert));

        ++i;
    }

    return ((parenthesefermee - parentheseOuverte) + (accoladeFermee - accoladeOuverte) + (crochetFermee - crochetOuvert));
}

int main(void)
{
    char s[] = "fmldkf(fm[ldk(flk)]()fdmkf)(f)d[]";

    int n = zBrace(s);

    if(!n)
        printf("Bien parentheser");

    else printf("Mal parentheser");
    return 0

Signature

http://cpp-rendering.io : Vous trouverez tout ce dont vous avez besoin sur Vulkan / OpenGL et le rendu 3D !

Information sur le compte

Date d'inscription : 12 mai 2010

Dernière connexion : 15 février 2019