problème addition et multiplication (BCD)

Version imprimable

Bonsoir, j'essai en ce moment de programmer une fonction multiplier.
On remarque que a*b = sum pour k allant de 0 à b-1 de a
ex: 4*3 = 4+4+4=12.
les nombres sont représentés dans des tableaux d'entiers avec un digit pour un indice. J'ai créé une fonction add pour faire l'addition. Mais je ne m'en sors pas avec le multiplier à cause des tableaux.
Voici mon code:

Code:

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
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
 
#define max(a,b) (a>=b?a:b)
 
void afficher(int a[], int len)
{
    int j = len-1;
    while(a[j]==0)
    {
        j--;
    }
    for(int i=0; i<=j; i++)
        {
            printf("%d",a[j-i]);
        }
}
 
/*
    fonction add(): calcul la somme de a et b et met le résultat dans c
    a[] et b[] sont les opérandes
    c[] représente le résultat.
    len1, len2, len3 sont les tailles respectives de a[], n[] et c[]
*/
void add(int a[], int b[], int len1, int len2, int c[], int len3) 
{
    int sum[len3];
    for(int i=0; i<len3; i++)
    {
        sum[i]=0;
    }
    for(int i=0; i<len1; i++)
    {
        sum[i]=a[i];
    }
    for(int j=0; j<len2; j++)
    {
        if((sum[j]+b[j])>=10)
        {
            sum[j]=sum[j]+b[j]-10;
            sum[j+1]=sum[j+1]+1;
        }
        else
        {
            sum[j]=sum[j]+b[j];
        }
    }
    for (int k=0; k<len3; k++)
    {
        c[k]=sum[k];
    }
}
 
void mult(int a[], int b[], int len1, int len2, int c[], int len3)
{
    int N = len1+len2;
    int product[N];
    for(int i=0; i<N; i++) // initialisation
    {
        product[i] = 0;
    }
 
    // Mon problème vient de comment réaliser la boucle pour ici (ou tant que)
 
 
    for (int k=0; k<N; k++)
    {
        c[k]=product[k];
    }
}
 
