Forums des Zéros

13 mars 2010 à 23:28:00

Oui, l'exercice est sympa.

Bien content de me retrouver dans cette situation.

Je me réserve 15 jours, pour proposer une solution qui swingue!

edit comptant -> content :'(

Zeste de Savoir, le site qui en a dans le citron !

14 mars 2010 à 11:10:46

Citation : GurneyH

Oui, l'exercice est sympa.
Bien content de me retrouver dans cette situation.

Citation : meteor2

j'ai bien aimé cet exercice...

Je suis content que l'exercice vous plaise.

J'en viens maintenant à la solution de meteor2 qui a dû lire l'énoncé un peu vite.
Premièrement, ta solution n'est pas mal est montre que tu as compris comment faire dans l'ensemble. Mais tu à loupé pas mal de détails :

Il faut donner le plus de gros billets avant de passer au suivant même si l'utilisateur commence par demander des billets de 10€.
Il manque les accords (1 billet , 2 billets).
Je peux demander n'importe quel billet, de la valeur que je veux est autant de fois que je veux, de même pour les pièces. (On ne doit pas se limiter à 10 types de billets ou de pièces)
L'exercice 3 est en fait bien plus difficile puisque l'utilisateur peut demander des billets de n'importe quelle valeur (ex : 257896412365847896) il faut donc les traiter comme des chaines de caractères de même que pour la somme d'argent.

meteor2

14 mars 2010 à 14:39:10

Bha j'ai repris un ptit peu le code, pour qu'il accepte les billets de n'importe quelle valeur, ainsi que les pièces (même + grandes que les billets). (je fais un tri). Ainsi que le (s) à billet(s)/pièce(s)

Citation

L'exercice 3 est en fait bien plus difficile puisque l'utilisateur peut demander des billets de n'importe quelle valeur (ex : 257896412365847896) il faut donc les traiter comme des chaines de caractères de même que pour la somme d'argent.

Mon code gère ce cas-là...Par contre faut pas lui demander de couper 487845478411455411 en pièces de 1, sauf si on veut bien attendre 1 an...

#include <stdio.h>
#include <string.h>

int nbBillets, nbPieces;
char billets[1000][1000];
char estPieceOuBillet[1000];

void zCoupure (char* somme)
{
    int i, j;
    int tailleSomme = strlen(somme);

/*Boucle principale, elle boucle pour chaque billet...........*/
    for(i=0; i<nbBillets+nbPieces; i++)
    {
        int compteur = 0, tailleBillet = strlen(billets[i]);

    /*Cette condition dit: TANT QUE le billet est plus petit que la somme actuelle.........*/
        while((tailleSomme>tailleBillet) || (tailleSomme==tailleBillet && (strcmp(somme, billets[i]) >= 0)))
        {
            /*On soustrait sans se préocuper des retenues*/
            for(j=1; j<=tailleBillet; j++)
                somme[tailleSomme-j] = somme[tailleSomme-j] - (billets[i][tailleBillet-j] - '0');
            /*On s'occupe des retenues*/
            for(j=tailleSomme-1; j>0; j--)
            {
                if(somme[j] - '0' < 0)
                {
                    somme[j] = ((somme[j]-'0') + 10) +'0';
                    somme[j-1] -= 1;
                }
            }
            /*Si la chaine doit rétrécir...par ex somme = "100", "100"- "1" = "099", donc somme = somme +1 = "99"*/
            if(somme[0] == '0')
                somme++;
            compteur++;
            tailleSomme = strlen(somme);
        }

        /*Les premiers nombre du tableau sont les billets, les derniers sont les pièces*/
        if(compteur == 1)
            if(estPieceOuBillet[i] == 'B')
                printf("%d billet de %s\n", compteur, billets[i]);
            else
                printf("%d piece de %s\n", compteur, billets[i]);
        else
            if(estPieceOuBillet[i] == 'B')
                printf("%d billets de %s\n", compteur, billets[i]);
            else
                printf("%d pieces de %s\n", compteur, billets[i]);
    }
}

