Taller1 FLP

Ejercicios repaso Dr Racket
Fundamentos de Lenguajes Programación
Diciembre de 2020
Implemente en Dr Racket los siguientes procedimientos:
1. (2pts.)(list-set lista n x) que retorna una lista similar a lista, excepto que el n-simo elemento
(indexado desde cero) es x.
> (list-set ’(a b c d) 2 ’(1 2))

(a b (1 2) d)
> (list-set ’(a b c d) 3 ’(1 5 10))
(a b c (1 5 10))
2. (2pts.)(list-tails lista) que recibe como parámetro una lista y retorna una lista de todas las sublistas
de elementos consecutivos en lista.
> (list-tails ’(1 2 3 4 5))

((1 2 3 4 5) (2 3 4 5) (3 4 5) (4 5) (5))
> (list-tails ’(1 a (e 4) 5 v))
((1 a (e 4) 5 v) (a (e 4) 5 v) ((e 4) 5 v) (5 v) (v))
3. (4pts.)(exists? pred lst) recibe como parametros un predicado (number? symbol? bool? list?) y re-
torna #t si al menos un elemento de la lista satisface el predicado
> (exists? number? ?(a b c 3 e))

#t
> (exists? number? ?(a b c d e))
#f
4. (3pts.)(list-facts n) que recibe como parámetro un entero n y retorna una lista incremental de facto-
riales, comenzando en 1! hasta n!
> (list-facts 5)
(1 2 6 24 120)
5. (4pts.)(simpson-rule f a b n) que cálcula la integral de una función f entre los valores a y b mediante
la regla de Simpson. Dicha regla utiliza la siguiente aproximación:
h
· y0 + 4y1 + 2y2 + 4y3 + 2y4 + · · · + 2yn−2 + 4yn−1 + yn
3
(b−a)
donde h = n para algún entero par n y yk = f (a + kh).
1
> (simpson-rule (lambda (x) (* x (* x x))) 1 5 8)
156
> (simpson-rule (lambda (x) x) 1 5 12)
12
6. (4pts.)(inversions lista) que determina el número de inversiones de lista. Sea A = (a1 a2 . . . an ) una
lista de n números diferentes, si i < j y ai > aj entonces la pareja (i j) es una inversión de A.
> (inversions ’(2 3 8 6 1))

> 5
> (inversions ’(1 2 3 4))
> 0
> (inversions ’(3 2 1))
> 3
7. (4pts.)(up lista) que remueve un par de paréntesis de cada elemento del nivel más alto de lista. Si
un elemento de este nivel no es una lista (no tiene paréntesis), este elemento es incluido en el resultado
sin modificaciones.
> (up ’((1 2) (3 4)))

(1 2 3 4)
> (up ’((x (y)) z))
(x (y) z)
8. (4pts.)(merge lista1 lista2), donde lista1 y lista2 son listas de enteros ordenadas ascendentemen-
te. El procedimiento merge retorna una lista ordenada de todos los elementos en lista1 y lista2.
> (merge ’(1 4) ’(1 2 8))

(1 1 2 4 8)
> (merge ’(35 62 81 90 91) ’(3 83 85 90))
(3 35 62 81 83 85 90 90 91)
9. (4pts.)(zip f lista1 lista2) que retorna una lista donde la posición n-sima corresponde al resultado
de aplicar la función f sobre los elementos en la posición n-sima en lista1 y lista2. Puede asumir que
f es una función que recibe dos argumentos y que ambas listan tienen igual tamaño.
> (zip + ’(1 4) ’(6 2))

(7 6)
> (zip * ’(11 5 6) ’(10 9 8))
(110 45 48)
10. (2pts.)(max-list lista) que recibe una lista de números y devuelve el número mayor en dicha lista.
> (max-list ’(12 4 21 11 8))

21
> (max-list ’(19 12 34 8 14 45))
45
11. (4pts.)(foldl lista f acum) que recibe una lista lista, una función f y un valor inicial acum. La
función f es una función que recibe dos parámetros. Este procedimiento aplicará la función f a cada
elemento de la lista y a un valor acumulado inicialmente correspondiente al valor inicial acum.
> (foldl ’(12 4 21 11 8) + 0)

56
> (foldl ’(19 12 34 8 14 45) max 0)
45
2
12. (4pts.)(filter-acum a b f acum filter) que recibe dos números a y b, una función binaria f, un valor
inicial acum y una función unaria filter. Este procedimiento aplicará la función f a cada valor entre a y
b y a un valor acumulado que inicialmente corresponde al valor inicial acum.
> (filter-acum 1 10 + 0 odd?)

