;;;;;;;;;;;;;;;;;;;;;;;;;;;;; PRACTICA-2.TXT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Opeadores booleanos, expresiones condicionales y procedimientos simples
  

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.


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

|----------------------------------------------------------------------------|
|----------------------------------------------------------------------------|
| 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. 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.                                 |
|----------------------------------------------------------------------------|
|----------------------------------------------------------------------------|

Eval\'ua, razonando la respuesta, las siguientes expresiones,
suponiendo que a, b y c tienen como valor #t, mientras que  d y e
tienen como valor #f. Utiliza el int\'erprete para comprobar tus
resultados. 

(or a (and b e))                                   ;;;[1a]
(not (and b c (or a e)))                           ;;;[1b]
(not (or (not a) (not b)))                         ;;;[1c]  
(and (or (symbol? e) (not (symbol? a))) (not e))   ;;;[1d]


**************************************************************************
* EJERCICIO 2                                                            *
**************************************************************************

Intenta predecir el valor de las siguientes expresiones
condicionales y utiliza luego el int\'erprete para comprobar la
validez de  cada predicci\'on.   

(define x '(2 3))			             ;;;[2a]
   
(if (null? x) 0 (car x))		             ;;;[2b]

(+ 3 (if (null? x) 0 (car x)))		             ;;;[3c]

(define x ())				             ;;;[2d]

(+ 3 (if (null? x) 0 (car x)))		             ;;;[2e]


(if (null? (car '())) 'vacio 'no-vacio)              ;;;[2f]

(if (null? (cdr '(2  3))) 'vacio 'no-vacio)          ;;;[2g]

(cond                                                ;;;[2h]
      ((symbol? (cadr '(a (b)))) 'simbolo)	
      ((number? (caar '((a) 5))) 'numero)
      ((pair? (cddr '(a (b)))) 'par)
      (else 'nada-de-lo-anterior))

(+ (if (null? #f) (+ 4 8) (* (+ 3 2) 2))             ;;;[2i]
	(cond
	 ((equal? 0 (caadr '(2 ((0))))) 9)
	 (else 12)))


**************************************************************************
* EJERCICIO 3                                                            *
**************************************************************************

Eval\'ua las siguientes expresiones e intenta comprender
los resultados obtenidos.

((lambda (x) (+ x (* x x) 1))  3)                              ;;;[3a]

((lambda (x y) (if (number? x) x y)) 'a 'b)                    ;;;[3b]

((lambda (l1 l2) (list (car l1) (car l2))) '(1 2 3) '(a b))    ;;;[3c]


**************************************************************************
* EJERCICIO 4                                                            *
**************************************************************************

Evalua la siguiente expresi\'on en el int\'erprete de Scheme:

(define borra-el-segundo			   ;;;[4a]
  (lambda (l)
    (cons (car l) (cddr l))))


Intenta entender qu\'e ocurre   cuando el procedimiento definido
recibe una lista  de menos de 2 elementos. Eval\'ua las expresiones:

(borra-el-segundo '())                             ;;;[4b]
(borra-el-segundo '(2))                            ;;;[4c]
(borra-el-segundo '(a b))                          ;;;[4d]
(borra-el-segundo '(1 3 4 2))                      ;;;[4e]
 

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

Define un procedimiento pega2 que tome como argumentos dos listas de dos
elementos y devuelva las lista resultante de unir ambas. Por ejemplo,

(pega2 '(a b) '(c d))  ==>  (a b c d)




|----------------------------------------------------------------------------|
|----------------------------------------------------------------------------|
| NOTA: Recordamos nuevamente 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 6                                                         *
***********************************************************************

Escribe un procedimiento llamado borra-el-segundo-bis que tome una
lista L como argumento y devuelva como valor la lista resultante de
eliminar en L el segundo elemento, si L tiene 2 o m\'as elementos y ()
en caso contario. Ejemplos de c\'omo debe comportarse
borra-el-segundo-bis son


(borra-el-segundo-bis '(a b c))  ==>  (a c)
(borra-el-segundo-bis '(1 2))    ==>  (1)
(borra-el-segundo-bis '(a))      ==>  ()
(borra-el-segundo-bis '())       ==>  ()


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

Define un procedimiento ciclo3 de manera que dada una lista L (que 
suponemos  tiene 3 o m\'as elementos) devuelva como valor la lista
obtenida al permutar c\'iclicamente los 3 primeros elementos de L, es
decir, el primero pasa a ser el segundo, el segundo pasa a ser el
tercero y el tercero el primero. Por ejemplo:

(ciclo3 '(a b c f))  ==>  (c a b f)
(ciclo3 '(1 2 3 4 5))  ==> (3 1 2 4 5)