Salut
 
Je ne sais pas si bcp de personnes connaissent ce language : Scheme mais moi j'ai pas mal de fonction qui ne sont pas définies dans mes cours.
 
Je sais que car ( 1 2 3 4 5 ) => ( 1 )
 
et que cdr (1 2 3 4 5 ) => ( 2 3 4 5 )
 
la je suis bloqué sur une composition de ces deux fonctions : caadr  
 
je pense que caadr ( 1 2 3 4 5 ) => ( 2 ) est ce correct ???
 
Merci d'avance !!!
 
J'en rajouterai d'autre derriere. Si vous pouviez m'aider svp...

1. Tu peux installer un interpréteur scheme pour tester ce genre de trucs, tu sais, c'est pas très compliqué
2.

(caadr lst)

est équivalent à

(car (car (cdr lst)))

Il suffit donc d'appliquer l'expansion de caadr à ta liste.

(car (car (cdr '(1 2 3 4 5))))
; On applique cdr, donc on récupère la tail de la liste
(car (car '(2 3 4 5))
; On applique car, donc on récupère le head de la liste
(car 2)
; On applique car, donc on récupère le head de la liste
; "2" n'est pas une liste, donc on a une erreur

Et effectivement, si on essaie ce code dans un interpréteur

Ca me semble pourtant relativement simple
(et accessoirement, non tu n'en ajouteras pas d'autres, si tu veux savoir ce qui se passe tu installes un interpréteur et tu vas lire R5RS)

C est ce que j ai fait !!! Mais la galere pour en trouver un J'ai pris DrScheme. Ca a l'air correct!!!
 
Du coup j'avais taper juste !!! YES !!!
 
Par contre est ce que c est possible de montrer les étapes de réflections de l ordinateur sur une commande ???
 
J'ai cette fonction :
 
(length (cons (+ 1 2) (append '(list 3 4) '(cons 5 6))))
 
et je ne trouve pas le meme résultat que l'ordi...
 
Moi je trouve 4 et lui 7...
 
J suis pas trop au point encore sur les cons et les append...
 
Sinon j vais test en décomposant par moi meme !!!
 
Merci en tous cas...

Sous Windows j'utilise Petite Chez Scheme, je l'aime bien (il est simple et efficace)
 

Aucune idée, regarde la doc de ton intrpréteur
 

(length (cons (+ 1 2) (append '(list 3 4) '(cons 5 6))))
; On commence par résoudre (append '(list 3 4) '(cons 5 6))
; Ca concatène la seconde liste à la première, *attention* ce sont deux listes ici puisqu'elles ont toutes deux le tick (')
; Donc ce ne sont pas des applications de fonction
; donc le résultat est '(list 3 4 cons 5 6)
(length (cons (+ 1 2) '(list 3 4 cons 5 6)))
; ici on exécute l'addition juste après le cons, c'est à dire (+ 1 2), qui est une addition parfaitement normale
(length (cons 3 '(list 3 4 cons 5 6)))
; cons ajoute un élément à l'avant d'une liste: (cons 1 '(2 3)) -> '(1 2 3)
; donc ici on ajoute simplement un "3" à l'avant de la liste donnée en 2e argument à cons
(length '(3 list 3 4 cons 5 6))
7

Et voilà.
 
Accessoirement, je ne vois pas trop comment tu peux trouver 4 même en te trompant et en croyant que '(list 3 4) et '(cons 5 6) sont des applications de fonction: (cons 5 6) ne génère pas une list mais une cons-cell '(5 . 6), donc on se retrouve avec

(cons 3 '(3 4 5 . 6))

qui donne  

'(3 3 4 5 . 6)

et si on applique length là dessus, ça plante:

(tu devrais t'informer sur le langage et ce que représente '(1 2 3 4 5) exactement si tu veux comprendre pourquoi ça plante)

Je suis bien d accord... Mais meme les profs la dessus nous donnent des explications bancales !!! Je pensais avec capté mais en fait non...
 
Par contre j'viens de capter que (cons 5 6) renvoiyait '(5 . 6) donc une liste a 3 élements en fait... Est ce exact ???
 
[edit]
Par contre je ne capte pas non plus l'utilisation de la fonction length...
 
Normalement length (cons 5 6) devrai renvoyer 3 mais la il me renvoie (5 . 6)...   capte pas...

OKI j ai capté la fonction length !!!
 
Pour le point s'il te trouve une erreur c est surement pk c est une facon pour la machine de te montrer que l emplacemnt est vide mais tu ne dois pas pouvoir utiliser la meme notation pour demander de laisser un vide a un emplacement précis d une liste...
 
C est la qu intervient la fonction "cons" je pense !!! Me trompe je ???
 
Par contre apres, la différence entre '( 5 6 ) et list( 5 6 ) je ne sais pas trop et mes cours n en disent pas plus !!!
 
 
ps : d aillerus je viens d essayer (list ( 5 6 ) ) et ca me renvoie une erreur... Je capte pas cette fonction. J vais voir sur le net !!!

oki j ai capté la fonction "list" !!!
 
J sais pas si ca t intéresse mais j le marque pour les gens qui sont en galere !!!
 
"list" génere une liste avec x element que tu rentres de la sorte :
 
(list 5 6 6 8 1 9) => (5 6 6 8 1 9)
 
Il n y aurai donc pas de différence entre "list" et " ' "... A voir...

Explications bancales sur quoi?

Non, '(5 . 6) c'est pas une liste, c'est ce qu'on appelle une "cons cell"
 

'(5 . 6) n'étant pas une liste, logiquement il devrait faire une erreur (et chez moi il fait effectivement une erreur)

Salut
 
Je te conseille de consulter de consulter ce lien, "Structure et Interpretation of Computer Programs", qui te fera comprendre ce qui se passe dans ta machine, en particulier le point 2.3.1 "Quotation"

 
 
Ok merci pour le lien... J'ai matter en diagonale tout ca !!! La je fais des tests pour essayé d assimiler le tout !!!
 
Est ce que qq un sait comment on configure DrScheme ???
 
Non pk la il me fait des blagues. A partir du moment ou je lui définit une fonction. Si elle est juste quekque soit la fonction que j'ai tapée il me renvoie la variable rentrée !!! Le con !!!  
 
Masklinn : est ce que tu aurais un lien pour dl Petite Chez Scheme stp ???
 
Merci

Google est ton ami

Pas trouver de lien sur google !!! Que des redirections vers vers des universités et il faut des codes d acces !!!

J'ose espérer que c'est une plaisanterie.

Beh j'y retourne !!!
 
[edit]
 
Ou est le pb ???    
 
http://www.google.fr/search?hl=fr& [...] heme&meta=
 
Sur l'action google n'eest pas mon amis. Je retrouve meme plus le lien de l'université dont j te parlais !!!    

   
 
http://www.google.fr/search?hl=fr& [...] cher&meta=
 
 

Le problème est que google n'étant pas un humanoïde francophone, il est inutile de faire des phrases    
 
De plus, les mots génériques comme télécharger et logiciel sont des keywords foireux à tous les coups  

Avec DrScheme, le debogueur te permet de voir toutes les étapes intermédiaires, d'après mes souvenirs.

Quelqu un pourrai m aider a config Dr Scheme svp...
 
Il marche tres bien quand j écris des fonctions du style :
 
(if (< 200 30)#t #f) et que je change les valeur directement.
 
Mais il ne fonctionne pas quand je fais des fonctions avec un define et une variable. Il me qui qu il n y a pas d erreur mais qq soit la fonction que j écris il me renvoie la variable...
 
Style :
 
(define (f1 x) (if (< x 0) #t #f))
 
si je rentre x=10 il me renvoie 10 (le con !!!)
 
- c est pour ca que j arrivais a rien !!! -
 
Help please !!!

C'est n'importe quoi, c'est pas comme ça qu'on définit une fonction en scheme

Je te suggère de lire le scheme tutorial et plus précisément la partie "Functions" qui indique par exemple...

(lambda (id...) exp )

((lambda (x) (* x x)) 3)

((lambda (x y) (+ x y)) 3 4)

(define square (lambda (x)  (* x x)))

Franchement, si tu refuses de lire la documentation tu vas avoir du mal à y arriver

Surtout que le Scheme Tutorial c'est le premier résultat quand tu fous "scheme define function" dans google

Masklinn : Je ne suis pas d'accord avec toi, les deux définitions  

sont équivalentes.
J'avais posé la question sur un forum dédié (plt-scheme@list.cs.brown.edu) car celà m'intriguait de voir les deux formes d'écritures (avec et sans la lambda), et c'est ce qui m'a été répondu.
Pour ce qui est du P.O., je ne sais pas comment il se débrouille, mais son code est correct.
D'autre part, moi j'ai simplement dowlader PLT-Scheme et je n'ai jamais eu de problèmes.

(define (f1 x) 
  (if ( <; x 0) #t #f)) 
 
(define f1
  (lambda (y)
         (if ( <; y 0)
             #t
             #f)))

Heuuu

Effectivement, oups

J'étais persuadé que la première ne passait pas

Si je dis qu'au moins avec la 2e on est tranquille parce qu'elle fonctionne partout, ça se voit que je me rattrape aux branches

mdr Masklinn !!!
 
Dites j'ai un pb sur la fonction let. Quelqu'un peut me donner la syntax svp ???
 
[edit]
 
ok c est gooooood j ai trouvé !!! Informaticien en herbe que je suis !!! boulé boulé boulé !!!
 
( let ( (def var 1) (def var 2) ... (def var n) )  ( operation))

J'avance j'avance...doucement...
 
Est ce que quelqu'un peut m expliquer pourquoi ma fonction ne fonctionne pas svp ???
 
dexcriptif : je veux faire une fonction qui calcule des puissances ou x est la puissance a appliqué sur un nombre y.
 
(define (puissX x y)
  (if (= x 0) 1
      (* y (puissX ((- x 1) y)) )
      )
  )
 
Thanks

Qu'est-ce que c'est encore que cette horreur

Chez moi ça fait un warning à la définition et une erreur à l'exécution, joli...

Franchement, t'as réfléchi à ce que tu faisais là? La programmation, c'est pas balancer des caractères au pif et espérer que ça va fonctionner tu sais...

Pour commencer, tu vas m'inverser les deux arguments de ta fonction, parce que l'ordre actuel est complètement illogique, puis j'aimerais que tu m'expliques comment tu arrives à un truc aussi terrifiant que

et ce que tu espères que ça fasse.

(et accessoirement, stylistiquement parlant en lisp on ne passe jamais à la ligne avant une fermeture de parenthèse, ça n'a aucun intérêt et ça rend juste le code plus difficile à lire)

Beh tout simplement (puissX ((- x 1) y)) ca relance la fonction avec comme parametre (x-1) et y la je ne vois pas le pb.
 
Arretes de me prendre pour un gogole stp. J suis la pour apprendre et pas pour me faire passé pour un con merce !!!
 
[edit]
 
Maintenant pour ton info j'viens de trouver l'erreur et j'ai corrigé mon prog... Le voici :
 
(define (puissX x y)
  (if (= x 0) 1
      (* y (puissX (- x 1) y))))
 
et il marche...
 
J'te remercie d'etre indulgent Masklinn ca me fait plaisir...  

C'est un appel récursif normalement, à priori rien ne me choque, mais si le compilo/interpréteur se plaint, c'est qu'il y a une raison.

C'est quoi l'algo utilisé pour calculer la puissance ? (mathématiquement)

EDIT : Ah, bah voilà ce qui était bizarre

Heu j ai pas trop capté la question...
 
Mon algo perso pour calculer la puissance serait
 
(define (puiss2 x) (* x x))
 
Et la j voulais compliqué la fonction pour choisir une puissance x a appliquer a une variable y.
 
C etait ca la question ???
 
Pour le bug a la compilation j ai trouvé l erreur c est qu en fait j avais trop de parentheses !!! On ne doit pas mettre de parenthese autour d une varaiable sur un appel récursif...
 
J'avoue erreure de base...  

Non, laisse tomber la question, elle est inutile
 
Pour les parenthèses, je ne les avaient pas repérées non plus. Ca fait 6 mois que j'ai pas fait de scheme pour ma défense
 
Par contre, il vaut mieux éviter d'être susceptible quand on poste sur des forums, même si on a un problème très énervant, et que les blagounettes des membres nous font pas trop rigoler  

Bravo, maintenant es tu capable de me dire pourquoi la première version était fausse?

Bien sure !!! j'l'ai mis au dessus !!!

Effectivement, excuse moi, je l'ai raté.

Question supplémentaire donc, puisque tu n'y as vu qu'une différence syntaxique ("trop de parenthèses) alors que la différence est réellement sémantique, que signifie l'expression

((- x 1) y)

pour un interpréteur scheme?

strictemnet rien... On est daccord...
 
Il soustraira 1 a la variable x et puis on lui donne aucuns calcule a faire !!!

Sisi, ça crée une erreur de runtime parce que l'exécution n'a pas de sens à cause des types impliqués, mais un interpréteur scheme va "voir" cette expression d'une manière très précise

La première partie de la phrase est vraie, pas compris la seconde

Maintenant que tu as trouvé une bonne écriture de la fonction puissance, il serait intéressant que tu compares avec cette version
(define (puissX3 x y z)
  (if (= x 0) z
      (puissX3 (- x 1) y (* y z))))
 
Appel avec (puissX3 5 2 1) par exemple.

 
Trap D : Heuuu j'ai pas tout capté l'utilisation du z...
 
 
 
J'me suis lancé dans les listes ce matin. et j'suis bloqué sur une fonction ou je dois vérifier si un arguments x appartient a la liste l
 
j'ai fait ca :
 
(define (Poss-x x l)
  (if (null? l) #f
      (if (= (car l) x) #t
          (Poss-x x (cdr l)))))
 
mais il me trouve une erreur :
 
je tape : (Poss-x 'a '(a b c d e))
 
. =: expects type <number> as 2nd argument, given: a; other arguments were: a
 
Pourtant j'ai fait une fonction au dessus qui me dis si la liste comprend un nombre ou pas. Et elle marche
 
(define (Poss-nbr l)
  (if (null? l) #f
      (if (number? (car l)) #t
          (Poss-nbr (cdr l)))))
 
La modification ne devrai pas etre catastrophique quand meme !!!
 
Merciii

Le prédicat (=) ne permet de comparer que des nombres
 
Accessoirement, sur ce genre de fonctions tu devrais utiliser (cond) et pas (if), je pense.
 
(et franchement tu devrais bosser sur le nommage de tes fonctions...)

Qu est ce que c est le "nommage de mes fonctions"  ??? Et qu est ce qu'il a ???
 
et si je ne peux pas utiliser "=" j'utilise quoi alors ???
 
Pour les cond moi j veux bien mais on a pas étudié ca en cour. J'ai pas non plus forcément envie de m embrouiller le cerveau 1 semaine avant le partiel !!!:S
 
[edit]
 
ok j'ai trouvé la soluce !!!
 
(define (Poss-x x l)
  (if (null? l) #f
      (if (equal? (car l) x) #t
          (Poss-x x (cdr l)))))
 
Merci Masklinn !!!

1. Les conventions de nommage scheme demandent habituellement à ce que les noms de fonctions (et de macros) soient en minuscule avec les "mots" séparés par des tirets "-": "member", "ceiling", "truncate", "call-with-input-file", "call-with-current-continuation", "imag-part". Pas de majuscules, donc
2. Les noms de fonctions doivent être clairs. "Poss-x" n'est pas clair (à quoi correspond x, d'abord?). "member" ou "elem" ou "in" ou "is-in" l'est
3. En scheme, un prédicat (une fonction qui prend une entrée quelconque et renvoie un booléen #t ou #f) est censé se terminer par "?" (afin d'indiquer clairement sa nature), donc ici tu pourrais nommer ta fonction "in?" ou "is-in?" ou "elem?" afin d'exprimer ce fait (tu peux voir ça comme le fait de poser une question e.g. (elem? 'a lst) correspondrait à la question "'a est il un élément de `lst`?"

Enfin, je ne peux que te conseiller de lire (jusqu'au chapitre 6 compris, le chapitre 7 étant sur la grammaire du langage) R5RS, également connu sous le nom de Revised^5 Report on the Algorithmic Language Scheme

Ce n'est pas grave si tu ne comprends pas absolument tout (au niveau des fonctions de la lib standard genre `call-with-current-continuation` par exemple), mais le document est relativement court, il est clair et il est bien écrit.

Cest un peu bizarre cette histoire du cond, c'est quand même plus général et plus lisible que le if.
 
Trace au debugger les deux fonctions pour voir la différence. Ta fonction reconstruit le calcul du factoriel alors que la mienne restitue directement le résultat lorsque x est nul, ce qui fait un important gain de temps en sortie de récursion.