Resolución guia 2 - Funcional
1. Hallar el factorial de un numero entero
(define factorial(lambda(n)
		   (if (= n 0)
		       1
		       (* n (factorial(- n 1)))
		       )
	   )
)

2. Encontrar el máximo elemento de la lista
(define max(lambda(L)
	     (if (null? (cdr L))
		 (car L)
		 (if(< (car L) (cadr L))
		    (max(cdr L))
		    (max(cons(car L) (cddr L)))
		    )
		 )
	     )
  )

3. Hallar la longitud de la lista
(define long(lambda(L)
	      (if (null? L)
		  0
		  (+ 1 (long(cdr L))))))

4. Sumar los elementos de una lista
(define suma(lambda(L)
	      (if (null? (cdr L))
		  (car L)
		  (+(car L)(suma(cdr L)))
		  )
	      )
  )

5. determinar si un elemento es miembro de una lista
(define miembro(lambda(n L)
	     (if (null? L)
		 #f
		 (if(= n (car L))
		    #t
		    (miembro n (cdr L))
		    )
		 )
	     )
  )

6. Concatenar dos listas
(define conca(lambda(L1 L2)
	      (if (null? L1)
		  L2
		  (cons (car L1)(conca (cdr L1) L2))
		  )
	      )
  )

7. Hallar el enésimo elemento de una lista
(define enesimo(lambda(n L)
	      (if (= n 1) 
		  (car L)
		  (enesimo (- n 1)(cdr L))
		  )
	      )
  )

8. determinar si una lista es sublista de otra
(define sublista(lambda(L1 L2)
	      (if (and (null? L1) (not(null? L2))) 
		  #f
		  (if (and (null? L1) (null? L2)) 
		  #t
		  (if (= (car L1) (car L2))
		      (sublista(cdr L1) (cdr L2))
		      (sublista (cdr L1) L2)
		  )
	      )
  )))

12. recorrer un arbol en preorden
(define preorden(lambda(arbol)
		  (if (null? arbol)
		      arbol
		      (append (cons (car arbol) (preorden(cadr arbol)))
			     (preorden(caddr arbol))))))

13. recorrer un arbol en inorden
(define inorden(lambda(arbol)
		  (if (null? arbol)
		      arbol
		      (append(inorden (cadr arbol))
		      (append (inorden(caddr arbol)) (cons (car arbol) '())))))
                    )

14. recorrer un arbol en posorden
(define posorden(lambda(arbol)
		  (if (null? arbol)
		      arbol
		      (append (posorden (cadr arbol))
			    (cons (car arbol) (posorden(caddr arbol)))))
                    ))

15. dadas dos listas determinar si la primera es prefijo de la otra
(define prefijo(lambda (l1 l2)
		 (if(null? l1)
		    #t
		    (if (null? l2)
			#f
			(and(iguales(car l1) (car l2))(prefijo (cdr l1) (cdr l2)))))))

(define iguales(lambda(x y)
		 (if (atom? x)
		     (if (atom? y)
			 (eqv? x y)
			 #f
			 )
		     (if (null? x)
			 (null? y)
			 (if (null? y)
			     (null? x)
			     (and (iguales (car x) (car y))(iguales (cdr x)(cdr y))))))))

16. dadas dos listas determinar si la primera es sufijo de la otra
(define sufijo(lambda (l1 l2)
		 (if(null? l1)
		    #t
		    (if (null? l2)
			#f
			(if(eqv? (longitud l1) (longitud l2))
			  (iguales l1 l2)
			  (sufijo l1 (cdr l2))
			 )
		    )
		 )
	)
)
  


23. dada una lista cuyos elementos pueden ser atomos o listas obtener una lista cuyos elementos sean todos atomos
(define atomos(lambda(l)
		(if (null? l)
		    l
		    (if (atom? (car l))
			(cons (car l) (atomos (cdr l)))
			(append (atomos(car l)) (atomos(cdr l)))
			)
		    )
		)
  )

29. definir una funcion que recibacomo argumento una funcion f y un entero n y aplique n veces la funcion f.
(define repetir(lambda (f n)
		 (if(= 1 n)
		    f
		    (f (repetir f (- n 1)))
		    )
		 )
  )



30. funcion que coloca al final de la lista los primeros n elementos de la lista original
(define moverAtras(lambda (l n)
		    (if (= 0 n)
			l
			(append (quitarN l n) (nPrimeros l n))
			)
		    )
  )

(define quitarN(lambda (l n)
		 (if (= 0 n)
		     l
		     (quitarN (cdr l) (- n 1))
		     )
		 )
  )
(define nPrimeros(lambda (l n)
		   (if (= 0 n)
		       '()
		       (cons (car l) (nPrimeros (cdr l) (- n 1)))
		       )
		   )
  )

36. Definir una funcion que sume las hojas de un arbol de la forma 
(valor hijo_izq hijo_der) 
(define sumahoja(lambda (l)
		  (if (and(null? (cadr l))(null? (caddr l)))
		      (car l)
		      (+ (car l)(+(sumahoja (cadr l))(sumahoja (caddr l))))
		      )
		  )
)

36. Definir una funcion que sume los nodos de un arbol
(define sumanodo(lambda (l)
		  (if (and(null? (cadr l))(null? (caddr l)))
		      1
		      (+ 1(+(sumanodo (cadr l))(sumanodo (caddr l))))
		      )
		  )
)
37. Determinar si un elemento pertenece a un arbol
(define pert_arb(lambda (e l)
		  (if (null? l)
		      #f
		      (if (eqv? e (car l))
			  #t
			  (or (pert_arb e (cadr l)) (pert_arb e (caddr l)))
			  )
		      )
		  )
  )

38. construir un sumador binario
(define sumadorbinario(lambda (n1 n2)
(invertir (sumar (completar (invertir n1) n2) (completar (invertir n2) n1) 0))
			)
  )

(define completar(lambda (l1 l2)
		   (if (null? l2)
		      l1
		      (if (null? l1)
		       (cons 0 (completar l1 (cdr l2)))
		       (cons (car l1) (completar (cdr l1) (cdr l2)))
		       )
		   )
  )
  )

(define invertir(lambda(l)
		 (if(null? l)
		    ()
		    (append (invertir(cdr l)) (cons (car l) '())) )
		  )
  )


(define sumar(lambda (l1 l2 d)
	       (if (null?  l1)
		   (if (= d 0)
		       '()
		       '(1))
		   (if (< (+ d (+ (car l1) (car l2))) 2)
		       (cons (+ d (+ (car l1) (car l2))) (sumar (cdr l1) (cdr l2) 0))
		       (if (= (+ d (+ (car l1) (car l2))) 2)
			   (cons 0 (sumar (cdr l1) (cdr l2) 1))
			   (cons 1 (sumar (cdr l1) (cdr l2) 1))
			   )
		       )
		   )
	       )
  )