void trierBillets(char (*tab)[1000])
{/*Tri super pas optimisé, super lent, super lent =D  */
    int tailleTableau = nbBillets+nbPieces, estTrie = 0, i = 0;
    while(estTrie == 0)
    {
        estTrie = 1;
        for(i=0; i<tailleTableau-1; i++)
        {
            if((strlen(tab[i]) < strlen(tab[i+1])) || ((strlen(tab[i]) == strlen(tab[i+1]) && strcmp(tab[i], tab[i+1]) < 0)))
            {
                char temp[1000];
                strcpy(temp, billets[i]);
                strcpy(billets[i], billets[i+1]);
                strcpy(billets[i+1], temp);
                estTrie = 0;

                char temp_2 = estPieceOuBillet[i];
                estPieceOuBillet[i] = estPieceOuBillet[i+1];
                estPieceOuBillet[i+1] = temp_2;
            }
        }
        tailleTableau--;
    }
}


int main()
{
    char somme[1000*1000];
    int i;
//*On demande quels seront les billets et monaies utilisées....*/
    printf("Combien de billets?\n");
    scanf("%d", &nbBillets);

    printf("Combien de pieces?\n");
    scanf("%d", &nbPieces);

/*Je récupère les billets...............*/
    for(i=0; i<nbBillets; i++)
    {
        printf("Billet %d :\n", i+1);
        scanf("%s", billets[i]);
        estPieceOuBillet[i] = 'B';
    }
/*Je récupère les pièces /!\Les pièces seront stockées dans le tableau des billets (pour raccourcir le code)/!\*/

    for(;i<nbBillets+nbPieces; i++)
    {
        printf("Piece %d :\n", i-nbBillets+1);
        scanf("%s", billets[i]);
        estPieceOuBillet[i] = 'P';
    }

/*On trie...*/
    trierBillets(billets);

/*On demande la somme qu'on doit recouper....*/
    printf("Entrez la somme que vous voulez convertir\n");
    scanf("%s", somme);
    printf("\n\n");
    zCoupure(somme);
    return 0;
}

Il est vraiment pas optimisé mon code, alors si j'ai le temps, j'essaierai de prendre du temps pour faire un truc qui tienne bien la route.

Combien de billets?
3 
Combien de pieces?
3
Billet 1 :
30
Billet 2 :
50
Billet 3 :
20
Piece 1 :
1
Piece 2 :
5
Piece 3 :
700
Entrez la somme que vous voulez convertir
17806729783


25438185 pieces de 700
5 billets de 50
1 billet de 30
0 billets de 20
0 pieces de 5
3 pieces de 1

ça marche avec les gros billets aussi hein:

Combien de billets?
7
Combien de pieces?
0
Billet 1 :
1
Billet 2 :
10000   
Billet 3 :
10000000
Billet 4 :
10000000000
Billet 5 :
10000000000000
Billet 6 :
10000000000000000
Billet 7 :
10000000000000000000
Entrez la somme que vous voulez convertir
789412165456447645476547


78941 billets de 10000000000000000000
216 billets de 10000000000000000
545 billets de 10000000000000
644 billets de 10000000000
764 billets de 10000000
547 billets de 10000
6547 billets de 1

14 mars 2010 à 15:41:29

Je pensais qu'il était évident que billets représentaient des valeurs plus grandes que les pièces mais non. Je vais donc le préciser.

Autres choses :
Zéro est singulier donc : 0 billet (pas de 's').
Pour stocker les valeurs des billets et des pièces, il vaudrai mieux utiliser l'allocation dynamique plus qu'un tableau de 10 000 cases.
Les variables globales sont à éviter.

14 mars 2010 à 15:47:56

Citation : Lithrein

Zéro est singulier donc : 0 billet (pas de 's').

Zéro ça désigne "rien". Si c'est singulier ça voudrait dire qu'il vaut 1.

14 mars 2010 à 16:12:34

@Colb-Seton: En français 0 et 1 sont singulier les autres pluriel, donc 0 billet, 1 billet, 2 billets, ...
Alors qu'en anglais seul 1 est singulier : 0 bank notes, 1 bank note, 2 bank notes, ...
Mais là n'est pas le problème.

14 mars 2010 à 16:27:50

