Resolução 1
1.1

(define func
  (lambda (n)
    (cond ((<= n 1) n)
          ((even? n)
           (- (func (- n 1))
              (func (- n 2))))
          (else (+ (func (- n 1))
                   (func (- n 2)))))))

; versão iterativa
(define seq
  (lambda (m)
    (letrec ((aux
              (lambda (mm)
                (if (<= mm m)
                    (begin
                      (display (func mm))
                      (display " ")
                      (aux (add1 mm)))))))
      (if (negative? m)
          -1
          (aux 0)))))
; versão recursiva
(define seq2
  (lambda (m)
    (cond ((negative? m) -1)
          (else
           (begin
             (seq2 (sub1 m))
             (display " ")
             (display (func m)))))))

; Um campo de minas é representado por uma lista.
; Cada elemento desta lista representa uma mina.
; Por seu turno, cada mina é representada por uma lista, em que os dois primeiros elementos
; são as coordenadas x y da mina, o terceiro o alcance máximo, e o quarto a sua potencia máxima.
; 
(define minas
  (list (list 10 20 5 100)
        (list 5 15 3 40)
        (list 20 10 5 70)))
; Um tanque é representado por uma lista, em que os dois primeiros elementos
; são as coordenadas x, y do tanque, e o terceiro elemento tem a ver com os seus estragos.
; Este construtor devolve um tanque na posição x y, e com os estragos em zero.
;
(define faz-tanque 
  (lambda (x y)
    (list x y 0)))

; Move um tanque, adicionando dx, dy às suas coordenadas.
;
(define move-tanque!
  (lambda (tanque dx dy)
    (let ((t-x tanque)
          (t-y (cdr tanque)))
      (set-car! t-x (+ (car t-x) 
                       dx))
      (set-car! t-y (+ (car t-y)
                       dy)))))

(define visu-tanque
  (lambda (tanque)
    (display "posicao do tanque: ")
    (display (car tanque))
    (display ", ")
    (display (cadr tanque))
    (newline)
    (display "estragos: ")
    (display (caddr tanque))
    (newline)))

;
; Criação interactiva de um tanque. 
;
(define caracterizar-tanque
  (lambda ()
    (display "posicao do tanque (x, y): ")
    (let ((x (read))
          (y (read)))
      (faz-tanque x y))))

; Simulação de um percurso num tanque.
; A simulação é um ciclo sem fim, em que o programa:
;;       Pergunta qual o próximo deslocamento do tanque.
;;       Calculo eventual estrago sofrido pelo tanque.
;;       Visualiza a nova situação do tanque.
;
(define andar-num-tanque
  (lambda (campo-de-minas)
    ; cria tanque
    (let ((t1 (caracterizar-tanque)))
      (andar-num-tanque-aux t1 campo-de-minas))))
;
(define andar-num-tanque-aux
  (lambda (tan camp-minas)
    (let ((deslocamento (pergunta-deslo)))
      (move-tanque! tan 
                    (car deslocamento)
                    (cadr deslocamento))
      (let ((estragos (calcula-estragos tan camp-minas)))
        (atinge-tanque! tan estragos)
        (visu-tanque tan)
        (andar-num-tanque-aux tan camp-minas)))))

(define pergunta-deslo
  (lambda ()
    (newline)
    (display "deslocamento do tanque (em x e y): ")
    (let ((x (read))
          (y (read)))
      (list x y))))

(define calcula-estragos
  (lambda (t minas)
    (let ((t-x (car t))
          (t-y (cadr t)))
      (calcula-estragos-aux t-x
                            t-y
                            minas))))
;
(define calcula-estragos-aux
  (lambda (t-x t-y minas)
    (let ((calcula-estrago
           (lambda (tx ty mina)
             (let ((mx (car mina))
                   (my (cadr mina))
                   (alcance-max (caddr mina))
                   (potencia-max (cadddr mina)))
               (let ((dist-mina-tan (distancia mx my tx ty)))
                 (if (> dist-mina-tan alcance-max)
                     0
                     (- potencia-max
                        (* potencia-max
                           (/ dist-mina-tan alcance-max)))))))))
      (if (null? minas)
          0
          (+ (calcula-estrago t-x t-y (car minas))
             (calcula-estragos-aux t-x t-y (cdr minas)))))))
;
(define distancia 
  (lambda (x0 y0 x1 y1)
    (sqrt (+ (* (- x0 x1) (- x0 x1))
             (* (- y0 y1)(- y0 y1))))))