Universidad Mayor de San Andrés
Facultad de Ciencias Puras y Naturales
Carrera de Informática
Programación Funcional INF-319
Práctica 1
Estudiante:
Luis David Ajhuacho Tarquino
CI:
10955267 LP
RU:
1741084
Docente:
M.Sc. Aldo Ramiro Valdez Alvarado
GESTIÓN II/2023
Práctica 1 INF-319
1. Convierta las siguientes expresiones aritméticas en expresiones Scheme, utilice el
IDE de Scheme para evaluarlas.
a) 1.2 × (2 - 1/3) + -8.7
b) (2/3 + 4/9) ÷ (5/11 - 4/3)
c) 1 + 1 ÷ (2 + 1 ÷ (1 + 1/2))
d ) 1 × -2 × 3 × -4 × 5 × -6 × 7
2. Determinar los valores de las siguientes expresiones
a) (cons ’car ’cdr)
b) (list ’esto ’(es fácil))
c) (cons ’es ’(esto fácil?))
d ) (quote (+ 2 3))
e) (cons ’+ ’(2 3))
f ) (car ’(+ 2 3))
g) (cdr ’(+ 2 3))
h) cons
i ) (quote cons)
j ) (quote (quote cons))
k ) (car (quote (quote cons))
l ) (+ 2 3)
m) (+ ’2 ’3)
n) (+ (car ’(2 3)) (car (cdr ’(2 3)))
ñ) ((car (list + - * /)) 2 3)
3. (car (car ’((a b) (c d)))) da como resultado a. Determine qué composiciones de
car y cdr aplicadas a ((a b) (c d)) producen b, c y d.
4. Vuelva a escribir las siguientes expresiones, usando let para eliminar subexpre-
siones comunes y mejorar la estructura del código. No realice simplificaciones
algebraicas.
a) (+ (- (* 3 a) b) (+ (* 3 a) b))
b) (cons (car (list a b c)) (cdr (list a b c)))
1
Práctica 1 INF-319
5. Vuelva a escribir las siguientes expresiones para dar nombres únicos a cada va-
riable ligada a un let diferente.
a) (let ([x ’a] [y ’b])
(list (let ([x ’c]) (cons x y)) (let ([y ’d]) (cons x y))))
b) (let ([x ’((a b) c)]) (cons (let ([x (cdr x)])
(car x)) (let ([x (car x)]) (cons (let ([x (cdr x)])
(car x)) (cons (let ([x (car x)])
x) (cdr x))))))
6. Determina los valores de las siguientes expresiones (recuerde primero hacer la
prueba de escritorio en papel y luego probar con el IDE).
a) (let ([f (lambda (x) x)]) (f ’a))
b) (let ([f (lambda x x)]) (f ’a))
c) (let ([f (lambda (x . y) x)]) (f ’a))
d ) (let ([f (lambda (x . y) y)]) (f ’a))
7. Usar expresiones condicionales para resolver los siguientes ejercicios:
a) Desarrollar un algoritmo que retorne verdadero si el argumento es par, o
falso si el argumento es impar.
b) Desarrollar un algoritmo que muestre el mayor de tres números, si los tres
son iguales muestre el primero.
c) Definir un procedimiento que tome como argumentos dos listas y retorne la
lista más corta de ambas.
d ) Definir un procedimiento que compare dos listas y devuelva verdadero si las
dos listas tienen los mismos elementos y falso si son diferentes.
8. Usar recursividad para resolver los siguientes ejercicios:
a) Definir el procedimiento crea-lista, que toma un entero no negativo n y
un objeto, y devuelve una nueva lista de longitud n, donde cada elemento
de la lista es el objeto.
b) Definir el procedimiento elemento-lista que devuelve el n-ésimo elemento
de una lista ls.
c) Reescribir el algoritmo factor visto en clases, usando letrec para enlazar
f en lugar de let nombrado.
2
Práctica 1 INF-319
d ) Determinar si una lista de números es capicúa.
e) Determinar si una lista de letras es palindromo.
9. Usar asignaciones para resolver los siguientes ejercicios:
a) Modificar el procedimiento pila visto en clases, para mostrar el i-ésimo
elemento y eliminar el i-ésimo elemento de la pila.
1 ( define ( crear-pila )
2 ( list ) )
3
4 ( define ( push pila elemento )
5 ( cons elemento pila ) )
6
8 ( define ver-i
9 ( lambda ( pila i )
10 ( cond (( or ( null ? pila ) ( < i 1) ) # f )
11 ((= i 1) ( car pila ) )
12 ( else ( ver-i ( cdr pila ) (- i 1) ) ) ) ) )
13
14 ( define eliminar-i
15 ( lambda ( pila i )
16 ( cond (( or ( null ? pila ) ( < i 1) ) pila )
17 ((= i 1) ( cdr pila ) )
18 ( else ( cons ( car pila ) ( eliminar-i ( cdr
pila ) (- i 1) ) ) ) ) ) )
3
Práctica 1 INF-319
4
Práctica 1 INF-319
b) Desarrollar un procedimiento similar a pila, para definir una cola simple.
1 ( define cola-simple
2 ( lambda ()
3 ( let ([ ls '() ])
4 ( lambda ( msg . args )
5 ( cond
6 [( eqv ? msg ' empty ?) ( null ? ls ) ]
7 [( eqv ? msg ' enqueue !) ( set ! ls ( append ls
( list ( car args ) ) ) ) ]
8 [( eqv ? msg ' front ) ( car ls ) ]
9 [( eqv ? msg ' dequeue !) ( set ! ls ( cdr ls ) ) ]
10 [ else " error " ]) ) ) ) )
5
Práctica 1 INF-319
6
Práctica 1 INF-319
c) Modificar el procedimiento de la cola anterior, para mostrar el i-ésimo ele-
mento y eliminar el i-ésimo elemento de la cola.
1 ( define ( crear-cola )
2 ( cons '() '() ) )
3
4 ( define ( push cola elemento )
5 ( let (( front ( car cola ) )
6 ( rear ( cdr cola ) ) )
7 ( set-car ! cola ( cons elemento '() ) )
8 ( set-cdr ! cola ( if ( null ? front )
9 ( car cola )
10 rear ) )
11 ( if ( null ? front )
12 ( set-car ! rear ( car cola ) )
13 ( set-cdr ! front ( car cola ) ) ) )
14 cola )
15
16 ( define ( ver-i cola i )
17 ( let (( front ( car cola ) ) )
18 ( cond (( or ( null ? front ) ( < i 1) ) # f )
19 ((= i 1) ( car front ) )
20 ( else ( ver-i ( cons ( cdr front ) ( cdr
cola ) ) (- i 1) ) ) ) ) )
21
22 ( define ( eliminar-i cola i )
23 ( let (( front ( car cola ) ) )
24 ( cond (( or ( null ? front ) ( < i 1) ) cola )
25 ((= i 1) ( cons ( cdr front ) ( cdr cola ) ) )
26 ( else ( let (( rest ( eliminar-i ( cons ( cdr
front ) ( cdr cola ) ) (- i 1) ) ) )
27 ( set-car ! cola ( cons ( car front )
( car rest ) ) )
28 ( set-cdr ! cola ( cdr rest ) )
29 cola ) ) ) ) )
7
Práctica 1 INF-319
8
Práctica 1 INF-319
10. Escriba los pasos de expansión necesarios para expandir el siguiente algoritmo a
sus formas básicas: (let ([x (memv ’a ls)]) (and x (memv ’b x)))
Respuesta: Se puede expresar como:
1 (( lambda ( x )
2 ( if x
3 ( memv 'b x )
4 #f))
5 ( memv 'a ls ) )
Donde lambda es una forma sintáctica básica que crea una función anónima,
(memv ’a ls) es el valor asociado a la variable x y se utiliza la forma sintáctica
básica if para evaluar si x es verdadero. Si x es verdadero, entonces se evalua
(memv ’b x) y se devuelve el resultado. De lo contrario, se devuelve #f. En
resumen, la expresión let se convierte en una función anónima con un parámetro,
seguida por la aplicación de la misma con el valor asociado a la variable x. Los
valores asociados se pasan como argumentos a la función anónima creada por
lambda. Además, se utiliza la forma sintáctica básica if para evaluar si x es
verdadero y luego se devuelve el resultado correspondiente.
11. Escriba los pasos de expansión necesarios para expandir el siguiente algoritmo a
sus formas básicas: (or (memv x ’(a b c)) (list x))
Respuesta: El código (or (memv x ’(a b c)) (list x)) es una expresión que utiliza
formas sintácticas básicas de Scheme. La forma sintáctica básica or toma dos
expresiones como argumentos y devuelve t si al menos una de ellas es verdadera,
y #f en caso contrario. La forma sintáctica básica memy devuelve la sublista de
una lista que comienza con el primer elemento que es igual al objeto dado. La
forma sintáctica básica list crea una nueva lista que contiene los elementos dados.
En este código, no se utilizan extensiones sintácticas, por lo que no es necesario
extender ninguna sintaxis adicional en las formas básicas durante la compilación
o interpretación.