Non, le zéro n'est pas singulier (je te parle de la quantité), c'est ce qui suit le 0 qui l'est.

14 mars 2010 à 16:39:04

Oui, on est d'accord ce qui suit 0 ou 1 est forcément singulier tandis que ce qui suit 2, 3, ... est pluriel.

14 mars 2010 à 16:49:45

Bon histoire de pas poster pour rien, est ce que ce type d'exo a un nom ?
Parce que lors de mes recherches sur internet, je sais pas trop quoi taper. Tu pourrais donner des pistes sur des algos ou autre ?

Merci d'avance,

14 mars 2010 à 16:51:03

Citation : Colb-Seton

Bon histoire de pas poster pour rien, est ce que ce type d'exo a un nom ?
Parce que lors de mes recherches sur internet, je sais pas trop quoi taper. Tu pourrais donner des pistes sur des algos ou autre ?

Merci d'avance,

.

Oui, réfléchir.

Zeste de Savoir, le site qui en a dans le citron !

14 mars 2010 à 16:55:50

Citation : Colb-Seton

Bon histoire de pas poster pour rien, est ce que ce type d'exo a un nom ?
Parce que lors de mes recherches sur internet, je sais pas trop quoi taper. Tu pourrais donner des pistes sur des algos ou autre ?

Merci d'avance,

J'approuve GurneyH sur le fait qu'il faut réfléchir et non chercher un algorithme tout près, surtout que le niveau 1 n'est pas bien dur.
Si tu ne vois vraiment pas comment commencer tu peux toujours regarder comment fait meteor2 pour le niveau 2.

14 mars 2010 à 17:02:52

Ah si pour le niveau 1 j'ai un truc tout moche mais qui fonctionne.

#include <stdio.h>

void
z_coupure_v1(int sum)
{
        int i = 0;

        for(; sum >= 100; sum -= 100)i++;

        printf("Nombre de billets de 100 : %d\n", i);

        for(i = 0; sum >= 50; sum -= 50)i++;

        printf("Nombre de billets de 50 : %d\n", i);

        for(i = 0; sum >= 20; sum -= 20)i++;

        printf("Nombre de billets de 20 : %d\n", i);

        for(i = 0; sum >= 10; sum -= 10)i++;

        printf("Nombre de billets de 10 : %d\n", i);

        for(i = 0; sum >= 2; sum -= 2)i++;

        printf("Nombre de billets de 2 : %d\n", i);

        for(i = 0; sum >= 1; sum -= 1)i++;

        printf("Nombre de billets de 1 : %d\n", i);
}

int
main(void)
{
        z_coupure_v1(183);
        return 0;
}

14 mars 2010 à 17:25:09

Eh bien, c'est pas mal tu as trouvé la méthode naïve avec soustractions successives.
Si tu veux une piste : il existe une opération qui permet d'avoir le même résultat qu'avec les soustractions successives mais beaucoup plus rapidement.
Une autre : tu peux indexé la coupure possible dans un tableau.
Une petite remarque, quand il n'y a qu'un billet, billet ne prend pas de 's'. :-°

14 mars 2010 à 18:28:49

Mon essai pour le 2

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

#define MAX_LINE    256

int cmp(const void * pa, const void *pb)
{
    const int a = *(const int *)pa;
    const int b = *(const int *)pb;
    if (a < b)
        return 1;
    if (a > b)
        return -1;

    return 0;
}



void clearBuf(void)
{
    int c;
    while ((c = getchar()) != '\n' && c != EOF)
        ;
}

int saisir_i(char const *msg)
{
    int res;

    printf("%s ", msg);
    while (scanf("%d", &res) != 1)
    {
        puts( "Entrez un nombre !...");
        clearBuf();
    }

    return res;
}

int traiter(    int smm,            /* Somme courante */
                int *cprs,          /* Tableau de coupures */
                size_t n,           /* Nombre de coupures différentes */
                char const *s_nom)  /* Nom de de la coupure */
{
    size_t i;
    for (i = 0; i < n; i++)
    {
        if (smm >= cprs[i])
        {
            int q = smm / cprs[i];
            printf("%d %s%sde %d.\n", q, s_nom,
                   q > 1 ? "s " : "  ", cprs[i]);
            smm -= q * cprs[i];
        }
    }

    return smm;
}


