Discussion :

[Modaak]

Bonjour, ou bonsoir peut-être, j'aimerais que quelqu'un m'aide sur quelque chose que je ne comprends pas ! Ma fonction decomposition() doit retourner normalement le même nombre passé en paramètre ! quand je test sur des petits nombres de l'ordre de 10**3 à 10*9 cela marche mais quand je rentre par exemple 9999999999999 cela ne marche pas ! Et je ne comprends pas pourquoi ! si une personne peut me résoudre ce problème j'en serais ravi, merci d'avance pour toutes aides en tout cas ^^ et si vous avez d'autre chose à me conseiller sur mon code je suis preneur !
Normalement je vous ai mis en pièce jointe mon projet complet si nécessaire, avec mon .h et des tests aussi !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <errno.h>
 
#include "./spell-number.h"
 
Number is_negative(const Number N) {
  Number nb = {N.negative, N.number, N.language};
  if (N.number < 0) {
    nb.negative = 1;
  }
  return nb;
}
 
//cette fonction renvoie le nombre pivot associé au nombre
long long pivot_number(const long long nb) {
 
  if (60 <= nb && HUNDRED - 1 >= nb) {
    return TWENTY;
  }
  else if (10 <= nb && 60 > nb) {
    return 10;
  }
  else if (HUNDRED <= nb && THOUSAND - 1 >= nb) {
    return HUNDRED;
  }
  else if (THOUSAND <= nb && MILLION - 1 >= nb) {
    return THOUSAND;
  }
  else if (MILLION <= nb && BILLION - 1 >= nb) {
    return MILLION;
  }
  else if (BILLION <= nb && TRILLION - 1 >= nb) {
    return BILLION;
  }
  else if (TRILLION <= nb && QUADRILLION - 1 >= nb) {
    return TRILLION;
  }
  else if (QUADRILLION <= nb && QUINTILLION - 1 >= nb) {
    return QUADRILLION;
  }
  else if (QUINTILLION <= nb && LLONG_MAX >= nb) {
    return QUINTILLION;
  }
}
 
long long power(const int a, const int n) { //cette fonction retourne a**n ou a^n
  if(n == 0) {
    return(1);
  }
  return(a * power(a, n-1));
}
 
// cette fonction est encore en phase de développement elle n'est pas terminée mais elle doit décomposé un nombre
// prenons l'éxemple de 10050200, après traitement la fonction doit retournée 10050200 = (10) * 10**6 + (50) * 10**3 + 2 * 100
// c.f http://yann.coscoy.free.fr/nombre/info.html pour l'algorithme, rubrique décomposition arithmétique
long long decomposition(const long long nb) {
  long long p = pivot_number(nb);
  printf("p = %lld\n", p);
  long long rest = nb % p;
  long long quotient = nb / p;
  printf("quotient = %lld\n", quotient);
  printf("rest = %lld\n", rest);
  return quotient * p + rest;
}
 
int main(int argc, char *argv[]) {
  if (argc > 3) { //3 car argv[0] = ./spell-number
 
    printf("Vous avez rensigné trop d'arguments !\n");
    printf("Exemple : ./spell-number language number\n");
    return EXIT_FAILURE;
 
  } else if(argc == 3) {
 
    errno = 0; //je suis obligé d'utiliser la variable errno pour la gestion d'erreurs de atoi()
 
    long long nb = atoi(argv[2]); //convertion de la chaine de caractère en nombre
    char *lg_array = malloc(strlen(argv[1]) + 1); //Allocation de mémoire "+1" pour "\0"
    strcpy(lg_array, argv[1]); //copie des arguments vers lg_array
 
    Number nombre = {nombre.negative = 0, nombre.number = nb, nombre.language = lg_array}; //par défaut le nombre n'est pas négatif
 
    if (errno == 34) { //34 correspond à l'erreur : Numerical result out of range
      fprintf(stderr, "atoi : %s\n", strerror(errno)); //perror("atoi"); fait exactement la même chose
      printf("Votre valeur ne doit pas être inférieur au minimum = %lld, ou ne doit pas être supérieur au maximum = %lld.\n", LLONG_MIN, LLONG_MAX);
      return EXIT_FAILURE;
    }
 
    nombre = is_negative(nombre); //traitement de is_negative()
 
    if (nombre.negative == 1) {
      nombre.number = nombre.number * -1; //pour le rendre positif afin de rendre le traitement plus facile
    }
 
    long long d = decomposition(nombre.number);
    printf("decomposition = %lld\n", d);
 
    return EXIT_SUCCESS;
 
  } else {
 
    printf("Le nombre d'argument renseigné est insuffisant !\n");
    printf("Exemple : ./spell-number language number\n");
    return EXIT_FAILURE;
 
  }
}