int main(int argc, char *argv[])
{
    int result;
    if (argc != 4)
    {
        fprintf(stderr, "ERROR : not enought or too much parameters!\n");
        return 1;
    }
    if ( strcmp(argv[2],"add")!=0 && strcmp(argv[2],"sub")!=0 && strcmp(argv[2],"mult")!=0 && strcmp(argv[2],"div")!=0)
    {
        fprintf(stderr, "ERROR : operator unknown\n");
        return 1;
    }
    else{
        int lenght1 = 0;
        lenght1=strlen(argv[1]);
        int lenght2 = 0;
        lenght2=strlen(argv[3]);
        int nbr1[lenght1];
        int nbr2[lenght2];
 
        for(int i=0; i<lenght1; i++)
        {
            if(isdigit(argv[1][i])==0)
            {
                fprintf(stderr, "ERROR : not a number\n");
                return 1;
            }
            nbr1[lenght1-1-i]= argv[1][i]-'0';
        }
        for(int j=0; j<lenght2; j++)
        {
            if(isdigit(argv[3][j])==0)
            {
                fprintf(stderr, "ERROR : not a number\n");
                return 1;
            }
            nbr2[lenght2-1-j]= argv[3][j]-'0';
        }
 
        if(strcmp(argv[2],"add")==0)
        {
            int N = max(lenght1,lenght2)+1;
            int result[N];
            add(nbr1, nbr2, lenght1, lenght2, result, N);
            afficher(nbr1,lenght1);
            printf("+");
            afficher(nbr2,lenght2);
            printf("=");
            afficher(result,N);
            printf("\n");
            return 0;
        }
if(strcmp(argv[2],"mult")==0)
        {
            int N=lenght1+lenght2;
            int result[N];
            mult(nbr1,nbr2,lenght1,lenght2,result);
            afficher(nbr1,lenght1);
            printf("*");
            afficher(nbr2,lenght2);
            printf("=");
            afficher(result,N);
            printf("\n");
            return 0;
        }
}

Citation:

Envoyé par jocelyn54

Code:

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
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
 
#define max(a,b) (a>=b?a:b)
 
void afficher(int a[], int len)
{
    int j = len-1;
    while(a[j]==0)
    {
        j--;
    }
    for(int i=0; i<=j; i++)
        {
            printf("%d",a[j-i]);
        }
}
 
/*
    fonction add(): calcul la somme de a et b et met le résultat dans c
    a[] et b[] sont les opérandes
    c[] représente le résultat.
    len1, len2, len3 sont les tailles respectives de a[], n[] et c[]
*/
void add(int a[], int b[], int len1, int len2, int c[], int len3) 
{
    int sum[len3];
    for(int j=0; j<len2; j++)
    {
        if((sum[j]+b[j])>=10)
        {
            sum[j]=sum[j]+b[j]-10;
            sum[j+1]=sum[j+1]+1;
        }
        else
        {
            sum[j]=sum[j]+b[j];
        }
    }
    for (int k=0; k<len3; k++)
    {
        c[k]=sum[k];
    }
}
 
void mult(int a[], int b[], int len1, int len2, int c[], int len3)
{
    int N = len1+len2;
    int product[N];
    for(int i=0; i<N; i++) // initialisation
    {
        product[i] = 0;
    }
 
    // Mon problème vient de comment réaliser la boucle pour ici (ou tant que)
 
 
    for (int k=0; k<N; k++)
    {
        c[k]=product[k];
    }
}
 
int main(int argc, char *argv[])
{
    int result;
    if (argc != 4)
    {
        fprintf(stderr, "ERROR : not enought or too much parameters!\n");
        return 1;
    }
    if ( strcmp(argv[2],"add")!=0 && strcmp(argv[2],"sub")!=0 && strcmp(argv[2],"mult")!=0 && strcmp(argv[2],"div")!=0)
    {
        fprintf(stderr, "ERROR : operator unknown\n");
        return 1;
    }
    else{
        int lenght1 = 0;
        lenght1=strlen(argv[1]);
        int lenght2 = 0;
        lenght2=strlen(argv[3]);
        int nbr1[lenght1];
        int nbr2[lenght2];
 
        for(int i=0; i<lenght1; i++)
        {
            if(isdigit(argv[1][i])==0)
            {
                fprintf(stderr, "ERROR : not a number\n");
                return 1;
            }
            nbr1[lenght1-1-i]= argv[1][i]-'0';
        }
        for(int j=0; j<lenght2; j++)
        {
            if(isdigit(argv[3][j])==0)
            {
                fprintf(stderr, "ERROR : not a number\n");
                return 1;
            }
            nbr2[lenght2-1-j]= argv[3][j]-'0';
        }
 
        if(strcmp(argv[2],"add")==0)
        {
            int N = max(lenght1,lenght2)+1;
            int result[N];
            add(nbr1, nbr2, lenght1, lenght2, result, N);
            afficher(nbr1,lenght1);
            printf("+");
            afficher(nbr2,lenght2);
            printf("=");
            afficher(result,N);
            printf("\n");
            return 0;
        }
if(strcmp(argv[2],"mult")==0)
        {
            int N=lenght1+lenght2;
            int result[N];
            mult(nbr1,nbr2,lenght1,lenght2,result);
            afficher(nbr1,lenght1);
            printf("*");
            afficher(nbr2,lenght2);
            printf("=");
            afficher(result,N);
            printf("\n");
            return 0;
        }
}

Ben si tu utilisais l'addition que t'as écrite pour faire ta multiplication ? 123 x 45 c'est bien 45 additions du nombre 123 non ?
123 x 45 = 0 + 123 + 123 + 123 + ... + 123 (45 répétitions)

Surtout que ça ressemble fort à un TP donc si j'étais prof, je serais heureux de voir que tu utilises les outils que tu crées pour en créer d'autres plus puissants...

PS: On peut optimiser la fonction "addition" en supprimant ce "sum" qui fait double emploi avec "c" et en évitant de répéter 3 fois l'addition (une fois dans le "if", une fois dans le "then" et une fois dans le "else")

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void add(int a[], int b[], int len1, int len2, int c[], int len3) 
{
    for(int i=0; i<len1; i++)
    {
        c[i]=a[i];
    }
    for(int j=0; j<len2; j++)
    {
        c[j]=c[j]+b[j];
        if(c[j] >= 10)
        {
            c[j]=c[j]-10;
            c[j+1]=c[j+1]+1;
        }
    }
}

05/12/2007, 19h45
jocelyn54

Citation:

Ben si tu utilisais l'addition que t'as écrite pour faire ta multiplication ? 123 x 45 c'est bien 45 additions du nombre 123 non ?
123 x 45 = 0 + 123 + 123 + 123 + ... + 123 (45 répétitions)
Surtout que ça ressemble fort à un TP donc si j'étais prof, je serais heureux de voir que tu utilises les outils que tu crées pour en créer d'autres plus puissants...

Je pense ceci aussi mais je n'arrive pas à modeliser la boucle pour afin de faire cette répetition. Je ne vois pas comment mettre à jour le tab.

J'ai écrit ceci pour mult :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 void mult(int a[], int b[], int len1, int len2, int c[], int len3) { int N = len1+len2; int product[N]; for(int i=0; i<N; i++) // initialisation { c[i] = 0; } for (int i=0; i<b[0]; i++) { add(c,a,N,len1,c,N); } }
Ca ne répond pas au problème d'une par car je m'occupe que de b[0] et non de b en entier. D'autre par, c[] n'évolue pas trop :(. Je veux dire que si par exemple, je met un cas où ça devrait marcher : 2 mult 3 dans la console, le résultat affiché est 2*3=2. Ce qui veut dire que la première somme est effectuée et mise dans c correctement mais que après incrémentation de i, on n'a pas la somme suivante qui se fait. Comment résoudre ces problèmes? Pouvez vous m'aider?

05/12/2007, 21h05
rebel64

Bonsoir jocelyn54,

Pour ton exemple 123 x 45:
Est-tu obligé de faire 45 additions pour ton exercice ?
Si tu as le choix, il est plus facile et plus performant de faire:

(1230 x 4) + (123 x 5)

Tu as alors maximum 9 additions par boucle...C'est plus facile
05/12/2007, 21h15
jocelyn54

Citation:

Envoyé par rebel64

Bonsoir jocelyn54,

Pour ton exemple 123 x 45:
Est-tu obligé de faire 45 additions pour ton exercice ?
Si tu as le choix, il est plus facile et plus performant de faire:

(1230 x 4) + (123 x 5)

Tu as alors maximum 9 additions par boucle...C'est plus facile

Je pense que faire le faire en 9 comme tu le proposes est possible encore que je ne vois pas comment m'y prendre de cette manière, le probleme vient surtout de la mise à jour du tableau.
05/12/2007, 22h29
rebel64
mult(...len3) ...len3 ne sert à rien ?
La longueur de ton nombre résultat est variable.
Ce serait plus facile si tu travaillais directement avec des chaines de caractères.
Code:

1 2 #define chiffre(a) ((a)-'0')
Tu pourras alors plus facilement concaténer (strcat), inverser (strrev)...
La longueur maximum n'est utile que pour allouer la mémoire.
07/12/2007, 18h22
Sve@r
Citation:

Envoyé par jocelyn54

Je pense ceci aussi mais je n'arrive pas à modeliser la boucle pour afin de faire cette répetition. Je ne vois pas comment mettre à jour le tab.

Je vais le mettre en pseudo langage parce que j'ai pas trop compris comment tu codes tes nombres (à l'endroit ? à l'envers ?)
Code:

1 2 3 4 5 6 7 void mult(int a[], int b[], int c[]) { Mettre la valeur "0" dans "c" for (i=0; i < la_valeur_representee_par_b; i++) Additionner "a" à "c" }
Citation:

Envoyé par rebel64

Bonsoir jocelyn54,

Pour ton exemple 123 x 45:
Est-tu obligé de faire 45 additions pour ton exercice ?
Si tu as le choix, il est plus facile et plus performant de faire:

(1230 x 4) + (123 x 5)

Tu as alors maximum 9 additions par boucle...C'est plus facile

Mais ça implique une analyse fine de "45". C'est à voir...
08/12/2007, 19h41
diogene

Sve@r :

Citation:

Ben si tu utilisais l'addition que t'as écrite pour faire ta multiplication ? 123 x 45 c'est bien 45 additions du nombre 123 non ?
123 x 45 = 0 + 123 + 123 + 123 + ... + 123 (45 répétitions)

- Le problème est que cette addition n'est pas concue pour faire ça : le résultat arrive dans un troisième tableau. Symboliquement :

Code:

a[]+b[]->c[].

Pour faire la multiplication, il faudrait l'adapter pour avoir un accumulateur

Code:

c[]+a[]->c[] ou c[]+b[]->c[].

Si les nombres sont un peu grands, on va faire une tonne de calculs. (C'est pourquoi, on apprend (ou on apprenait) une table de multiplication pour faire à la main ce genre de choses).

- Le code que tu proposes #2 ne tient pas compte de len3. De plus, si len2> len1, on va avoir des résultats bizarres (c[j] non initialisé), donc est à revoir.

- Ce que propose Rebel64 est d'utiliser la même méthode que celle qu'on utilise "à la main". L'opération élémentaire est du type

Code:

c[]*f +b*a[] ->c[]

f vaut 1 ou 10, b est un élément du tableau b[] .Ce n'est pas une fonction compliquée à coder.
Pour faire la multiplication, il suffit ensuite de l'appeler avec pour b tous les éléments du tableau b[], en commençant par l'élément de poids fort (en fin de tableau), et pour f, 1 la première fois et 10 les fois suivantes.