size_t init_tab(int **t, char const *nom)
{
    char s_tmp[MAX_LINE];
    size_t i, n;

    sprintf(s_tmp, "Saisir le nombre de %ss : ", nom);
    n = saisir_i(s_tmp);

    *t = malloc(n * sizeof *(*t));
    if (*t == NULL)
    {
        perror("Erreur allocation");
        exit(EXIT_FAILURE);
    }

    for (i = 0; i < n; i++)
    {
        (*t)[i] = -1;
        sprintf(s_tmp, "%s %i -> ", nom, i + 1);
        while ((*t)[i] < 0)
            (*t)[i] = saisir_i(s_tmp);
    }

    qsort(*t, n, sizeof *(*t), cmp);

    return n;
}



int main(void)
{
    int *billets = NULL, *pieces = NULL;
    size_t n_billets, n_pieces;

    int somme;

    somme = saisir_i("Quelle somme desirez vous ? somme -> ");

    n_billets = init_tab(&billets, "billet");
    n_pieces = init_tab(&pieces, "piece");

    somme = traiter(somme, billets, n_billets, "billet");
    somme = traiter(somme, pieces,  n_pieces, "piece");

    free(billets), billets = NULL;
    free(pieces), pieces = NULL;

    return EXIT_SUCCESS;
}

Zeste de Savoir, le site qui en a dans le citron !

14 mars 2010 à 19:59:26

J'essaye d'implémenter, le 2 en récursif, Mais y'a un bug, je dois pas m'y prendre correctement.
J'ai dans l'idée de faire une fonction qui s'occupe de faire des coupures avec des billets, et et d'une autre avec les pièces. Ici je test déjà si ma méthode est bonne pour les billets. J'utilise les variables gloabales pour pas surcharger le prototype de ma fonction.

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

int     *t_piece,
        *t_billet,
        nb_billet,
        nb_piece;


void
remplir(int *t, int taille)
{
        int i = 0;

        printf("Vous avez le droit a %d billets differents\n\n", taille);

        for (; i < taille; i++) {
                printf("Billet numero %d ", i+1);
                scanf("%d", &t[i]);

        }
}

int
z_coupure_billet(int sum, int sum_per_billet)
{
        int i = 0;
        while (i < nb_billet) {
                if (sum == 0)return 0;

                printf("Nombre de billet de %d : %d \n", t_billet[i], z_coupure_billet(sum % t_billet[i], sum / t_billet[i]));
                ++i;
        }
}

int
main(void)
{
        printf("Combien de type piece voulez vous ?  ");
        scanf("%d", &nb_piece);

        t_piece = (int*)malloc(sizeof *t_piece * nb_piece);

        printf("Combien de type de billet voulez vous ?  ");
        scanf("%d", &nb_billet);

        t_billet = (int*)malloc(sizeof *t_piece * nb_piece);

        remplir(t_billet, nb_billet);
        remplir(t_piece, nb_piece);

        z_coupure_billet(100, 0);

        free(t_billet), free(t_piece);
        return 0;
}

Je cast mais faites pas attention :-°

...

J'aimerais savoir pourquoi ça plante.
Merci,

@GurneyH :

//ligne 70
*t = malloc(n * sizeof *(*t));

Tu peux suprrimer les parenthèses nan ?
*t = malloc(n * sizeof **t);

14 mars 2010 à 20:15:11

@ColbSeton:
Oui, je pourrais supprimer les parenthèses, mais, je trouve plus clair comme ça...

C'est d'ailleurs la raison, pour laquelle la plupart de tes codes plantent, tu tentes les raccourcis(et cherches la petite bête, cf le pluriel), avant d'avoir un code correct.

Citation : ColbSeton

J'essaye d'implémenter, le 2 en récursif, Mais y'a un bug, je dois pas m'y prendre correctement.

Pourquoi, tu n'essayes pas de faire le 1 correct? o_O

Zeste de Savoir, le site qui en a dans le citron !

