Saltar a contenido

Ejercicios · PFC · Colecciones: secuencias y conjuntos

Once ejercicios para recorrer en el navegador, en el orden en que se presentan los temas. Ninguno muestra nada antes de que usted produzca algo: hay trazas que avanzan paso a paso, valores que hay que predecir antes de verlos y opciones entre las que hay que escoger, y cada opción equivocada dice en qué consiste la confusión. Todo lo que se afirma salió de correr el código con Scala 2.13.11, la versión del curso.

Dos ideas los atraviesan. Una, que la colección se escoge por cómo se va a acceder a los datos, y que map, filter, exists y forall se escriben igual sobre todas. Otra, que una expresión for con yield no es un ciclo: es flatMap, map y filter escritos de otro modo, y el compilador hace esa traducción.

De listas a colecciones

jerarquia

Arranca con tres expresiones sobre List para reactivar map, filter y length, y de ahí pasa a las preguntas que una lista no responde bien: llegar al elemento mil, agregar al final, guardar datos sin orden. Para cada necesidad hay que escoger la colección, y al final se separa lo que todas comparten de lo que es propio de una.

Secuencias: Vector, Range, Array y String

vector

Los dos agregados son lo que se confunde: +: pone al inicio y :+ al final, y los dos puntos siempre apuntan hacia la colección. La segunda parte comprueba que head, tail, isEmpty, map y filter se escriben igual que en una lista, con una pregunta que pide las dos expresiones que devuelven Vector(3, 4).

rangos

to incluye el extremo y until no, by fija el paso y admite paso negativo. Tres resultados que sorprenden al correrlos: un rango no se imprime con sus elementos sino como Range 1 to 5, (6 to 1 by -2) sale como inexact Range 6 to 1 by -2, y (5 to 1).toList da la lista vacía porque sin by el paso sube. Cierra con Array y String reusando las mismas operaciones, y con que filtrar un texto devuelve un texto.

Operaciones sobre secuencias

consultas

Trece preguntas sobre las operaciones que no devuelven otra secuencia: exists y forall dan booleanos, zip y unzip arman y desarman parejas, y sum, product, max y min dejan un número. Dos casos cuestan: zip recorta a la más corta de las dos, y sobre una colección vacía forall da true mientras exists da false.

flatMap

flatmap

Primero el problema: con map el resultado queda anidado, tres vectores de dos parejas cada uno. Antes de ver el de flatMap hay que predecir cuántas parejas trae, y la traza paso a paso muestra cada x produciendo su trozo y los trozos concatenándose hasta las seis. Termina con el producto escalar, que compone zip, map y sum en una línea.

Expresiones For

forExpr

Cuatro expresiones for que hay que emparejar con la cadena de funciones de alto orden que les corresponde. Hay cinco cadenas para las cuatro expresiones, y una de ellas usa map donde hace falta flatMap: no le corresponde a ninguna, y descubrir por qué es el ejercicio. Las dos escrituras de las parejas primas devuelven el mismo vector.

traducir

Lo mismo por el otro lado: en lugar de reconocer la equivalencia, derivarla. Se llega a la cadena por reescrituras, de un generador a dos con filtro, y en cada paso hay que decir qué función entra. Dos resultados medidos sostienen el ejercicio: con filter en lugar de withFilter el valor es el mismo, y lo que cambia es que withFilter no construye la colección intermedia; y poner map donde va flatMap deja cinco vectores anidados en lugar de las siete parejas. Cierra con el for sin yield, que devuelve () de tipo Unit y es el ciclo imperativo que aquí no se usa.

ordenGeneradores

Con dos generadores, el de la derecha es el que varía más rápido, y la traza lo muestra pareja por pareja. Invertirlos da los mismos seis pares en otra secuencia, de modo que las dos versiones son iguales con toSet y distintas con ==, que es donde cuesta no responder que da lo mismo. Después el generador que depende del anterior: recorre un triángulo y da seis pares donde el independiente da nueve, e invertirlo no compila. El mensaje del compilador está copiado de la corrida.

Conjuntos

conjuntos

Sin orden y sin duplicados, con union, intersect, diff, subsetOf y el atajo de aplicar el conjunto como si fuera una función. Que los duplicados se colapsen tiene consecuencia medible: seis divisiones dejan cuatro elementos. La pregunta más dura es la del texto impreso, porque el mismo conjunto sale unas veces como Set y otras como HashSet, con los elementos en otro orden, y de ahí se sigue que ni el nombre ni el orden son parte de lo que un conjunto promete.

Ternas pitagóricas

ternas

Tres generadores anidados con la condición de que los lados vayan en orden, el filtro del teorema y un toSet al final. Primero se predice cuántas ternas candidatas se van a probar con cinco, y la traza las muestra descartándose una por una hasta que sobrevive (3,4,5): es búsqueda exhaustiva y se ve. Después queda la versión con flatMap y filter, que da el mismo conjunto, y las seis ternas que aparecen hasta veinte. Con veinte la traza son más de tres mil pasos, así que conviene el botón de ir al final.

Test de primalidad

esPrimo

Las dos escrituras, negar que exista un divisor y pedir que ninguno divida, coinciden en todos los valores probados, y esa equivalencia es la mitad del ejercicio. La otra mitad es el rango sin elementos: para n = 2 el rango 2 until 2 está vacío, así que forall da true y exists da false, y de ahí sale por qué la guarda n >= 2 tiene que estar. La traza cuenta los divisores que se prueban y deja ver dónde se detiene la búsqueda cuando encuentra uno.