Petando la pila. Problemas y retos usando recursividad.

[HackmanC]

Hola,

Al parecer ya van mas adelantados, aún así me uno con las dos propuestas iniciales, seguramente no están optimizadas, son solamente otro punto de vista de los problemas.

Esta ya estaba resuelta anteriormente casi de igual forma, el concepto creo que es el mismo en todos los casos,

Problema #1:

Código C:

#include <stdio.h>
 
/* más codigo si hace falta */
 
int contar(const int ds[], const int bx) {
    return (bx < 0 ? 0 : (ds[bx] < 0) + contar(ds, bx - 1));
}
 
int contarNegativos(int arr[], int n) {
    /* Escribir código */
    return contar(arr, n - 1);
}
   
int main (void) {
    int arr[] = {1, 4, -3, 2, -1, -8, 0, 1};
    int n = sizeof arr / sizeof *arr;
 
    /* calcular cantidad de negativos */
    int cantidad = contarNegativos(arr, n);
    /* mostrar cantidad de negativos */
    printf("%d\n", cantidad);
    return 0;
}
 

Para esta use un concepto un poco diferente, los programadores que tiene tiempo en esto seguramente van a observar un patrón bastante antiguo basado en los segmentos de la memoria, antiguamente no existía la memoria flat como ahora, así que había que trabajar con segmentos y offsets. Es solamente otro punto de vista el problema.

El único cambio a la plantilla original es en el tamaño reservado, que para contener el resultado realmente debía ser mas grande.

Problema #2:

Código C:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
/* más codigo si hace falta */
 
#define SEG(ds, ws) (ds * (ws + 1))
 
char* diacpy(char* dst, const char* src, const int ws, const int ds, const int bx) {
    if (bx >= ws) {
        dst[SEG(ds, ws)] = '\0';
    } else {
        memset(&dst[SEG(ds, ws)], 0x20, ws);
        memcpy(&dst[SEG(ds, ws) + bx], &src[bx], 1);
        dst[SEG(ds, ws) + ws] = 0x0a;
        diacpy(dst, src, ws, ds + 1, bx + 1);
    }
    return dst;
}
 
char* diag(char* cadena, char* resultado) {
    /* Escribir código */
    return diacpy(resultado, cadena, strlen(cadena), 0, 0);
}
 
int main (void) {
    char cadena [] = "abcde";
    int n = strlen(cadena);
 
    char* resultado = malloc((n + 1) * n + 1); /* doy mas espacio del necesario */
 
    // a partir de la cadena de caracteres retornar la nueva que tenga los caracteres en diagonal
    resultado = diag(cadena, resultado);
 
    //mostrar resultado
    puts(resultado);
 
    free(resultado);
    return 0;
}
 

En sí, no hay nada optimizado ni especializado y posiblemente tenga algún error. Con un poco mas de tiempo voy a pensar en alguna propuesta para los siguientes problemas.

Saludos,