Pouet_forever

14 mars 2010 à 20:17:04

Le copier/coller c'est mal :

Citation : Colb-Seton

t_billet = (int*)malloc(sizeof *t_piece * nb_piece);

Tu appelles la fonction 'remplir' mais tu ne demandes que des billets alors qu'il y a aussi des pièces ...
Les variables globales sont-elles vraiment indispensable ?
Ta fonction z_coupure_billet retourne un int mais est-ce vraiment utile ?

Et oui tu peux mettre sans parenthèses. Tu devrais commencer par initialiser tes boucles 'for' plutôt que jouer sur des détails insignifiants comme ça ...

@GurneyH : J'aime bien ton code.

14 mars 2010 à 20:20:25

Citation : Pouet_forever

@GurneyH : J'aime bien ton code.

Et, tu ne sais pas combien je suis heureux de poster du code.

Zeste de Savoir, le site qui en a dans le citron !

14 mars 2010 à 20:46:00

Citation : Pouet_forever

Tu appelles la fonction 'remplir' mais tu ne demandes que des billets alors qu'il y a aussi des pièces ...

C'est bien tu chipotes sur l'affichage.

Citation : Pouet_forever

Les variables globales sont-elles vraiment indispensable ?

Oui, j'ai d'ailleurs dis pourquoi.

Citation : Pouet_forever

Ta fonction z_coupure_billet retourne un int mais est-ce vraiment utile

Bah faut croire car sinon le compilateur me lance une erreur dans la tronche.

Citation : Pouet_forever

Et oui tu peux mettre sans parenthèses. Tu devrais commencer par initialiser tes boucles 'for' plutôt que jouer sur des détails insignifiants comme ça ...

Oui et toi tu devrais te mêler de tes affaires.

Citation : GurneyH

@ColbSeton:
Oui, je pourrais supprimer les parenthèses, mais, je trouve plus clair comme ça...
C'est d'ailleurs la raison, pour laquelle la plupart de tes codes plantent, tu tentes les raccourcis(et cherches la petite bête, cf le pluriel), avant d'avoir un code correct.

Y'a un lien avec la ptite bête et le code qui plante ?
Je tiens quand même à dire que ma question c'était pas pour jouer... Mais tant pis.

Donc en fait GurneyH si j'ai bien compris tes parenthèses sont aussi inutiles que les miennes quand je fais return (p_new);

14 mars 2010 à 20:59:42

C'est vrai que le code de GurneyH est vraiment clair, il n'y a même pas besoin d'utiliser les commentaires pour comprendre.
Juste une remarque :
Je pense que tu peux améliorer cette partie.

int q = smm / cprs[i];
printf("%d %s%sde %d.\n", q, s_nom,
q > 1 ? "s " : "  ", cprs[i]);
smm -= q * cprs[i];

Comme ça (par exemple) :

div_t q = div(smm, cprs[i]);
printf("%d %s%sde %d.\n", q.quot, s_nom,
q.quot > 1 ? "s " : "  ", cprs[i]);
smm = q.rem;

