A1 · Ejercicios de programación funcional

Practica funciones como valores, colecciones sin bucles y secuencias perezosas. Cada ejercicio indica la salida esperada para que compruebes tu programa.

Ejercicio A1.1

Aplicar una función varias veces. Escribe aplicarNVeces(f, n, x), que aplica la función f al valor x, n veces seguidas (con n = 0 devuelve x sin cambios).

En main pruébala con estas llamadas, cada resultado en su línea:

• «doble» (multiplicar por 2) aplicada 3 veces a 1.
• «sumar 3» aplicada 4 veces a 0.
• «doble» aplicada 0 veces a 1.

Salida esperada:

8
12
1

En Kotlin

El tipo de una función de Int a Int es (Int) -> Int.

Solución modelo (bloqueada)

🔒 La solución completa está bloqueada. Esto es solo un ejemplo de cómo empieza:

fun aplicarNVeces(f: (Int) -> Int, n: Int, x: Int): Int {
    var resultado = x
    repeat(n) { resultado = f(resultado) }
    return resultado
}
// ... (resto de la solución bloqueado)

Ejercicio A1.2

Contador con paso. Escribe crearContador(inicio, paso), que devuelve una función. Cada vez que se llama a esa función devuelve el valor actual y después avanza paso unidades.

En main crea un contador que empieza en 10 y avanza de 5 en 5, y otro que empieza en 0 y avanza de 1 en 1. Llama tres veces al primero (en una sola línea, separando con espacios) y una vez al segundo. Comprueba que cada contador lleva su propia cuenta.

Salida esperada:

10 15 20
0

Solución modelo (bloqueada)

🔒 La solución completa está bloqueada. Esto es solo un ejemplo de cómo empieza:

fun crearContador(inicio: Int, paso: Int): () -> Int {
    var actual = inicio
    return {
        val valor = actual
        actual += paso
// ... (resto de la solución bloqueado)

Ejercicio A1.3

Palabras seleccionadas. Dada la lista sol, luna, estrella, mar, cielo, nube:

1. Quédate con las palabras de 4 letras o más.
2. Pásalas a mayúsculas.
3. Ordénalas alfabéticamente.
4. Muestra el resultado unido con guiones y, en otra línea, cuántas palabras quedaron.

Hazlo sin escribir un bucle: encadena operaciones de colección.

Salida esperada:

CIELO-ESTRELLA-LUNA-NUBE
4 palabras

Solución modelo (bloqueada)

🔒 La solución completa está bloqueada. Esto es solo un ejemplo de cómo empieza:

fun main() {
    val palabras = listOf("sol", "luna", "estrella", "mar", "cielo", "nube")
    val resultado = palabras
        .filter { it.length >= 4 }
        .map { it.uppercase() }
// ... (resto de la solución bloqueado)

Ejercicio A1.4

Contar por longitud. Con la misma lista del ejercicio anterior (sol, luna, estrella, mar, cielo, nube), cuenta cuántas palabras hay de cada longitud y muestra el resultado ordenado por longitud, con el formato longitud:cantidad separado por comas y espacios.

Salida esperada:

3:2, 4:2, 5:1, 8:1

Solución modelo (bloqueada)

🔒 La solución completa está bloqueada. Esto es solo un ejemplo de cómo empieza:

fun main() {
    val palabras = listOf("sol", "luna", "estrella", "mar", "cielo", "nube")
    val cuenta = palabras.groupingBy { it.length }.eachCount().toSortedMap()
    println(cuenta.entries.joinToString(", ") { "${it.key}:${it.value}" })
}
// ... (resto de la solución bloqueado)

Ejercicio A1.5

Una tubería de funciones. Escribe pipeline(funciones), que recibe una lista de funciones de entero a entero y devuelve una sola función que las aplica una tras otra, en orden.

En main: construye la tubería «multiplicar por 2», «sumar 1», «elevar al cuadrado» y aplícala a 5. Después comprueba qué ocurre con una tubería vacía aplicada a 7.

Salida esperada:

121
7

Solución modelo (bloqueada)

🔒 La solución completa está bloqueada. Esto es solo un ejemplo de cómo empieza:

fun pipeline(funciones: List<(Int) -> Int>): (Int) -> Int =
    { x -> funciones.fold(x) { acumulado, f -> f(acumulado) } }
fun main() {
    val tuberia = pipeline(listOf({ n -> n * 2 }, { n -> n + 1 }, { n -> n * n }))
    println(tuberia(5))
// ... (resto de la solución bloqueado)

Ejercicio A1.6

Secuencia perezosa. Obtén los cuatro primeros números naturales (empezando en 1) que sean múltiplos de 7 y mayores que 20, y muéstralos como una lista.

La secuencia de números naturales es infinita: usa una secuencia perezosa y pide solo los cuatro que necesitas.

Salida esperada:

[21, 28, 35, 42]

En Kotlin

generateSequence(1) { it + 1 } es infinita; take(4) corta a cuatro.

Solución modelo (bloqueada)

🔒 La solución completa está bloqueada. Esto es solo un ejemplo de cómo empieza:

fun main() {
    val multiplos = generateSequence(1) { it + 1 }
        .filter { it % 7 == 0 && it > 20 }
        .take(4)
        .toList()
// ... (resto de la solución bloqueado)