char *classic_sus_op(char const *str1, char const *str2)
{
    int i = my_strlen(str1) - 1;
    int j = my_strlen(str2) - 1;
    int k = 0;
    int rest = 0;
    char *result = malloc(sizeof(char) * (i + j + 1));
    int dec_i = 0;
    int dec_j = 0;
    int test = 0;

    while (i >= 0 || j >= 0 || rest != 0){
        dec_i = (i >= 0) ? str1[i] - '0' : 0;
        dec_j = (j >= 0) ? str2[j] - '0' : 0;
        test = dec_i - dec_j + rest;
        if (test < 0){
            result[k] = (test + 10) + '0';
            rest = 1;
        }
        if (test >= 0){
            result[k] = test + '0';
            rest = 0;
        }
        k++;
        i--;
        j--;
    }
    result = my_revstr(result);
     if (result[0] == '0')
        my_putchar('0');
     else
         my_putstr(result);
     my_putchar('\n');
    return (result);
}

void infin_sus(char *av1, char *av2)
{
    int i = my_getnbr(av1);
    int j = my_getnbr(av2);

    if (i > j){
        classic_sus_op(av1, av2);
    } else {
        my_putchar('-');
        classic_sus_op(av2, av1);
    }
}

int main(int ac, char **av)
{
    infin_sus(av[1], av[2]);
}

Bonjour tous le monde. Voici mon programme pour la réalisation d'une soustraction infinie. Mais le probleme que j'ai rencontré est qu'il me renvoie une mauvaise réponse pour par exemple 1000 - 500... ça me renvoie 2050. Mais je ne comprends pas trop pourquoi. Mon algorithme me semble pourtant bien implémenter.

Bonjour,

a) Ligne 7, la taille allouée n'est pas la bonne, il y a parfois fois trop de caractères réservés, parfois il n'y en a pas assez. Par exemple si tu soustraits "1" de "5" il faut réserver 2 caractères pour stocker le "4".
b) Ligne 15, tu appliques ta retenue dans le mauvais sens.
c) Ligne 27, à la fin de la boucle, la chaîne result n'a jamais reçu de terminateur.
d) Ligne 29, ton traitement des nombres commençant par '0' est peut-être un peu trop réducteur.
e) tu fais une allocation de mémoire, mais jamais de libération.

char *classic_sus_op(char const *str1, char const *str2)
{
    int i = my_strlen(str1) - 1;
    int j = my_strlen(str2) - 1;
    int k = 0;
    int rest = 0;
    char *result = malloc(sizeof(char) * (i + j + 1));
    int dec_i = 0;
    int dec_j = 0;
    int test = 0;

    while (i >= 0 || j >= 0 || rest != 0){
        dec_i = (i >= 0) ? str1[i] - '0' : 0;
        dec_j = (j >= 0) ? str2[j] - '0' : 0;
        test = dec_i - dec_j + rest;
        if (test < 0){
            result[k] = (test + 10) + '0';
            rest = 1;
        }
        if (test >= 0){
            result[k] = test + '0';
            rest = 0;
        }
        k++;
        i--;
        j--;
    }
    result[k] = '\0';
    result = my_revstr(result);
     if (result[0] == '0')
        my_putchar('0');
     else
         my_putstr(result);
     my_putchar('\n');
    return (result);
    free(result);
}

void infin_sus(char *av1, char *av2)
{
    int i = my_getnbr(av1);
    int j = my_getnbr(av2);

    if (i > j){
        classic_sus_op(av1, av2);
    } else {
        my_putchar('-');
        classic_sus_op(av2, av1);
    }
}

Voilà ce que j'obtiens. Pour les nombres commencant par 0 c'était pour ne pas avoir de sortie comme 0000 et 0020...

Mais je ne comprends pas pourquoi tu as parlé de gestion de retenu mal effectuer. As tu une autre façon de ge=érer les retenus à me proposer ?