25
> (filter-acum 1 10 + 0 even?)
30
13. (4pts.)(sort lista f) que retorna la lista lista ordenada ascendentemente aplicando la función de
comparación f.
> (sort ’(8 2 5 2 3) <)

(2 2 3 5 8)
> (sort ’(8 2 5 2 3) >)
(8 5 3 3 2)
> (sort ’("a" "c" "bo" "za" "lu") string>)
("za" "lu" "c" "bo" "a")
14. (4pts.)(path num arbol) que toma un entero num y un árbol binario de búsqueda que contiene el entero
num y retorna una lista de lefts y rights indicando como encontrar el nodo que contiene el entero num
en el árbol. Si num es encontrado en la raı́z, el procedimiento retorna una lista vacia.
> (path 17 ’(14 (7 () (12 () ()))

(26 (20 (17 () ())
())
(31 () ()))))
(right left left)
15. (5pts.)(prod-scalar-matrix mat vec) que recibe una matriz mat representada como una lista de listas
y un vector vec representado como una lista y retorna el resultado de realizar la multiplicación matriz
por vector.
> (prod-scalar-matriz ’((1 1) (2 2)) ’(2 3))

’((2 3) (4 6))
> (prod-scalar-matriz ’((1 1) (2 2) (3 3)) ’(2 3))
’((2 3) (4 6) (6 9))
Nota: Puede asumir que los tamaños de la matriz y el vector son coherentes.
16. (4pts.)(get-elements-in-order arbol) que toma un árbol binario de búsqueda arbol y retorna una
lista con sus elementos ordenados ascendentemente.
> (get-elements-in-order ’(14 (7 () (12 () ()))

(26 (20 (17 () ())
())
(31 () ()))))
(7 12 14 17 20 26 31)
> (sort ’(8 2 5 2 3))

(2 2 3 5 8)
17. (5pts.)(common-subtree arbol1 arbol2) que recibe dos arboles n-arios y retorna el subarbol común
(estructuralmente). El subarbol común se compone de las ramas que existen en ambos árboles. En este
ejercicio el dato existente en cada nodo es irrelevante por lo que puede asumir que siempre será 0.
A continuación se muestra un ejemplo del subarbol común para dos árboles binarios:
3
18. (5pts.)(pascal N) que retorna la fila N del triangulo de Pascal.
A continuación se muestra las primeras cinco filas del triangulo de Pascal:
1 Primera fila
1 1 Segunda fila
1 2 1 Tercera fila
(0) 1 3 3 1 (0) Cuarta fila

+ + + + +
1 4 6 4 1 Quinta fila
Ayuda: Note que la fila N depende de la anterior, por ejemplo la quinta fila:
(1 4 6 4 1) =
(0 1 3 3 1) +
(1 3 3 1 0)
> (pascal 5)
(1 4 6 4 1)
> (pascal 1)
(1)
19. (6pts.)(remove-bin-stree arbol val) que toma un árbol binario de búsqueda arbol y retorna un
nuevo árbol binario de búsqueda donde se ha removido el elemento val.
> (remove-bin-stree ’(14 (7 () (12 () ()))

(26 (20 (17 () ())
())
(31 () ())))
20)
(14 (7 () (12 () ()))
(26 (17 () ())
(31 () ())))
> (remove-bin-stree ’(14 (7 () (12 () ()))
(26 (20 (17 () ())
())
(31 () ())))
26)
(14 (7 () (12 () ()))
(31 (20 (17 () ())
()))

Taller1 FLP

Cargado por

Copyright:

Formatos disponibles

Taller1 FLP

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Taller1 FLP

Cargado por

Copyright:

Formatos disponibles

Ejercicios repaso Dr Racket

Fundamentos de Lenguajes Programación

Implemente en Dr Racket los siguientes procedimientos:

> (list-set ’(a b c d) 2 ’(1 2))

> (list-tails ’(1 2 3 4 5))

> (exists? number? ?(a b c 3 e))

> (inversions ’(2 3 8 6 1))

> (up ’((1 2) (3 4)))

> (merge ’(1 4) ’(1 2 8))

> (zip + ’(1 4) ’(6 2))

> (max-list ’(12 4 21 11 8))

> (foldl ’(12 4 21 11 8) + 0)

> (filter-acum 1 10 + 0 odd?)

> (sort ’(8 2 5 2 3) <)

> (path 17 ’(14 (7 () (12 () ()))

> (prod-scalar-matriz ’((1 1) (2 2)) ’(2 3))

> (get-elements-in-order ’(14 (7 () (12 () ()))

> (sort ’(8 2 5 2 3))

(0) 1 3 3 1 (0) Cuarta fila

> (remove-bin-stree ’(14 (7 () (12 () ()))

También podría gustarte