Ejercicios Básicos y Secuencias

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <stdio.h>
#include <assert.h>

int calcular_pasos_regresiva(int n) {
    if (n <= 0) {
        return 0;
    }
    int pasos = 0;
    for (int i = n; i >= 1; --i) {
        pasos++;
    }
    return pasos;
}

long long suma_cuenta_regresiva(int n) {
    if (n <= 0) {
        return 0;
    }
    long long suma = 0;
    for (int i = n; i >= 1; --i) {
        suma += i;
    }
    return suma;
}

int main(void) {
    assert(calcular_pasos_regresiva(5) == 5);
    assert(calcular_pasos_regresiva(1) == 1);
    assert(calcular_pasos_regresiva(0) == 0);
    assert(calcular_pasos_regresiva(-4) == 0);

    assert(suma_cuenta_regresiva(5) == 15);
    assert(suma_cuenta_regresiva(1) == 1);
    assert(suma_cuenta_regresiva(0) == 0);
    assert(suma_cuenta_regresiva(-10) == 0);

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>
#include <assert.h>

int contar_pares_en_rango(int inicio, int fin) {
    if (inicio > fin) {
        int temp = inicio;
        inicio = fin;
        fin = temp;
    }
    int cuenta = 0;
    for (int i = inicio; i <= fin; ++i) {
        if (i % 2 == 0) {
            cuenta++;
        }
    }
    return cuenta;
}

int main(void) {
    assert(contar_pares_en_rango(1, 10) == 5);
    assert(contar_pares_en_rango(-4, 2) == 4);
    assert(contar_pares_en_rango(10, 1) == 5);
    assert(contar_pares_en_rango(3, 3) == 0);
    assert(contar_pares_en_rango(4, 4) == 1);

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <stdio.h>
#include <assert.h>

long long suma_primeros_n_impares(int n) {
    if (n <= 0) {
        return 0;
    }
    long long suma = 0;
    int impar_actual = 1;
    for (int i = 0; i < n; ++i) {
        suma += impar_actual;
        impar_actual += 2;
    }
    return suma;
}

int main(void) {
    assert(suma_primeros_n_impares(1) == 1);
    assert(suma_primeros_n_impares(4) == 16);
    assert(suma_primeros_n_impares(10) == 100);
    assert(suma_primeros_n_impares(0) == 0);
    assert(suma_primeros_n_impares(-5) == 0);

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#include <assert.h>

long long suma_secuencia_ascendente(int n, int m) {
    if (n >= m) {
        return 0LL;
    }
    long long suma = 0;
    for (int i = n; i < m; ++i) {
        suma += i;
    }
    return suma;
}

int main(void) {
    assert(suma_secuencia_ascendente(1, 5) == 10LL);
    assert(suma_secuencia_ascendente(-3, 2) == -5LL);
    assert(suma_secuencia_ascendente(7, 8) == 7LL);
    assert(suma_secuencia_ascendente(5, 5) == 0LL);
    assert(suma_secuencia_ascendente(10, 4) == 0LL);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include <assert.h>
#include <stddef.h>

void generar_tabla_multiplicar(int base, int *salida, size_t n)
{
    if (salida == NULL || n == 0)
    {
        return;
    }

    for (size_t i = 0; i < n; i++)
    {
        salida[i] = base * (int)(i + 1);
    }
}

int main(void)
{
    int tabla_7[5];
    generar_tabla_multiplicar(7, tabla_7, 5);
    assert(tabla_7[0] == 7);
    assert(tabla_7[1] == 14);
    assert(tabla_7[2] == 21);
    assert(tabla_7[3] == 28);
    assert(tabla_7[4] == 35);

    int tabla_neg[3];
    generar_tabla_multiplicar(-4, tabla_neg, 3);
    assert(tabla_neg[0] == -4);
    assert(tabla_neg[1] == -8);
    assert(tabla_neg[2] == -12);

    int tabla_cero[4];
    generar_tabla_multiplicar(0, tabla_cero, 4);
    assert(tabla_cero[0] == 0 && tabla_cero[1] == 0 && tabla_cero[2] == 0 && tabla_cero[3] == 0);

    generar_tabla_multiplicar(9, NULL, 0);

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
#include <assert.h>
#include <stddef.h>

size_t generar_secuencia_collatz(unsigned long long n, unsigned long long *salida, size_t cap_max)
{
    if (n == 0)
    {
        return 0;
    }

    if (salida == NULL)
    {
        size_t pasos = 1;
        unsigned long long actual = n;
        while (actual != 1)
        {
            if (actual % 2 == 0)
            {
                actual /= 2;
            }
            else
            {
                actual = actual * 3 + 1;
            }
            pasos++;
        }
        return pasos;
    }

    if (cap_max == 0)
    {
        return 0;
    }

    size_t escritos = 0;
    unsigned long long actual = n;
    salida[escritos++] = actual;

    while (actual != 1 && escritos < cap_max)
    {
        if (actual % 2 == 0)
        {
            actual /= 2;
        }
        else
        {
            actual = actual * 3 + 1;
        }
        salida[escritos++] = actual;
    }

    return escritos;
}

int main(void)
{
    /* Caso borde: n = 0 */
    assert(generar_secuencia_collatz(0, NULL, 0) == 0);

    /* Caso borde: n = 1 */
    unsigned long long buf_1[5];
    size_t len_1 = generar_secuencia_collatz(1, buf_1, 5);
    assert(len_1 == 1);
    assert(buf_1[0] == 1);

    /* Modo conteo sin buffer */
    assert(generar_secuencia_collatz(6, NULL, 0) == 9);

    /* Caso normal: n = 6 */
    unsigned long long buf_6[20];
    size_t len_6 = generar_secuencia_collatz(6, buf_6, 20);
    assert(len_6 == 9);
    assert(buf_6[0] == 6);
    assert(buf_6[1] == 3);
    assert(buf_6[2] == 10);
    assert(buf_6[3] == 5);
    assert(buf_6[4] == 16);
    assert(buf_6[5] == 8);
    assert(buf_6[6] == 4);
    assert(buf_6[7] == 2);
    assert(buf_6[8] == 1);

    /* Capacidad acotada */
    unsigned long long buf_trunc[4];
    size_t len_trunc = generar_secuencia_collatz(6, buf_trunc, 4);
    assert(len_trunc == 4);
    assert(buf_trunc[0] == 6 && buf_trunc[3] == 5);

    return 0;
}