// Recursión sobre arreglos y cadenas, sin ciclos y sin copiar nada.
#include <stdio.h>

// Cuántos negativos hay en los n elementos que empiezan en a.
static size_t count_negative(const int *a, size_t n) {
    if (n == 0) {
        return 0;
    }
    size_t rest = count_negative(a + 1, n - 1);
    if (a[0] < 0) {
        return rest + 1;
    }
    return rest;
}

// El menor de n elementos. Requiere n >= 1: un arreglo vacío no tiene mínimo.
static int array_min(const int *a, size_t n) {
    if (n == 1) {
        return a[0];
    }
    int rest = array_min(a + 1, n - 1);
    if (a[0] < rest) {
        return a[0];
    }
    return rest;
}

// ¿El arreglo se lee igual desde los dos extremos?
static int is_symmetric(const int *a, size_t n) {
    if (n <= 1) {
        return 1;
    }
    if (a[0] != a[n - 1]) {
        return 0;
    }
    return is_symmetric(a + 1, n - 2);
}

// Cuántos caracteres hay antes del '\0'.
static size_t string_length(const char *s) {
    if (s[0] == '\0') {
        return 0;
    }
    return 1 + string_length(s + 1);
}

int main(void) {
    int data[] = {4, -2, 7, -9, 1};
    int mirror[] = {3, 8, 8, 3};
    size_t data_n = sizeof data / sizeof data[0];
    size_t mirror_n = sizeof mirror / sizeof mirror[0];

    printf("negativos: %zu\n", count_negative(data, data_n));
    printf("mínimo: %d\n", array_min(data, data_n));
    printf("data simétrico: %d\n", is_symmetric(data, data_n));
    printf("mirror simétrico: %d\n", is_symmetric(mirror, mirror_n));
    printf("largo de \"Chosica\": %zu\n", string_length("Chosica"));
    printf("largo de \"\": %zu\n", string_length(""));
    return 0;
}