;;;;;;;;;;;;;;;;;;;;;;;;;;;;; PRACTICA-3.TXT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Recursi\'on simple. Traza.
  

Para facilitar el trabajo divide la pantalla en dos ventanas mediante 
CTRL-X 2 y, en una de ellas,  crea un buffer para trabajar con el
int\'erprete, mediante ESC-X run-scheme ENTER. Utiliza CTRL-X O para
saltar de una a otra ventana, mientras haces los ejercicios.


|----------------------------------------------------------------------------|
|----------------------------------------------------------------------------|
| NOTA: Recuerda que no es necesario teclear en el int\'erprete              |
| expresiones que ya aparezcan en este fichero. Para ello primero debes      |
| pasar a modo scheme, tecleando (con el cursor en este buffer)              |
| ESC-X scheme-mode ENTER. Luego, cada vez que quieras evaluar una expresi\'on |
| que ya est\'a escrita en este fichero, no tendr\'as que teclearla de nuevo |
| en el buffer del int\'erprete. Bastar\'a que coloques el cursor al         | 
| principio de la expresi\'on y teclees CTRL-C CTRL-E.                       |
| Observar\'as que en la ventana de scheme aparece el valor de la            |
| expresi\'on.                                                               |
|----------------------------------------------------------------------------|
|----------------------------------------------------------------------------|
|----------------------------------------------------------------------------|
|----------------------------------------------------------------------------|
| NOTA: Recuerda tambi\'en que no es necesario escribir las expresiones      |
| pedidas  en el int\'erprete. Puedes escribirlas en este buffer debajo      |
| de cada apartado y evaluar lo que escribes con CTRL-C CTRL-E, viendo la    |
| respuesta en el buffer de Scheme. As\'i, podr\'as corregir fallos          |
| f\'acilmente y adem\'as al final de la clase, si grabas este fichero,      |
| tendr\'as los ejercicios resueltos, sin necesidad de anotar en papel       |
| las soluciones. Al usar CTRL-C CTRL-E recuerda que la expresi\'on que      |
| deseas evaluar debe comenzar con par\'entesis y el primero de ellos debe   |
| ocupar la PRIMERA COLUMNA DE LA IZQUIERDA.                                 |
|----------------------------------------------------------------------------|
|----------------------------------------------------------------------------|



**************************************************************************
* EJERCICIO 1                                                            *
**************************************************************************

(1) Define la funci\'on suma-primeros que al recibir como entrada un 
n\'umero  natural, n, devuelve la suma de los n primeros números naturales.
Prueba a calcular varios valores.


(2) Vamos ahora a "inspeccionar" las distintas llamadas a funciones que se 
producen al calcular la suma para un determinado n\'umero. Para ello, haz
(trace suma-primeros)                                      
y calcula varios valores de la funci\'on. Sigue las explicaciones
del profesor para entender lo que aparece en pantalla.

(3) Haz la "traza" con un poco m\'as de detalle: teclea
(trace +)
y calcula nuevamente varios valores de la funci\'on.

Nota: Al finalizar este ejercicio "deshaz" la traza. Para ello, teclea
(untrace suma-primeros)
(untrace +)
    


*****************************************************************************
* EJERCICIO 2:                                                              *
*****************************************************************************

(1) Definir una funci\'on cuad-list que reciba una lista de n\'umeros
como argumento y devuelva la lista de los cuadrados de los elementos de
la lista de entrada. Por ejemplo:

(cuad-list '(1 2 3 4)) ==> (1 4 9 16)
(cuad-list '(5 3)) ==> (25 9)
(cuad-list '()) ==> () 

(2) El siguiente procedimiento, llamado misterio1, recibe como entrada una
lista de listas y est\'a definido de la siguiente manera:

(define misterio1                                ;;;[2a]
  (lambda (l)
    (cond
     ((null? l) ())
     ((null? (car l)) (misterio1 (cdr l)))
     (else (cons (caar l) (misterio1 (cdr l)))))))

Describe el comportamiento general de misterio1.




*****************************************************************************
* EJERCICIO 3:                                                              *
*****************************************************************************

(1) Definir una funci\'on lista-simb que reciba una lista como argumento y 
devuelva la lista de los s\'imbolos de la lista de entrada. Por ejemplo:

(lista-simb '(1 iacs hse ccia 2)) ==> (iacs hse ccia)
(lista-simb '(sevilla 2 betis 1)) ==> (sevilla betis)
(lista-simb '(1 2 3)) ==> ()

(2) El siguiente procedimiento, llamado misterio2, recibe como entrada una 
lista y est\'a definido de la siguiente manera:

(define misterio2
  (lambda (l)
    (cond
     ((or (null? l) (null? (cdr l))) ())
     (else (cons (car l) (misterio2 (cdr l)))))))

Describe el comportamiento general de misterio2.


*****************************************************************************
* EJERCICIO 4:                                                              *
*****************************************************************************

(1) Define una funci\'on sum-cuad que reciba como argumento una lista de 
n\'umeros y devuelva la suma de los cuadrados de los elementos de la lista.
Por ejemplo:

(sum-cuad '(1 2 3)) ==> 14
(sum-cuad '(3 0 3)) ==> 18
(sum-cuad '()) ==> 0


(2) El siguiente procedimiento, llamado misterio3, recibe como entrada una
lista de n\'umeros naturales y est\'a definido de la siguiente manera: 

(define misterio3
  (lambda (l)
    (m3bis 0 l)))

donde m3bis se define de la siguiente manera:

(define m3bis
  (lambda (s l)
    (cond
     ((null? l) ())
     ((even? (car l)) (cons (+ s (car l)) (m3bis (+ s (car l)) (cdr l))))
     (else (cons (car l) (m3bis s (cdr l)))))))
	
	
Describe el comportamiento general de misterio3.



***********************************************************************
* EJERCICIO 5                                                         *
***********************************************************************

Definir un procedimiento expdos que reciba como entrada un n\'umero 
mayor que cero y devuelva el exponente de la mayor potencia de dos que
divide al n\'umero (es decir, el exponente del dos en la descomposici\'on
en factores primos del n\'umero). Por ejemplo:

(expdos 24) ==> 3  
(expdos 120) ==> 3 
(expdos 1) ==> 0
(expdos 16) ==> 4
 
NOTA: puedes usar el procedimiento ya definido remainder que recibe como 
entrada dos n\'umeros y devuelve el resto de dividir el primero por el
segundo.



*****************************************************************************
* EJERCICIO 6                                                              *
*****************************************************************************

Define un procedimiento sparimp que reciba como entrada una lista num\'erica 
y devuelva como salida una lista de dos numeros: el primero, la suma de los
pares de la lista de entrada y el segundo la suma de los impares de la 
lista de entrada. Por ejemplo:

(sparimp '(1 2 3 4 5 6)) ==> (12 9)
(sparimp '(2 4 6)) ==> (12 0)
(sparimp '()) ==> (0 0)




***********************************************************************
* EJERCICIO 7                                                         *
***********************************************************************

Define un procedimiento segundolis que recibiendo como entrada una 
lista de listas devuelva la lista de los elementos que en cada  
sublista est\'an en segunda posici\'on (ignorando aquellas sublistas  
que tienen menos de dos elementos). Por ejemplo:

(segundolis '((1 2 3) (4 5 6) (7 8 9))) ==> (2 5 8)
(segundolis '((agua) (2 3 sol) (aire mar 1 2) ())) ==> (3 mar)
(segundolis '((a) (b) (c))) ==> ()
(segundolis '()) ==> ()