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 C#

El tipo de una función de int a int es Func<int, int> (un delegado): se ejecuta con f(x).

Solución modelo (bloqueada)

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

int AplicarNVeces(Func<int, int> f, int n, int x)
{
    for (int i = 0; i < n; i++)
    {
        x = f(x);
// ... (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

En C#

Una lambda de C# captura la variable, no su valor, y puede modificarla: basta con una variable local que la lambda cambie.

Solución modelo (bloqueada)

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

Func<int> CrearContador(int inicio, int paso)
{
    int actual = inicio;
    return () =>
    {
// ... (resto de la solución bloqueado)

Ejercicio A1.3¶

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

Quédate con las palabras de 4 letras o más.
Pásalas a mayúsculas.
Ordénalas alfabéticamente.
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:

string[] palabras = ["sol", "luna", "estrella", "mar", "cielo", "nube"];
var resultado = palabras
    .Where(p => p.Length >= 4)
    .Select(p => p.ToUpper())
    .OrderBy(p => p, StringComparer.Ordinal)
// ... (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

En C#

GroupBy agrupa; cada grupo tiene su Key y se puede contar con Count().

Solución modelo (bloqueada)

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

string[] palabras = ["sol", "luna", "estrella", "mar", "cielo", "nube"];
var porLongitud = palabras
    .GroupBy(p => p.Length)
    .OrderBy(g => g.Key)
    .Select(g => $"{g.Key}:{g.Count()}");
// ... (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:

Func<int, int> Pipeline(List<Func<int, int>> funciones)
{
    return x => funciones.Aggregate(x, (acumulado, f) => f(acumulado));
}
var tuberia = Pipeline([n => n * 2, n => n + 1, n => n * n]);
// ... (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 C#

Enumerable.Range(1, int.MaxValue) es una secuencia perezosa (casi infinita); Take(4) corta a cuatro. También sirve un método con yield return.

Solución modelo (bloqueada)

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

var multiplos = Enumerable.Range(1, int.MaxValue)
    .Where(n => n > 20 && n % 7 == 0)
    .Take(4);
Console.WriteLine($"[{string.Join(", ", multiplos)}]");
// ... (resto de la solución bloqueado)