Multiplier un tableau de chiffres par int en C

Donc, quelques observations:

1) Je ne pense pas qu'il soit nécessaire d'inverser le tableau. Traitez-le simplement du chiffre le moins significatif au chiffre le plus significatif.

2) Il n'y a aucune raison de stocker des valeurs temporaires plus grandes que votre plage de chiffres autorisée. Faites simplement le transport au fur et à mesure, comme vous le feriez si vous le faisiez à la main:

carry = 0
for i in all_the_digits:
    product = x[i]*y + carry
    x[i] = product%10
    carry = product/10

3) vous pouvez stocker les chiffres sous le nom uint8_t sans crainte de débordement - cela rendra votre tableau 1/4 de la taille actuelle, ce qui devrait améliorer la vitesse en raison des effets de mise en cache.

Comme demandé, voici un exemple de code qui multiplie un tableau par un seul chiffre. Le tableau est petit-boutiste. Pour un exemple simple, j'ai supposé que le tableau est de longueur fixe, un plus complexe allouerait de la mémoire du tableau et l'étendrait si le tableau devenait trop grand.

683215 * 7 = 4782505

Sortie du programme p >

#include <stdio.h>

#define BIGLEN 20

typedef struct {
    int length;
    int array[BIGLEN];
} biggy_t;

void bigmul(biggy_t *big, int mul)
{
    int carry = 0, partial;
    for(int i = 0; i < big->length; i++) {
        partial = big->array[i] * mul + carry;
        big->array[i] = partial % 10;
        carry = partial / 10;
    }
    if(carry) {
        big->array[big->length] = carry;
        big->length++;
    }
}

void bigout(biggy_t *big)
{
    for(int i = big->length-1; i >= 0; i--) {
        printf("%d", big->array[i]);
    }
}

int main(int argc, char *argv[])
{
    biggy_t big = { 6, { 5, 1, 2, 3, 8, 6 }};   // reverse order
    bigout(&big);
    printf(" * 7 = ");

    bigmul(&big, 7);
    bigout(&big);
    printf("\n");
}

J'ai écrit une implémentation bignum dans laquelle je peux choisir la base. 10 ou 100 pour le stockage d'octets, bien plus pour le stockage 32 bits. S'en tenir à une puissance de 10 rend la conversion en sortie décimale plus facile qu'une puissance de 2 radix, avec une petite pénalité de temps pour ne pas utiliser la pleine capacité du type de stockage.

Il y a plusieurs problèmes dans votre code. Je ne suis pas sûr de les avoir tous repérés mais en voici quelques-uns pour commencer.

Cette boucle:

len=7
value=1024772

exécute "lengthof_x + 1" fois. En d'autres termes - une fois de trop! Vous voulez le changer en:

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

struct returnpointer { int * pointer; int length; };

void print_num(struct returnpointer * num)
{
        printf("len=%d\nvalue=", num->length);
    for(int i = 0; i <num->length; i++) {
        printf("%d", num->pointer[i]);
    }
}

struct returnpointer mul_arrays(int * x, int y, int lengthof_x) {
    struct returnpointer result_end;
    int result[lengthof_x + 1];

    // Multiply all element and revert array
    int j = 0;
    for (int i = lengthof_x-1; i >= 0; i--) {
        result[j] = x[i] * y;
        j++;
    }

    // Handle carry 
    int carry = 0;
    for (j = 0; j < lengthof_x; j++) {
        result[j] = result[j] + carry;
        carry = result[j] / 10;
        result[j] = result[j] % 10;
    }

    // Did length increase
    if (carry)
    {
        lengthof_x++;
        result[j] = carry;
    }

    // malloc result and revert back to desired format
    j = 0;
    int* final_result = malloc(lengthof_x * sizeof *final_result);
    for (int i = lengthof_x-1; i >= 0; i--) {
        final_result[j] = result[i];
        j++;
    }

    result_end.pointer = final_result;
    result_end.length  = lengthof_x;
    return result_end;
}


int main(int argc, char *argv[])
{
    int arr[] = { 5, 1, 2, 3, 8, 6}; 
    struct returnpointer num = mul_arrays(arr, 2, 6);  // 512386 * 2 -> 1024772
    print_num(&num);
}

De plus, vous avez:

result_end.length  = i + 1;

mais il semble que vous ayez calculé le résultat dans la variable final_result afin que vous retourniez le mauvais tableau.

Cependant - dans tous les cas, vous n’êtes pas autorisé à renvoie un pointeur vers un tableau local! Il sortira de la portée lors du retour de la fonction. Donc même si vous faites:

result_end.pointer = final_result;

c'est toujours du code invalide. Vous aurez besoin de malloc le tableau (et cela nuira aux performances).

Ensuite, vous avez:

result_end.pointer = result;

Donc vous incrémentez la longueur dans tous les cas. C'est faux. Vous ne devriez incrémenter que lorsque vous avez un report.

Ci-dessous, j'ai essayé de corriger votre code, c'est-à-dire que j'ai essayé de conserver la structure globale de votre code afin que vous puissiez voir où vous avez fait des erreurs. p>

for (int i = lengthof_x - 1; i >= 0; i--) {  // notice the "- 1"
    result[j] = x[i] * y;
    j++;
}

Résultat:

for (int i = lengthof_x; i >= 0; i--) {
    result[j] = x[i] * y;
    j++;
}

Notez cependant que ce n'est pas une solution optimale ...