@Colb-Seton : ta fonction z_coupure_billet sert strictement à rien (elle renverra toujours 0 :-°

).
Pourquoi tu te prends une erreur dans ta tronche quand tu ne précise pas que son type de retour est entier.
Un début de réponse sur cette ligne (j'ai mis pourquoi entre chevrons) :

printf("Nombre de billet de <%d> : %d \n", t_billet[i], <z_coupure_billet(sum % t_billet[i]>, sum / t_billet[i]));

Pouet_forever

14 mars 2010 à 21:19:16

L'affichage fait partie de l'exercice ...
Les variables ne sont en aucun cas indispensable, surtout sur un petit code comme ça. Si tu réfléchis 2 secondes tu pourrais voir que tu peux ne pas surcharger tes fonctions avec 50 variables mais 2 voire 3 à tout casser.
Le compilo te retourne une erreur parce que tu as fait une erreur.
Avec des réponses comme ça tu n'évolueras jamais ... la critique fait avancer en général, avec toi elle te fait reculer j'ai bien l'impression ...

14 mars 2010 à 22:02:22

@lithrein : en effet! :-°

@colb: Tu cherches à jouer!
Un peu trop à mon gout!
Mais continue, on va rire!

edit: effectivement ça va swinguer! :colere2:

Citation : ColbSeton

Donc en fait GurneyH si j'ai bien compris tes parenthèses sont aussi inutiles que les miennes quand je fais return (p_new);

edit: Il y a une nuance, je sais ce que je fais. Ce n'est pas ton cas...;)

Zeste de Savoir, le site qui en a dans le citron !

Stagiaire en C

15 mars 2010 à 10:03:06

Ma solution pour le 1er exercice (d'abord j'avais fait les soustractions mais là j'ai utilisé une méthode un peu différente)

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

void coupure(int somme)
{
    int n = 0;

    n = somme / 100;
    if (n > 1) {
        printf("%d billets de 100.\n", n);
    } else if (n == 1) {
        printf("1 billet de 100.\n");
    }

    somme -= n*100;
    n = somme / 50;
    if (n > 1) {
        printf("%d billets de 50.\n", n);
    } else if (n == 1) {
        printf("1 billet de 50.\n");
    }

    somme -= n*50;
    n = somme / 20;
    if (n > 1) {
        printf("%d billets de 20.\n", n);
    } else if (n == 1) {
        printf("1 billet de 20.\n");
    }

    somme -= n * 20;
    n = somme / 10;
    if (n > 1) {
        printf("%d billets de 10.\n", n);
    } else if (n == 1) {
        printf("1 billet de 10.\n");
    }

    somme -= n * 10;
    n = somme / 2;
    if(n > 1) {
        printf("%d pieces de 2.\n", n);
    } else if (n == 1) {
        printf("1 piece de 2.\n");
    }

    somme -= n * 2;
    if(somme > 1) {
        printf("%d pieces de 1.", somme);
    } else if (somme == 1) {
        printf("1 piece de 1.");
    }
}

int main(void)
{
    int somme;
    printf("Quelle somme voulez-vous? ");
    scanf("%d", &somme);
    coupure(somme);

    return EXIT_SUCCESS;
}

Solution pour le 2ème exercice

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

void triBillet(int billet[], int nombre)
{
    int i, j, k;

    //Cette  fonction sert à mettre les billets par ordre décroissant

    for(j = 0; j < nombre; j++) {
        for(i = 0; i < nombre - 1; i++) {
            if (billet[i] < billet[i+1]) {
                k = billet[i];
                billet[i] = billet[i+1];
                billet[i+1] = k;
            }
        }
    }
}

void coupure(int somme, int billet[], int typeBillet)
{
    int n, i;

    for(i = 0; i < typeBillet; i++) {
        n = somme / billet[i];
        if (n > 1) {
            printf("%d billets de %d.\n", n, billet[i]);
        } else if (n == 1) {
            printf("1 billet de %d.\n", billet[i]);
        }
        somme -= n*billet[i];
    }
    if (somme > 1) {
        printf("%d pieces de 1.", somme);
    } else if (somme == 1) {
        printf("1 piece de 1.");
    }
}

int main(void)
{
    int somme, typeBillet = 0, i;
    int *billet;
    while(typeBillet < 1 || typeBillet > 6) {
        printf("Combien de types de billets voulez-vous (a choix : 10, 20, 50, 100, 200, 1000) ? ");
        scanf("%d", &typeBillet);
    }
    billet = malloc(typeBillet * sizeof(int));
    for(i = 0; i < typeBillet; i++) {
        while(billet[i] != 10 && billet[i] != 20 && billet[i] != 50 && billet[i] != 100 && billet[i] != 200 && billet[i] != 1000) {
            printf("Valeur du billet (%d / %d) : ", i + 1, typeBillet);
            scanf("%d", &billet[i]);
        }
    }
    triBillet(billet, typeBillet);

    printf("Quelle somme voulez-vous? ");
    scanf("%d", &somme);
    coupure(somme, billet, typeBillet);

    return EXIT_SUCCESS;
}

15 mars 2010 à 11:49:20

@Stagière en C : C'est un bon début bien que tu puisse largement améliorer ta solution pour l'exercice 1.
Pour le deuxième je dois pouvoir choisir tout les billets que je veux et toutes les pièces que je veux or la ta solution ne me le permet pas.
Je rappelle que ce n'est pas une course, ce n'est pas celui qui soumet son code le plus vite qui gagne.

Donc un conseil, revois ta solution pour le niveau 1 (ça vaut aussi pour Colb-Seton) car ton code n'est absolument pas évolutif, si je te donne plus de possibilités de billets tu vas devoir modifié pas mal de choses.
Puis refais le niveau 2 tranquillement.

Stagiaire en C

15 mars 2010 à 12:30:09

Pour le 2ème je me suis dit qu'un billet de 45.- ça existait pas donc ça me paraissait plus logique..

Correction pour le 1 (j'ai utilisé une boucle et un tableau d'entiers pour la valeur du billet)

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

void coupure(int somme)
{
    int n, i;
    int billet[4] = {100, 50, 20, 10}, piece[2] = {2, 1};

    for (i = 0; i < 4; i++) {
        n = somme / billet[i];
        if (n > 1) {
            printf("%d billets de %d.\n", n, billet[i]);
        } else if (n == 1) {
            printf("1 billet de %d.\n", billet[i]);
        }
        somme %= billet[i];
    }

    for (i = 0; i < 2; i++) {
        n = somme / piece[i];
        if (n > 1) {
            printf("%d pieces de %d.\n", n, piece[i]);
        } else if (n == 1) {
            printf("1 piece de %d.\n", piece[i]);
        }
        somme %= piece[i];
    }
}

int main(void)
{
    int somme;
    printf("Quelle somme voulez-vous? ");
    scanf("%d", &somme);
    coupure(somme);

    return EXIT_SUCCESS;
}

Voilà le deux on peut choisir n'importe quelle valeur pour les billets et les pièces.

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

void tri(int tableau[], int tailleTableau)
{
    int i, j, k;

    for(j = 0; j < tailleTableau; j++) {
        for(i = 0; i < tailleTableau- 1; i++) {
            if (tableau[i] < tableau[i+1]) {
                k = tableau[i];
                tableau[i] = tableau[i+1];
                tableau[i+1] = k;
            }
        }
    }
}

void coupure(int somme, int billet[], int typeBillet, int piece[], int typePiece)
{
    int n, i;

    for(i = 0; i < typeBillet; i++) {
        n = somme / billet[i];
        if (n > 1) {
            printf("%d billets de %d.\n", n, billet[i]);
        } else if (n == 1) {
            printf("1 billet de %d.\n", billet[i]);
        }
        somme %= billet[i];
    }

    for(i = 0; i < typePiece; i++) {
        n = somme / piece[i];
        if (n > 1) {
            printf("%d pieces de %d.\n", n, piece[i]);
        } else if (n == 1) {
            printf("1 piece de %d.\n", piece[i]);
        }
        somme %= piece[i];
    }
}

int main(void)
{
    int somme, typeBillet = -1, typePiece = -1, i;
    int *billet, *piece;

    while(typeBillet < 0) {
        printf("Combien de types de billets voulez-vous? ");
        scanf("%d", &typeBillet);
    }
    billet = malloc(typeBillet * sizeof(int));
    for(i = 0; i < typeBillet; i++) {
        printf("Valeur du billet (%d / %d) : ", i + 1, typeBillet);
        scanf("%d", &billet[i]);
    }
    tri(billet, typeBillet);

    printf("Combien de types de pieces voulez-vous? ");
    scanf("%d", &typePiece);
    piece = malloc(typePiece * sizeof(int));
    for(i = 0; i < typePiece; i++) {
        printf("Valeur de la piece (%d / %d) : ", i + 1, typePiece);
        scanf("%d", &piece[i]);
    }
    tri(piece, typePiece);

    printf("Quelle somme voulez-vous? ");
    scanf("%d", &somme);
    coupure(somme, billet, typeBillet, piece, typePiece);

    return EXIT_SUCCESS;
}

darkipod

15 mars 2010 à 13:32:30

bonjour
voici ma contribution :-°

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

void Zcoupure(int valeur)
{
    int coupure[7]={100,50,20,10,5,2,1};
    int fois[7]={0,0,0,0,0,0,0};
    int i=0;
    char chaine[10];
    printf("valeur a echanger : %d\n",valeur);

    //decomposition de la valeur
    while (valeur !=0)
    {
        fois[i]=valeur / coupure[i];
        valeur= valeur % coupure[i];
        i++;
    }
    // affichage de la decomposition

    for (i=0;i<7;i++)
    {
       if (i<5)
           {
               // 0 à 4 ce sont les billets
               if (fois[i]>1) { strcpy(chaine,"billets");}
               else           { strcpy(chaine,"billet");}
           }
        else
           {
               // 5 et 6 ce sont des pieces
               if (fois[i]>1) { strcpy(chaine,"pieces");}
               else           { strcpy(chaine,"piece");}
           }

        if (fois[i] !=0)
        {
            // affichage uniquement que s'il y a la coupure concernée
            printf ("%d X %d %s \n",fois[i],coupure[i],chaine);
        }
    }

}
int main(void)
{
    Zcoupure(867);
    return 0;
}

j'ai pas trouve plus simple pour l'affichage ! Qu'en pensez vous sinon je passe au niveau II

Merci pour les exos et les superbes corrections

HighTam

15 mars 2010 à 16:29:38

Voici ma tentative pour le niveau 2

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

typedef struct Coupure
{
    int *t_b;
    int n_b;
    int *t_p;
    int n_p;
} Coupure;

int fill(int *eff, int *t, int n, int s)
{
    int i = 0;
    while (i < n)
    {
        if (s >= t[i])
        {
            eff[i]++;
            s -= t[i];
        }
        else
            i++;
    }
    return s;
}

void zCoupure(int s, Coupure coupure)
{
    int *eff_b = NULL, *eff_p = NULL;
    int i = 0;

    eff_b = calloc(coupure.n_b, sizeof(int));
    eff_p = calloc(coupure.n_p, sizeof(int));

    if (eff_b == NULL || eff_p == NULL)
    {
        perror("Erreur allocation de memoire");
        exit(EXIT_FAILURE);
    }

    s = fill(eff_b, coupure.t_b, coupure.n_b, s);
    s = fill(eff_p, coupure.t_p, coupure.n_p, s);

    for (i = 0 ; i < coupure.n_b ; i++)
        printf(eff_b[i] > 1 ? "%d billets de %d.\n" : "%d billet de %d.\n", eff_b[i], coupure.t_b[i]);
    for (i = 0 ; i < coupure.n_p ; i++)
        printf(eff_p[i] > 1 ? "%d pieces de %d.\n" : "%d piece de %d.\n", eff_p[i], coupure.t_p[i]);

    free(eff_b), eff_b = NULL;
    free(eff_p), eff_p = NULL;
}

int main(void)
{
    int s = 0, i = 0;
    Coupure coupure = {NULL, 0, NULL, 0};

    printf("Combien de types de billets ? ");
    scanf("%d", &coupure.n_b);
    printf("Combien de types de pieces ? ");
    scanf("%d", &coupure.n_p);

    coupure.t_b = malloc(coupure.n_b*sizeof(int));
    coupure.t_p = malloc(coupure.n_p*sizeof(int));

    if (coupure.t_b == NULL || coupure.t_p == NULL)
    {
        perror("Erreur allocation de memoire");
        exit(EXIT_FAILURE);
    }

    printf("Les billets :\n");
    for (i = 0 ; i < coupure.n_b ; i++)
        scanf("%d", &coupure.t_b[i]);
    printf("Les pieces :\n");
    for (i = 0 ; i < coupure.n_p ; i++)
        scanf("%d", &coupure.t_p[i]);

    printf("Quelle somme voulez-vous ? ");
    scanf("%d", &s);
    zCoupure(s, coupure);

    free(coupure.t_b), coupure.t_b = NULL;
    free(coupure.t_p), coupure.t_p = NULL;

    return 0;
}

Par contre, je n'ai pas bien compris le niveau 3 !!