Discussion :

[imrannasar]

Bonjour à tous,
voilà je vous présente un projet à réalisé de toute urgence, que je dois rendre.
Ce projet s'intitule "grands nombres entiers"
Je cite :
"Un nombre entier est formé de chiffres. Un grand nombre entier est formé de beaucoup de chiffres. Disons, une liste de chiffres, exemple (3 1 4 1 5 9 2 6 5). Il faut pouvoir travailler (calculer) avec de tels nombres, les additionner, les soustraire, les multiplier et diviser (division entière ou décimale), les mémoriser pour s'en servir pour faire des calculs."

Si quelqu'un aurais quelque piste pour moi s'il vous plait MERCI !

[Trap D]

Une des pistes possibles, c'est d'expliquer ce que vous avez déjà fait, ce qui vous pose problème avec des exemples de code.

[imrannasar]

Alors voici mon code, désormais je bloque au niveau de la boucle, (l'appel récursif) je ne sais pas comment le faire et ou le placer. et j'ai aussi un probleme au niveau de l'accumulateur (qui doit contenir une retenue afin d' additioner ou soustraire la retenue) en je ne sais pas comment le défénir.

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
(define (add l1 l2)
  (if (pair? l1)
      (if (pair? l2)
          
         (cons (+ (car (reverse l1)) (car (reverse l2))) '())
         
      #f)#f))

(define (sub l1 l2)
 (if (pair? l1)
      (if (pair? l2)
          
         (cons (- (car (reverse l1)) (car (reverse l2))) '())
         
      #f)#f))

[Trap D]

la retenue, ce n'est pas un problème, au départ elle est égale à 0. On peut l'intégrer facilement dans le mode opératoire.

[imrannasar]

je sais que acc = 0 et que je dois mettre une condition (if l'addition des cars des deux listes > 9) acc = 1.
Le souci ne viens pas du fait que je ne sais pas à quel valeur l'initialiser le souci c'est que je ne sais pas comment et ou le définir dans mon code...

[byjav]

Il vaut mieux disposer les chiffres dans l'ordre renversé, c'est-à-dire d'abord les unités, ensuite les disaines, les centaines, etc. Sinon ces REVERSEs superflus créent trop de garbage. Alors l'addition se produit de cette façon :

Code :

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

1
2
3
4
5
6
7
8
(define (raw-add l1 l2)
  (if (and (pair? l1) (pair l2))
      (cond ((null? l1) l2)
            ((null? l2) l1)
            (else (cons (+ (car l1)
                           (car l2))
                        (add (cdr l1) (cdr l2)))))
      #f))

(je ne l'ai pas testé, mais je pense que ça doit fonctionner). Mais c'est en effet l'addition brute, car (raw-add '(9 9) '(9 9)) produit '(18 18), et si on emploie par exemple le système décimale, on voudrais plutôt obtenir '(8 9 1). Alors if faut une fonction qui normalise une liste par rapport à une base donnée comme ça : ((18 18) 10) => (8 9 1).

[Trap D]

Ton idée est bonne, mais je préfère faire un calcul en utilisant une retenue.
Il faut aussi considérer les cas où les listes n'ont pas la même longueur.
PS le code est faux à l'avant dernière ligne c'est raw-add et non pas add qu'il faut écrire et renvoyer #f est un peu dur..., '() serait plus approprié.

[byjav]

Oui, c'est ma faute, j'ai oublié de changer add en row-add.

Les listes peuvent en effet avoir diverse longeur grâce aux première et deuxième clauses de COND.

Je crois qu'il n'y a pas besoin de contrôler si l1 et l2 satisfont pairs?. Ça pourrait être une espece de traitement d'erreurs, mais en tout cas je ne sais Scheme pas assez bien pour les traiter. Donc,

Code :

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

1
2
3
4
5
6
(define (raw-add l1 l2)
  (cond ((null? l1) l2)
        ((null? l2) l1)
        (else (cons (+ (car l1)
                       (car l2))
                    (raw-add (cdr l1) (cdr l2))))))

Quant'aux retinues, je pense qu'elles sont digne d'une fonction spéciale:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
(define (normalize base)
  (define (normalize lst)
    (if (null? lst)
        '()
        (let* ((a (car lst))
               (r (modulo a base))
               (q (/ (- a r) base))
               (tail (cdr lst)))
          (cond ((zero? q) (cons r (normalize tail)))
                ((null? tail) (list r q))
                (else (cons r (normalize (cons (+ (car tail) q)
                                               (cdr tail)))))))))
  normalize)

Cette fonction peut être pratique dans d'autres cas aussi.

[Trap D]

Oui, mais cela oblige à un parcours complet de la liste résultat ce qui n'a pas lieu si on utilise la retenue au moment du calcul.

[imrannasar]

c'est clair ! de plus pour la division et la multiplication du coup sa deviens très très compliqué il suffit qu'il multiplie les premiers chiffres c'est à dire exemple :
'(1 2 3 4) '(1 2 3 4)

il me multiplie 4 avec 4 3 avec 3 ... et pas 1234 * 1234 idem pour la division.
Un sacré casse tête ce langage scheme quand même !

[Trap D]

Il faudrait savoir exactement ce qui est demandé, (code efficace oup as) car la multiplication n'est jamais qu'une addition combinée avec une soustraction
x * y = somme de y termes égaux à x !

[byjav]

Pour la multiplication, je pense que cette formule récursive est efficace:
a * (r + 10q) = a * r + (a * 10) * q
Alors, il suffit de savoir multiplier par une chiffre (ce qui est simple) et par 10 (ce qui est encore plus simple). Je crois qu'il n'est pas nécessaire de normaliser les résultats intermédiaires.

[byjav]

Un sacré casse tête ce langage scheme quand même !

Tu penses que c'est plus facil d'écrir ça en C++? Vas-y.

[Trap D]

Je ne connaissais pas cette méthode (on apprend à tout âge !) mais c'est surement plus efficace que ma méthode un peu trop basique.