Enoncé d'exo d'informatique

voilà à quoi ressemble une programmation en langage scheme:


"EXERCICE 1 "
;;;moyenne de trois nombres
;;;nombre^3-> nombre
;;;moyenne des nombres x y z
(define (moyenne x y z)
(/ (+ x y z) 3))

"TEST"
(moyenne 3 4 5)

"EXERCICE 2"
;;;moyenne pondérée de trois nombres
;;;nombre^6 ->nombre
;;;rend la moyenne arithémtique pondérée des nombres x,y,z affectés des coefficients respectifs a,b,c
(define (moyennepondérée x a y b z c)
(/ (+ (* a x)
(* b y)
(* c z))
(+ a b c )
))

"TEST"
(moyennepondérée 1 4 2 6 4 2 )

"EXERCICE 3"
;;;max x y z
;;;rend le plus grand des trois nombres x y et z
;;;nombre^3->nombre
(define (max x y z)
(if (> x y)
(if (> x z)
x
y)
(if (> y z)
y
z)))
"Test"
(max 3 5 9)
(max 4.5 -6 3)

(sqrt 9)
(* 1 pi)

"EXERCICE 4"
;;;période-pendule
;;;nombre nombre
;;;rend la période d'un pendule de longueur L
;;;hypothèse: L>=0
(define (période-pendule L)
(* (sqrt (/ L 980 )) (* 2 pi)))

"TEST"
(période-pendule 90)


"EXERCICE 5"

"Q1"
;;;fah
;;;convertie les degrés Fahrenheit en degré Celsius
;;;nombre nombre
(define (fah t)
(* (/ 5 9) (- t 32)))

"test"
(fah 100)
(fah 71)
(fah -13)

"Q2"
;;;cel
;;;convertie les degrés celsius en degrés fahreinheit
;;;nombre->nombre
(define (cel t)
(+ (* t (/ 9 5)) 32))

"test"
(cel -25)
(cel (/ 340 9))
(cel (/ 65 3))

(modulo 10 5)
(modulo 9 3)
(modulo 20 6)

"EXERCICE 10"

"Q1 pair?"
;;;pair?
;;;nombre bool
;;;renvoie vrai si le nombre est pair
(define (pair? n)
(= 0 (modulo n 2)))

"test"
(pair? 3)
(pair? 4)

"Q2 divise?"
;;;divise?
;;;nombre*nombre->bool
;;;renvoie vrai si m divise n
(define (divise? m n)
(= 0 (modulo n m)))

