| Re: [LA-discussions] coder en scheme |
[ Thread Index |
Date Index
| More linuxarverne.org/discussions Archives
]
Daniel Cartron wrote:
Le vendredi 17 mai 2013 09:57:55 Kewl Cat a écrit :
admettons que ta liste "résultat de recherche"
s'appelle r
mais comment je la fais cette liste ?...
Alors, on va partir d'une liste vide qu'on va remplir lors d'une recherche :
(define resultat-recherche (list ))
(define (rechercher liste) (
(if (> (nbre-elem liste) 0)
(if (est-valeur-recherchee car(liste))
(let (resultat-recherche (append resultat-recherche car(liste))))
)
)
(if (> (nbre-elem liste) 1)
(rechercher-liste cdr(liste))
)
)
)
(define mel (append base_do cta))
(rechercher mel)
.... ou quelque chose d'approchant.
Maintenant, dans le détail, il nous faut un comparateur
"est-valeur-recherchee" qui retourne #t ou #f (qui sont, si j'ai bien
compris, les booléens true et false) si les premières valeurs sont 4 1 0 1 :
(define (est-valeur-recherchee liste) (
(and
(= (car liste) 4)
(= (car (cdr liste)) 1)
(= (car (cdr (cdr liste))) 0)
(= (car (cdr (cdr (cdr liste)) 1)
)
)
)
A partir de là on a de quoi construire "la grande liste" avec les
éléments qui commencent par 4 1 0 1. Il ne reste plus qu'à les traiter
pour récupérer les éléments "e" et "f" :
(define liste-resultats (list ))
(define (recuperer-e-f liste) (
(if (> (nbre-elem liste) 0)
(let liste-resultats (append liste-resultats ((car (cdr (cdr (cdr
(cdr liste))))) (car (cdr (cdr (cdr (cdr (cdr liste)))))))))
)
(if (> (nbre-elem liste) 1)
(recuperer-e-f (cdr liste))
)
)
)
A partir de là, exécuter (recuperer-ef (rechercher mel)) dervait nous
renvoyer une liste de couples (e f) correspondant à ce que tu cherches
(les valeurs "e" et "f" des listes commençant par 4 1 0 1)
.... si je n'ai pas foiré l'équilibrage des parenthèses, bien sûr...
Je te laisse le soin de trouver ou d'écrire la fonction nbre-elem qui
retourne le nombre d'éléments dans une liste ;-)
ma liste de listes:
(define cte
(list
(list 6 -1 0 2 2 2)
(list 4 -1 0 1 2 2)
(list 0 0 0 1 2 3)
(list 1 0 0 2 2 3)
(list 2 0 0 1 2 4)
(list 3 0 0 2 2 4)
(list 5 0 0 2 2 5)
(list 4 0 0 1 2 5)
(list 6 0 0 2 2 6)
(list 0 1 0 1 2 6)
(list 1 1 0 2 2 7)
(list 2 1 0 1 2 7)
(list 3 1 0 2 2 8)
(list 4 1 0 1 2 8)
(list 5 1 0 2 2 9)
(list 0 2 0 1 2 9)
(list 6 1 0 2 2 10)
(list 2 2 0 1 2 10)
(list 1 0 0 1 1 2)
(list 3 1/2 0 2 1 2)
(list 5 0 0 2 1 3)
(list 4 0 0 1 1 3)
(list 6 0 0 1 1 4)
(list 0 1 0 2 1 4)
(list 1 0 0 1 1 5)
(list 2 1 0 2 1 5)
(list 3 1 1/2 2 1 6)
(list 4 1 0 1 1 6)
(list 5 1 0 2 1 7)
(list 6 1 0 1 1 7)
(list 0 2 0 2 1 8)
(list 1 1 0 1 1 8)
(list 2 2 0 2 1 9)
(list 4 1 0 1 1 9)
(list 6 2 0 1 1 10)
(list 3 2 1/2 2 1 10)
(list 5 3 0 2 1 11)
(list 1 2 0 1 1 11)
(list 0 0 1/2 1 1 1)
(list 1 0 1/2 2 1 1)
(list 6 0 -1/2 1 2 1)
(list 4 0 1/2 2 2 1)
)
)
et je cherche à récupérer e et f pour a b c d = 4 1 0 1 (il y a deux
résultats, 1 6 et 2 8.
mais pour 3 1 0 il n'y a qu'une seule valeur possible, on n'a mm pas besoin
du d.
Si tu as plusieurs choses à tester tu peux paramétrer le comparateur
pour passer en second argument une liste contenant les valeurs
auxquelles les premiers éléments de la liste "à tester" doivent être égaux
et pour 6 1 0 on a soit 2 2 10 soit 1 1 7, et selon les cas je dois choisir
en fonction de d ou de e. Dans tous les cas la valeur finale qui m'intéresse
est d e f que ce soit l'unique solution ou que j'aie forcé la valeur d ou e.
donc comment tu écris (let ((x (cadddr r)) (y ((cadddddr r)))) pour que ça
fasse le boulot ?
merci
C'est un poil plus long à obtenir que ça, mais a priori tu récupères tes
valeurs dans la variable liste-resultats
Maintenant, si un expert de Scheme peut nous corriger tout ça, je suis
preneur :-p
=^.^=
--
Liste de discussions de LinuxArverne
http://wiki.linuxarverne.org/listes_de_diffusion