Resolução do Exame de Recurso, 10/2/2001
Resolução 1
1.1
ponto-piramide(lin, col)= 0, se col>lin 1, se col=1 1, se col=lin ponto-piramide(lin-1, col-1) + ponto-piramide(lin-1, col), para os outros casos1.2
(define ponto-piramide
(lambda (lin col)
(cond ((> col lin) 0)
((= col 1) 1)
((= col lin) 1)
(else (+ (ponto-piramide (sub1 lin)(sub1 col))
(ponto-piramide (sub1 lin) col))))))
1.3
(define linha-piramide
(lambda (lin)
(letrec ((aux
(lambda (c)
(if (= c lin)
(list 1)
(cons (ponto-piramide lin c)
(aux (add1 c)))))))
(aux 1))))
Resolução 2; Exercício 2 - Manipulação de polinómios representados por listas de coeficientes (define coeficiente-polinomio (lambda (pol i) (if (> i (length pol)) 0 (list-ref pol i))))2.1
(define multiplica-polinomio (lambda (pol x) (map (lambda (coef) (* x coef)) pol)))2.2
(define avalia-polinomio (lambda (pol x) (if (null? pol) 0 (+ (car pol) (* x (avalia-polinomio (cdr pol) x))))))2.3
(define cria-polinomio
(lambda lista-coefs
(lambda (x)
(avalia-polinomio lista-coefs x))))
; testes (define p1 '(1 6 0 2)) (display p1) (coeficiente-polinomio p1 1) (define p2 (multiplica-polinomio p1 2)) (display p2) (avalia-polinomio p1 1) (define p3 (cria-polinomio 1 6 0 2)) (p3 1)Resolução 3
; A abstracção jogo-da-vida
;
; O construtor
;
(define faz-jogo-vida
(lambda (dim n)
(let ((jogo-vida (make-vector dim))) ; vector das linhas
(letrec ((constroi! ; vector das colunas para cada linha
(lambda (conta)
(if (< conta dim) ; preenche com "-"
(begin
(vector-set! jogo-vida conta (make-vector dim "-"))
(constroi! (add1 conta))))))
(aux!
(lambda (num-simb)
(if (zero? num-simb)
jogo-vida
(let ((lin (random dim))
(col (random dim)))
(cond ((equal? (sel-jogo-vida jogo-vida lin col) ; já existe "+"
"+")
(aux! num-simb))
(else
(mod-jogo-vida! jogo-vida lin col "+") ; altera para "+"
(aux! (sub1 num-simb))))))))) ; próximo símbolo
(constroi! 0)
(aux! n)))))
;
; Os selectores
;
(define sel-jogo-vida
(lambda (jogo i j)
(vector-ref
(vector-ref jogo i)
j)))
(define dim-jogo-vida
(lambda (jogo)
(vector-length jogo)))
;
; O modificador
;
(define mod-jogo-vida!
(lambda (jogo i j simb)
(vector-set! (vector-ref jogo i)
j
simb)))
;
; O visualizador
;
(define visu-jogo-vida
(lambda (jogo)
(let ((dim (vector-length jogo)))
(letrec ((visu
(lambda (lin col)
(cond ((>= lin dim)
(newline))
((= col dim)
(newline)
(visu (add1 lin) 0))
(else
(display (sel-jogo-vida jogo lin col))
(display " ")
(visu lin (add1 col)))))))
(visu 0 0)))))
3.2
; o modificador que, a partir de um jogo determina a proxima posição...
;
(define proximo!
(lambda (jogo-vida)
(let ((dim (dim-jogo-vida jogo-vida)))
(let ((presente (faz-jogo-vida dim 0)))
(letrec
;
((copia!
(lambda (lin col)
(cond ((>= lin dim)
'copiado)
((>= col dim)
(copia! (add1 lin) 0))
(else
(mod-jogo-vida! presente
lin
col
(sel-jogo-vida jogo-vida lin col))
(copia! lin (add1 col))))))
;
(actualiza!
(lambda (lin col)
(cond ((>= lin dim)
'actualizado)
((>= col dim)
(actualiza! (add1 lin) 0))
;
((and (equal? "-" (sel-jogo-vida presente lin col))
(= 3 (num-vizinhos presente lin col)))
(mod-jogo-vida! jogo-vida lin col "+")
(actualiza! lin (add1 col)))
((and (equal? "+" (sel-jogo-vida presente lin col))
(not (= 3 (num-vizinhos presente lin col))))
(mod-jogo-vida! jogo-vida lin col "-")
(actualiza! lin (add1 col)))
(else
(mod-jogo-vida! jogo-vida lin col
(sel-jogo-vida presente lin col))
(actualiza! lin (add1 col)))))))
(copia! 0 0) ; faz uma copia de jogo-vida em jogo-presente
(actualiza! 0 0)))))) ; actualiza jogo-vida a partir de jogo-presente
;
(define num-vizinhos
(lambda (jogo lin col)
(let ((dim (vector-length jogo))
(lin0 (sub1 lin))
(col0 (sub1 col))
(alt 2)
(larg 2)
(n-viz 0))
(if (equal? "+" (sel-jogo-vida jogo lin col)) ; descontar o "+" origem
(set! n-viz -1))
(if (= lin 0)
(begin
(set! lin0 0)
(set! alt 1)))
(if (= col 0)
(begin
(set! col0 0)
(set! larg 1)))
(if (= lin (sub1 dim))
(set! alt (sub1 alt)))
(if (= col (sub1 dim))
(set! larg (sub1 larg)))
(letrec ((aux
(lambda (inc-li inc-co)
(cond ((> inc-co larg)
(aux (add1 inc-li) 0))
((> inc-li alt)
0)
((equal? "+" (sel-jogo-vida jogo
(+ lin0 inc-li)
(+ col0 inc-co)))
(add1 (aux inc-li (add1 inc-co))))
(else
(aux inc-li (add1 inc-co)))))))
(+ n-viz (aux 0 0))))))