Discussion :

[Erwane]

Bonjour , j'ai écrit une fonction qui me calcule les coordonnées du centre de gravité d'un polygone à partir d'une liste , en faisant la moyenne des coordonnées x et les moyennes des coordonnées y , par exemple ma fonction doit se présenter comme suit :

(polygone (list (list 2 4) (list 4 6) (list 8 10) (list 2 4))

et elle doit me renvoyer : 4 6 , ( chaque list contient une coordonnée x et y ) . Mon probleme vient du fait que ma fonction ne rend que le 4 et pas le 6 , voici mon code :

Code :

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

1
2
3
4
5
(define (polygone L)
  (if (pair? L)
      (/ (+ (caar L) (caadr L) (caadr (cdr L)) (caadr (cddr L))) 4)
      (/ (+ (cadr (car L)) (cadr (car (cdr L))) (cadr (car (cdr (cdr L)))) (cadr (cadddr L)) 4)
      0)))

Mon erreur vient surement du if , je peux pas exécuter 2 actions dans le meme if il me semble car l'algorithme et les accessions aux listes sont corrects , quelqu'un pourrait il m'aider s'il vous plait ?

Je vous remercie .

[+Guilhem]

Si on "traduit" ton code en français, cela donne :

"Soit la fonction polygone prenant un argument L. Si L est un doublet, alors je renvoie la moyenne des 'car' de chaque sous-liste de L. Sinon je fais la somme des 'cadr' de chaque sous-liste de L, j'ajoute 4, je divise le tout par 0, et je renvoie le résultat."

=> Ton calcul de moyenne des coordonnées y n'est pas bon puisqu'il y a un problème de parenthésage.

=> Une fonction ne renvoie jamais plus d'un résultat. Si tu veux renvoyer plusieurs informations, tu peux par exemple les mettre dans un doublet...........

Au passage, la condition de ton "if" ne permet pas de savoir si la liste L contient des sous-listes (comme attendu).

[Jedai]

Voilà une fonction parfaitement illisible... Son nom est trompeur également puisqu'elle ne marche que pour les quadrilatères.

Il serait préférable de se renseigner un peu sur les fonctions de traitement de listes, par exemple map et length.

--
Jedaï

[Erwane]

J'ai pas le droit d'utiliser les fonctions lengh..seules car et cdr me sont permises .

Alors guillems , mon calcul de la moyenne de l'abscisse est juste , par contre yavait une erreur dans le calcul de l'ordonnée dû au paranthésage comme tu as dis , je l'ai corrigé et testé il fonctionne :

Code :

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

(/ (+ (cadr (car L)) (cadr (car (cdr L))) (cadr (car (cdr (cdr L)))) (cadr (cadddr L))) 4)

Au passage, la condition de ton "if" ne permet pas de savoir si la liste L contient des sous-listes (comme attendu).

Oui mais je ne sais pas comment écrire en scheme "si L contient les 4 sous L et qu'ils sont non vides " , je sais tester si une liste est vide mais pas si une liste contient d'autres listes ...

Une fonction ne renvoie jamais plus d'un résultat. Si tu veux renvoyer plusieurs informations, tu peux par exemple les mettre dans un doublet...........

Je ne vois pas trop comment faire ici , donc si en résume en français ça doit donner :

Si la liste contient 4 sous listes non vides , on calcule la moyenne des abscisses et des ordonnées et on renvoie le résultat sous forme de doublet .

J'ai fait les calculs mais coder en scheme le bon if et le doublet je ne trouve pas , tu peux m'éclairer ?

merci

[Jedai]

Bon je te donne la version avec fonctions avancées, à toi de les recoder, ce sera bien plus robuste que ta version actuelle et bien plus lisible. Incidemment mon code contient la solution à ta question initiale :

Code :

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

1
2
3
4
5
6
7
8
9
10
(define (polygone L)
  (if (pair? L)
      (let ([l (length L)])
        {list (/ (sum (map car L)) l) (/ (sum (map cadr L)) l)}
        )
      0
      )
  )

(define (sum L) (foldl + 0 L))

--
Jedaï

[Erwane]

merci bien jedai mais je suis un pur débutant et ton code est parfaitement illisible pour moi je ne comprends pas un seul mot , ou alors juste 1 , sans vouloir faire preuve de mauvaise volonté .

si quelqu'un d'autre à une réponse à mes 2 petites questions sur le if et le doublet elle est la bienvenue .

[+Guilhem]

Oui mais je ne sais pas comment écrire en scheme "si L contient les 4 sous L et qu'ils sont non vides " , je sais tester si une liste est vide mais pas si une liste contient d'autres listes ...

Pour cela il faudrait faire une récursivité sur la liste L. Mais c'est pas bien grave si tu t'assures qu'à chaque fois tu lui passes une liste de listes.
Par contre l'avantage de la récursivité c'est qu'elle te permet d'avoir autant de points que tu souhaites dans le polygone. Ce n'est pas très naturel et très élégant d'enchainer ainsi de suite les 'car', 'cadr', etc.

Un doublet (couple, "pair", ...) se fait avec un cons.
Donc si tu veux renvoyer deux résultats, tu peux les stocker dans un doublet :

Code :

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

(cons 1er-element 2eme-element)

Puis tu récupères les deux informations grâce aux fonctions élémentaires 'car' et 'cdr'.

A toi de jouer...

[Erwane]

oui c'est clair que mon écriture est affreuse et que c'est que pour un polygone 4 , mais sur ce que tu dis , la récursivité je la fais où , dans le if , après le if ?

Je trouve pas ça normal la récursivité car ici je veux écrire : Si la liste contient une liste , ET une autre liste , ET une autre liste .

La récursivité c'est plutot Si la liste contient une liste QUI contient une liste , QUI contient une liste , un peu comme des poupées russes...c'est pas le schéma de mon exercice .

Et ensuite je dois calculer la moyenne de tous les abscisses et ordonnées , franchement je laisse tomber c'est trop compliqué , merci bcp de votre aide !

[+Guilhem]

Pour l'instant oublie la récursivité et essaye de renvoyer tes deux résultats. Il n'y a qu'une chose à modifier sur ton code initial (hormis le problème de parenthésage).

[Garulfo]

Quelques détails :

Erwane: tes noms sont mal choisis comme le mentionnait Jedaï. Pour aider à la compréhension du système et à la lisibilité, il est classique, en Scheme, de redéfinir des niveaux d'abstraction par des simples changements de noms... Yo m'explique.

Code :

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

1
2
3
4
5
6
7
8
9
(define creer-point list)            ;; pourrait-être cons
(define creer-quadrilatere list) 
(define abscisse car)
(define ordonnee cadr)             ;; serait cdr si creer-point est cons
(define sommet-1 car)
(define sommet-2 cadr)
(define sommet-3 caddr)
(define (sommet-4 q) (car (cdddr x)))

Ainsi tu as des niveaux d'abstractions plus clairs et ton code est plus lisible.

+Guilhem il se trouve qu'en Scheme tu peux renvoyer plusieurs valeurs en utilisation les continuations, ou plus simplement value. Contrairement à un list qui crée une structure mémorisant les valeurs, un value transmet vraiment plusieurs valeurs en même temps.

Retour à Erwane
Ne cherches pas à retourner plusieurs valeurs. Si tu as formulé correctement ton problème, tu vois que tu dois retourner un point; ce n'est qu'une valeur. En réutilisant les abstractions ci-dessus, tu te rends compte que tu n'as qu'à le créer avant de le renvoyer.


Bon à toi de bouillir un peu. Sinon l'exercice ne sera pas pertinent.

[Erwane]

Pour l'instant oublie la récursivité et essaye de renvoyer tes deux résultats. Il n'y a qu'une chose à modifier sur ton code initial (hormis le problème de parenthésage).

Code :

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

1
2
3
4
5
(define (polygone L)
  (if (pair? L)
       (cons (/ (+ (caar L) (caadr L) (caadr (cdr L)) (caadr (cddr L))) 4) 
       (cons (/ (+ (cadr (car L))   (cadr (car (cdr L))) (cadr (car (cdr (cdr L)))) (cadr (cadddr L))) 4)
      0))))

curieux j'ai testé avec 4 listes contenenant 2 2 et ça me renvoie 2 2.0 , donc un entier et un décimal...

[Jedai]

Code :

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

1
2
3
4
5
(define (polygone L)
  (if (pair? L)
       (cons (/ (+ (caar L) (caadr L) (caadr (cdr L)) (caadr (cddr L))) 4) 
       (cons (/ (+ (cadr (car L))   (cadr (car (cdr L))) (cadr (car (cdr (cdr L)))) (cadr (cadddr L))) 4)
      0))))

curieux j'ai testé avec 4 listes contenenant 2 2 et ça me renvoie 2 2.0 , donc un entier et un décimal...

Non, pas un entier et un décimal mais deux entiers et un entier, ton code revient à faire :

Code :

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

(cons 2 (cons 2 0))

Ce qui ne te donne pas une liste correcte mais plutôt (2 2 . 0)

Tu devrais plutôt utiliser list comme dans ma proposition (ou celle de Garulfo si tu renommes list en creer-point comme il le proposait) :

Code :

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

1
2
3
4
5
6
(define (polygone L)
  (if (pair? L)
      (list (/ (+ (caar L) (caadr L) (caadr (cdr L)) (caadr (cddr L))) 4) 
            (/ (+ (cadr (car L))   (cadr (car (cdr L))) (cadr (car (cdr (cdr L)))) (cadr (cadddr L))) 4)
            )
      0))

--
Jedaï

[Erwane]

jedai je comprends mal ta réponse car l'exemple est trop lourd , regarde j'ai cré un autre code qui me renvoie une liste mais avec tjs ce petit probleme à la fin :

Code :

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

1
2
3
4
5
6
(define (yop L n)
  (if (pair? L)
      (if (<= (car L) n)
          (cons (car L) 
                (yop (cdr L) n))
          0)))

(yop (list 1 2 3 4 5 9) 7)
(1 2 3 4 5 . 0)

mon code fait ce que je veux mais ce 5.0 est vraiment laid , et en utilisant un list ça fait pire que mieux...

[Jedai]

En quoi

Code :

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

(cons 2 (cons 2 0))

est-il trop lourd ?

L'exemple minimal que je peux te fournir c'est :

Code :

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

(cons 2 0)

Ca fait (2 . 0), c'est à dire une paire, alors que tu veux une liste de deux éléments. Pour faire une liste avec cons, il faut lui donner un élément de la liste en premier argument et la queue de la liste en second, c'est à dire une autre liste. Il faudrait donc faire :

Code :

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

(cons 2 (list 0))

pour obtenir (2 0).

Ce qui se passe dans ton programme est similaire : ton parenthésage est incorrect, donc 0 n'est pas la seconde branche du if mais le second argument du cons, voilà pourquoi tu as ". 0)" à la fin de ton résultat.

--
Jedaï

[Erwane]

Code :

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

1
2
3
4
5
6
  (define (polygone L)
  (if (pair? L)
      (list (/ (+ (caar L) (caadr L) (caadr (cdr L)) (caadr (cddr L))) 4) 
            (/ (+ (cadr (car L))   (cadr (car (cdr L))) (cadr (car (cdr (cdr L)))) (cadr (cadddr L))) 4)
            )
      0))

cette fonction marche effectivement mais elle est affreuse vous avez raison , la réponse de garulfo est un peu trop compliquée pour moi , j'aimerais svp qu'on développe un peu l'idée de guillem et jedai , car j'aimerais savoir le faire pour un polynome de degré n , qui peut me filer l'algo en français j'essayerai de l'écrire demain , merci

[Garulfo]

[...]la réponse de garulfo est un peu trop compliquée pour moi[...]

Tu ne comprends pas que c'est le contraire.
Utiliser les définitions que je te donne va te permettre d'éclaircir ton problème en limitant les niveaux d'abstractions.
Ainsi tu ne penseras plus en terme de structure de donnée (des listes), mais en terme de donnée directement (des points et des quadrilatères).

Tu trouverais plus vite ta solution.
Supposons que tu crées tes points avec cons comme l'exemple (cons 2 (cons 2 0)) le suggère, alors ce que je viens d'écrire reviens à

Code :

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

1
2
(creer-point 2 (creer-point 2 0))

Est ce que cela semble cohérent ?
Non, car la création d'un point nécessite deux nombres et tu crées un point avec un nombre et un autre point. On voit vite que ça n'a pas de sens. C'est à ça que servent les niveaux d'abstractions: à cacher les détails inutiles à un certains niveaux (et aussi à la maintenance).

Réécris ton code avec les créateurs

Code :

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

1
2
(define creer-point cons)            ;; pourrait-être cons
(define creer-quadrilatere cons)

et les accesseurs

Code :

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

1
2
3
4
5
6
(define abscisse car)
(define ordonnee cdr)
(define sommet-1 car)
(define sommet-2 cadr)
(define sommet-3 caddr)
(define sommet-4 cdddr)

et tu réfléchiras à un niveau plus abstrait et donc moins complexe.

[Erwane]

garulfo je doute pas 1s que tu dis la vérité mais étant dans ma 1ere année de scheme , donc je me demande si ta méthode est accessible aux etudiants de 1ere année car j'ai beau fouiller mes cours depuis quelques minutes je ne vois pas quelque chose de similaire à ce que tu donnes...

j'essayerai quand meme de réfléchir à ta méthode

[Garulfo]

garulfo je doute pas 1s que tu dis la vérité mais étant dans ma 1ere année de scheme , donc je me demande si ta méthode est accessible aux etudiants de 1ere année car j'ai beau fouiller mes cours depuis quelques minutes je ne vois pas quelque chose de similaire à ce que tu donnes...

Non seulement c'est accessible à des étudiants qui étudient pour la première fois du Scheme, mais c'est accessible à des étudiants qui étudient pour la première fois la programmation quelque soit le langage.

Le concept d'abstraction est fondamental au regard du processus de développement. C'est un aspect méthodologique mais ce n'est pas une méthode.

Tu n'as pas compris que ça a pour but de limiter la complexité. Tu mets la charrue avant les bœufs: on commence par voir les choses de hauts puis on descend. Ce que je te propose est le découpage naturel issu d'une conception descendante. Et c'est bien la première chose qu'on devrait apprendre en informatique. En tout cas, dans beaucoup de programme c'est la première chose.

Ton problème est simplement que tu essayes de réfléchir aux détails (implémentation) avant de réfléchir au problème. Crois moi, ce que je te dis est testé depuis de nombreuses années en cours.

[+Guilhem]

+Guilhem il se trouve qu'en Scheme tu peux renvoyer plusieurs valeurs en utilisation les continuations, ou plus simplement value. Contrairement à un list qui crée une structure mémorisant les valeurs, un value transmet vraiment plusieurs valeurs en même temps.

Autant pour moi, j'avais oublié la continuation. Par contre je ne connais pas de tout value et j'ai rien trouvé sur le net ni dans mon bouquin. Si tu pouvais m'en dire un peu plus ou me rediriger vers de la doc, ça serait sympa.

[Garulfo]

Autant pour moi, j'avais oublié la continuation. Par contre je ne connais pas de tout value et j'ai rien trouvé sur le net ni dans mon bouquin. Si tu pouvais m'en dire un peu plus ou me rediriger vers de la doc, ça serait sympa.

J'ai fait une erreur de syntaxe, c'est values.
En fait un values est une continuation. C'est défini dans le R5RS.
On peut le définir par:

Code :

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

1
2
3
4
5
(define values . elements
  (call-with-current-continuation 
    (lambda (k) (apply k elements))
    )
  )

C'est sa définition officielle.
Il existe aussi la primitive call-with-values dans le R5RS.
Et let-values dans MzScheme.