(longitud '(a b c d)) -> 4

(longitud '(a b c d))
(+ 1 (longitud '(b c d)))
(+ 1 (+ 1 (longitud '(c d))))
(+ 1 (+ 1 (+ 1 (longitud '(d)))))
(+ 1 (+ 1 (+ 1 (+ 1 (longitud '())))))
(+ 1 (+ 1 (+ 1 (+ 1 0))))
(+ 1 (+ 1 (+ 1 1)))
(+ 1 (+ 1 2))
(+ 1 3)
4

(define (fib n)
(cond ((= n 0) 0)
        ((= n 1) 1)
        (else (+ (fib (- n 1))
                 (fib (- n 2))))))

(define (factorial-iter n)
   (fact-iter-aux n n))

(define (fact-iter-aux product n)
    (if (= n 1)
        product
        (fact-iter-aux (* product (- n 1))  (- n 1))))

(factorial-iter 4)
(factorial-iter-aux 4 4)
(factorial-iter-aux 12 3)
(factorial-iter-aux 24 2)
(factorial-iter-aux 24 1)
24

(define (longitud-iter lista)
   (longitud-iter-aux lista 0))

(define (longitud-iter-aux lista result)
   (if (null? lista)
      result
      (longitud-iter-aux (cdr lista) (+ result 1))))

(longitud 'abcdef)
(longitud-iter 'abcdef 0)
(longitud-iter 'bcdef 1)
(longitud-iter 'cdef 2)
(longitud-iter 'def 3)
(longitud-iter 'ef 4)
(longitud-iter 'f 5)
(longitud-iter "" 6)
6

(define (fib n)
  (cond ((= n 0) 0)
        ((= n 1) 1)
        (else (+ (fib (- n 1))
                 (fib (- n 2))))))

(define (fib-iter a b count)
  (if (= count 0)
      b
      (fib-iter (+ a b) a (- count 1))))

(define (fib n)
  (fib-iter 1 0 n))

              1
            1   1
          1   2   1
        1   3   3   1
      1   4   6   4   1
    1   5  10  10  5   1
  1   6  15  20  15  6   1
1   7  21  35  35  21  7   1
             ...

Pascal(fila, 0) = 1 para cualquier valor de fila
Pascal(fila, columna) = 1 si fila = columna
Pascal(fila, columna) = Pascal(fila-1,columna-1) + Pascal(fila-1, columna) en otro caso

(define (pascal row col)
  (cond ((= col 0) 1)
        ((= col row) 1)
        (else (+ (pascal (- row 1) (- col 1))
                 (pascal (- row 1) col) ))))

(pascal-sig-fila '(1 3 3 1)) -> (1 4 6 4 1)

(define (pascal-sig-fila fila)
    (append '(1)
                (pascal-sig-fila-central fila)
                '(1)))

(define (pascal-sig-fila-central fila)
   (if (= 1 (length fila))
      '()
       (append (list (+ (car fila) (car (cdr fila))))
                   (pascal-sig-fila-central (cdr fila)))))

(define (pascal-iter fila col)
   (if (= 0 col)
      1
      (list-ref (pascal-iter-aux '(1 1) fila) col)))

(define (pascal-iter-aux fila n)
    (if (= n (- (length fila) 1))
        fila
        (pascal-iter-aux (pascal-sig-fila fila) n)))

(pascal 28 10) -> 13123110
(pascal-iter 28 10) -> 13123110

• Expresiones-s
• Árboles binarios
• Árboles genéricos

• Un dato atómico es una expresión-s
• Si e₁ y e₂ son expresiones-s, la expresión (e₁ . e₂) también es una expresión-s

(A . B)
(A . (B . C))
((A . B) . (C . D))
(A. ((A . B) . (C . D)))

(A . B . C)
(A)
(() . B)

(= 4 (+ 2 2))
(if (= x y) (* x y) (+ (/ x y) 45))
(define (factorial x) (if (= x 0) 1 (* x (factorial (- x 1)))))

(define (factorial x) (if (= x 0) 1 (* x (factorial (- x 1)))))
(define lista (quote (1 (2 (3)))))

(1 (2 (3))) 

• Una expresión-s es una lista cuyos elementos pueden ser datos atómicos o expresiones-s
• Una expresión-s vacía es una lista vacía

• La función car devolverá un dato atómico u otra expresión-s
• La función cdr devolverá la expresión-s resultante de eliminar el primer elemento de la lista. Nunca devolverá un dato atómico.

• Otro ejemplo (ejercicio en clase):

• (let ((x 12)
        (y 5))
     (+ x y)))
  
  

• list y quote: construcción
• cons: añadir elemento a la cabeza
• car: devuelve el primer dato (puede ser una hoja o una expresión-S)
• cdr: devuelve el resto (siempre una expresión-S)
• null?: comprueba si es lista vacía

(define (hoja? x)
   (not (pair? x)))

• (cuenta-hojas-exp exp): cuenta las hojas
• (niveles-exp exp): cuenta los niveles
• (pertenece-exp x exp): busca una hoja
• (cuadrado-exp exp): eleva todas las hojas al cuadrado
• (map-exp f exp): similar a map

(define (cuenta-hojas-exp exp)
    (cond
      ((null? lista) 0)
      ((hoja? (car exp)) (+ 1 (cuenta-hojas-exp (cdr exp))))
      (else
           (+ (cuenta-hojas-exp (car exp))
              (cuenta-hojas-exp (cdr exp))))))

(define (niveles-exp exp)
   (cond 
      ((null? exp) 0)
      ((hoja? exp) 0)
      (else (max (+ 1 (niveles-exp (car exp)))
                 (niveles-exp (cdr exp))))))

(define (pertenece-exp? x exp)
         (cond 
             ((null? exp) #f)
             ((hoja? exp) (equal? x exp))
             (else (or (pertenece-exp? x (car exp))
                       (pertenece-exp? x (cdr exp))))))

(define (cuadrado-exp exp)
  (cond ((null? exp) '())
        ((hoja? exp) (cuadrado exp))
        (else (cons (cuadrado-exp (car exp))
                    (cuadrado-exp (cdr exp)) )) ))

(define (map-exp f exp)
  (cond ((null? exp) '())
        ((hoja? exp) (f exp))
        (else (cons (map-exp f (car exp))
                    (map-exp f (cdr exp)) )) ))

• (make-bt dato izq-bt der-bt): crea un árbol binario con un dato, un árbol binario izquierdo y un árbol binario derecho
• vacio-bt: constante que define el árbol binario vacío
• (dato-bt bt): devuelve el dato de un árbol binario
• (izq-bt bt): devuelve el árbol binario izquierdo
• (der-bt bt): devuelve el árbol binario derecho
• (hoja-bt? bt): comprueba si el árbol es una hoja (no tiene hijos)
• (vacio-bt? bt): comprueba si el árbol es vacío

    *
   / \
  +   8
 / \
5   3

(define t1 (make-bt 5 vacio-bt vacio-bt))
(define t2 (make-bt 3 vacio-bt vacio-bt))
(define t3 (make-bt '+ t1 t2))
(define t4 (make-bt 8 vacio-bt vacio-bt))
(define t5 (make-bt '* t3 t4))
(dato-bt t5) -> *
(dato-bt (izq-bt t5)) -> +
(dato-bt (izq-bt (izq-bt t5))) -> 5

(10 (5 (3 () ()) ()) (23 (12 () ()) (28 () ())))

(define (make-bt dato izq der)
    (list dato izq der))
(define vacio-bt '())

(define (vacio-bt? btree) (null? btree))
(define (dato-bt btree) (car btree))
(define (izq-bt btree) (car (cdr btree)))
(define (der-bt btree) (car (cdr (cdr btree))))

(define (hoja-bt? btree)
   (and (vacio-bt? (izq-bt btree))
        (vacio-bt? (der-bt btree))))

• (to-list-bt bt): devuelve una lista formada por los elementos del bt
• (member-bt? x bt): busca el elemento x en un árbol binario ordenado
• (insert-bt x bt): "inserta" (realmente, no modifica el árbol que se pasa como parámetro, sino que crea otro) un dato en un árbol binario ordenado
• (insert-list-bt lista bt): "inserta" una lista en un árbol binario ordenado
• (list-to-bt list): construye un árbol binario ordenado a partir de una lista

(define (to-list-bt btree)
   (if (vacio-bt? btree)
      '()
      (append (to-list-bt (izq-bt btree)) 
              (list (dato-bt btree))
              (to-list-bt (der-bt btree)))))

• Si el dato de la raíz del árbol es menor que x, hacemos una llamada recursiva para comprobar si el dato está el subárbol derecho
• Si el dato es mayor que x, buscamos x en el subárbol izquierdo
• Si el dato de la raiz es igual que x devolvemos #t.

(define (member-bt? x bt)
   (cond 
      ((vacio-bt? bt) #f)
      ((= x (dato-bt bt)) #t)
      ((< x (dato-bt bt))
         (member-bt? x (izq-bt bt)))
      (else
         (member-bt? x (der-bt bt)))))

(define (insert-bt x bt)
   (cond
      ((vacio-bt? bt) (make-bt x vacio-bt vacio-bt))
      ((< x (dato-bt bt))
         (make-bt (dato-bt bt) 
                    (insert-bt x (izq-bt bt)) 
                    (der-bt bt)))
      ((> x (dato-bt bt))
         (make-bt (dato-bt bt)
                    (izq-bt bt)
                    (insert-bt x (der-bt bt))))
      (else bt)))

(define (insert-list-bt lista bt)
   (if (null? lista)
      bt
      (insert-list-bt (cdr lista) 
          (insert-bt (car lista) bt))))

(define (list-to-bt lista)
   (insert-list-bt lista vacio-bt))

• Un árbol genérico está formado por un dato y una lista de árboles hijos (también árboles)

• (make-tree dato lista-hijos): construye un árbol a partir de un dato y una lista de hijos formada por árboles. La lista puede ser vacía.
• (dato-tree tree): devuelve el dato de la raíz del árbol
• (hijos-tree tree): devuelve una lista de árboles hijos

(define (make-tree dato lista-hijos)  (cons dato lista-hijos))
(define (dato-tree tree)  (car tree))
(define (hijos-tree tree)  (cdr tree))

(define t1 (make-tree 5 '()))
(define t2 (make-tree 2 '()))
(define t3 (make-tree 3 '()))
(define t4 (make-tree 10 '()))
(define t5 (make-tree 12 '()))
(define t6 (make-tree '* (list t2 t3)))
(define t7 (make-tree '- (list t5)))
(define t8 (make-tree '+ (list t1 t6 t4)))
(define tree (make-tree '* (list t8 t7)))

(+ (5) (* (2) (3)) (10))

(define tree '(+ (5) (* (2) (3)) (10)))

• (tree-to-list tree): devuelve una lista con los datos del árbol original
• (square-tree tree): eleva al cuadrado todos los datos de un árbol manteniendo la estructura del árbol original
• (map-tree f tree): devuelve un árbol con la estructura del árbol original aplicando la función f a sud datos.

(define (to-list-tree tree)
   (cons (dato-tree tree)
         (to-list-bosque (hijos-tree tree)))))

(define (to-list-bosque bosque)
   (if (null? bosque)
       '()
       (append (to-list-tree (car bosque))
               (to-list-bosque (cdr bosque)))))

(define (cuadrado-tree tree)
   (make-tree (cuadrado (dato-tree tree))
                   (cuadrado-bosque (hijos-tree tree))))

(define (cuadrado-bosque bosque)
   (if (null? bosque)
       '()
       (cons (cuadrado-tree (car bosque))
               (cuadrado-bosque (cdr bosque)))))

(define (cuadrado-tree tree)
   (make-tree (cuadrado (dato-tree tree))
              (map cuadrado-tree (hijos-tree tree))))

(define (map-tree f tree)
   (make-tree (f (dato-tree tree))
              (map-bosque f (hijos-tree tree))))

(define (map-bosque f bosque)
   (if (null? bosque)
       '()
       (cons (map-tree f (car bosque))
             (map-forest f (cdr bosque)))))