"test"
(divise? 10 5)
(divise? 4
(divise? -3 6)
(divise? 10 10000)

"Q3"
(define (pair1? x)
(divise? 2 x))

(pair1? 5 )
(pair? 5 )
(pair1? 6)
(pair? 6)


amusez-vous bien

tu n'as plus de joker :evil: :twisted:

tu es le maillon faible tout court oui :ecrouled: :ecrouled: :ecrouled:

L'informatique? Pffft, fastoche!

(quote ((section MIME1)(groupe 2)
(date "Tue Oct 25 17:02:19 CEST 2005")(time "1130252539")
(id1 "2500781")(nom1 "Nedil")(prenom1 "Ouamar")
(mel1 "hs_alucard@hotmail.com")
(id2 "2305061")(nom2 "Sann")(prenom2 "Stephane")
(mel2 "wwwamnwww@yahoo.fr")))

;;;Ouamar Nedil et Stephane Sann

" exercice 26 "

" question 1 "

;;; liste-racines : nombre*nombre*nombre => Liste [ Nombres ]

;;; ( liste-racines a b c ) rend les racines de l'équation ax²+bx+c
sous forme
de liste

( define ( liste-racines a b c )
( let* (( delta ( - ( * b b ) ( * 4 a c ))))
( if ( < delta 0 )
( list )
( if ( = delta 0 )
( list ( / ( - b ) ( * 2 a )))
( list ( / ( - ( - b ) ( sqrt delta ) ) ( * 2 a )) ( list
( / ( + (
- b ) ( sqrt delta ) ) ) ))))))

( liste-racines 2 4 1 )

" question 2 "

;;; liste-racines : nombre*nombre*nombre => Liste [ Nombres ]

;;; ( liste-racines a b c ) rend les racines de l'équation ax²+bx+c
sous forme
de liste

( define ( liste-racines a b c )
( let* (( delta ( - ( * b b ) ( * 4 a c ))))
( cond

( ( < delta 0 ) ( list ) )
( ( = delta 0 ) ( list ( / ( - b ) ( * 2 a ))))
( ( > delta 0 ) ( list ( / ( - ( - b ) ( sqrt delta ) ) ( * 2
a )) ( li
st ( / ( + ( - b ) ( sqrt delta ) ) ) ))))))

( liste-racines 2 4 1 )

"exercice 21"

;;; pyramide : nombres*nombres*nombres*nombres*nombres => image
;;; ( pyramide n x y l h ) rend une pyramide à n étages à partir
d'un rectang
le de coordoonnées bas-gauche x ...y , de largeur l et de hauteur h

(define (filled-rectangle x y l h)
(overlay
(filled-triangle x y x ( + h y ) ( + x l ) y )
(filled-triangle x ( + h y ) (+ x l ) ( + y h ) ( + x l ) y ) ) )

( define ( pyramide n x y l h )
( if ( > n 0 )

( overlay filled-rectangle x y ( * l ( * 2 ( - n 1 ) ) ) h ) (
pyramide ( - n 1
) ( + x l ) ( + y h ) ( * 2 ( - n 1 ) l ) ( * 2 h ))))

( pyramide 3 0 0 0.1 0.1 )

Y a pas à chiquer, le scheme, ça pue :boltz:

terreàterre a écrit:

Y a pas à chiquer, le scheme, ça pue :boltz:

surtout quand il s'agit d'écrire un programme récursif :silent: :no

"Exercice20"
"Question1"

;;;quotient-et-reste : nat*nat/>0/->NUPLET[nat nat]
;;;(quotient-et-reste m n) : le reste et le quotient de la division euclidienne
de m par n

(define (quotient-et-reste m n)
(if (< m n)

(list 0 m)
(let ((v (quotient-et-reste (- m n) n)))
(cons (+ 1 (car v)) (cdr v)))))

(quotient-et-reste 3 5)
(quotient-et-reste 0 5)
(quotient-et-reste 10 5)
(quotient-et-reste 11 5)

"Question2"

;;;verif : nat*nat/>0/-> bool
;;;(verif m n) verifie si la fonction quotient-et-reste est vraie.

(define (verif m n)
(equal? (quotient-et-reste m n) (list(quotient m n)(remainder m n))))

(verif 3 5)
(verif 0 5)
(verif 10 5)
(verif 11 5)

"Exercice25"

(define (sierpinski n a b c d e f)
(if (= n 0)
(filled-triangle a b c d e f)
(overlay (overlay (sierpinski (- n 1) a b (/ (+ a c) 2) (/ (+ b d) 2) (/ (
+ a e) 2) (/ (+ b f) 2))
(sierpinski (- n 1) (/ (+ a c) 2) (/ (+ b d) 2) c d (/ (
+ e c) 2) (/ (+ f d) 2)))
(sierpinski (- n 1) (/ (+ a e) 2) (/ (+ f b) 2) e f (/ (+ c e) 2)
(/ (+ f d) 2)))))

(sierpinski 1 -1 -1 1 -0.5 0 1)
(sierpinski 4 -1 -1 1 -0.5 0 1)
"Exercice27"
"Question1"

;;;plus-de-3 : LISTE[ALPHA] -> bool
;;;(plus-de-3 L) rend vrai ssi la list L compte au moins trois elements

(define (plus-de-3 L)
(and (pair? L) (pair? (cdr L)) (pair? (cddr L))))

"Question2"

;;;longueur-egale3 : LISTE[ALPHA] -> bool
;;;(longueur-egale3 L) rend vrai ssi la list L compte strictement trois elements

(define (longueur-egale3 L)
(and (plus-de-3 L) (pair? (cdddr L))))

"Exercice31"
"Question1"

(define (est-dans? x L)
(if (pair? L)
(or (equal? x (car L)) (est-dans? x (cdr L)))
#f))

(est-dans? 3 (list 1 8 2 5 4))
(est-dans? 3 (list 1 8 2 3 4))

AAAAAAAAAAAAAAAATCHOU'M!

à mes souhaits :shaking: :shaking2:

Sierpinsky & rectangle diagonale


(define (filled-rectangle a b c d)
(overlay (filled-triangle a b c d a d) (filled-triangle a b c d c b)))

(define (A a b c d)
(overlay (filled-rectangle a b c d) (filled-triangle (- a) (- c) (- b) (- d) (- c) (- a))))



(define (B a b c d e f)
(overlay (filled-triangle a b c d e f) (filled-triangle (- a) (- b) (- c) (- d) (- e) (- f))))



(define (S n a b c d e f)
(if (= n 0)
(filled-triangle a b c d e f)
(overlay (S (- n 1) a b (/ (+ a e) 2) (/ (+ b f) 2) (/ (+ a c) 2) (/ (+ b d) 2))
(overlay (S (- n 1) e f (/ (+ c e) 2) (/ (+ d f) 2) (/ (+ a e) 2) (/ (+ b f) 2))
(S (- n 1) c d (/ (+ c e) 2) (/ (+ d f) 2) (/ (+ a c) 2) (/ (+ d b) 2))))))


(define (R n a b c d)
(if (= n 0)
(filled-rectangle a b c d)
(overlay (R (- n 1) a b (/ (+ a c) 2) (/ (+ d b) 2))
(R (- n 1) c d (/ (+ a c) 2) (/ (+ d b) 2)))))
(list (R 0 -1 -1 1 1) (R 1 -1 -1 1 1) (R 2 -1 -1 1 1)(R 3 -1 -1 1 1)(R 4 -1 -1 1 1)(R 5 -1 -1 1 1))

POLYNOME DU SECOND DEGRES





(define (S a b c)
(let ((delta (- (* b b) (* 4 a c))))
(cond
((< delta 0) "pas de solution réelle")
((= delta 0) (/ (- b) (* 2 a)))
(else (list (/ (- (- b) (sqrt delta)) (* 2 a))
(/ (+ (- b) (sqrt delta)) (* 2 a)))))))

(S 1 1 1)
(S -1 0 0)
(S -1 0 1)

Beurk, c'est nul: ça ne trouve que les polynomes réels de degré 2...

En plus, si tu définis a = 0 (degré 1), si c'est comme pour le fortran, ça risque de bugguer méchamment...

bon ça va

fait pas ton intéressant encore


on a fait un contrôle d'info en amphi

jte dis pas comment il était chaud

un truc à la acker man de merde là

M'étonne pas....


De toute façon, le scheme, ça pue. Java POWAAAA :ppunk:

tu connais acker man ?

Non, mais Ackerman oui

moué bref

c pareil pour moi




et tu trouves ça dur ?

Non

ah oui c vrai


toi c ce qu'il y a en dehors de la terre dans laquelle tu plonges la tête qui est dure muhahaaha :twisted: