Mensajes

Diría que te lo piden en C pero si no es así especifica si te lo están pidiendo en C/C++.
Si quieres recibir ayuda para futuras consultas te recomiendo que pongas el código que tengas hecho o cómo lo estés intentando. Si no lo pones pensaremos que quieres que te hagan la tarea y te contestará menos gente. Aparte sabiendo lo que estás intentando podremos ayudarte mejor.

Imagino que si estás empezando los datos se los pides al usuario por pantalla. Eso es muy simple, puedes verlo en cualquier sitio...
Usando <printf()> y <scanf()> en C o usando <cout> y <cin> en C++.

Luego por ejemplo crea una función que le pases como parámetros dos <float>/<double>, uno para el capital actual y otro para el interés. Y que te devuelva el interés aplicado a ese capital o el total (capital + interés), eso ya como tú quieras.
Después solo tendrás que meter esa función en un bucle <for> para tener el resultado.

Intenta hacer lo que te he comentado y si no lo logras pon lo que hayas hecho para ver dónde tienes los problemas.
(El código que pongas entre etiquetas de Código GeSHi, por favor)

Suerte

Varias cosas... Primero sobre los nombres. Al usar cadenas literales no estás reservando memoria en cada <struct> para guardar los nombres. Lo que estás haciendo es que los punteros del <struct> apunten a la dirección de memoria en la que se encuentran esas cadenas almacenadas desde antes de la ejecución del programa.
Entonces a la hora de crear la nueva lista con el filtro, no puedes copiar los nombres usando <strcpy()> puesto que tampoco estás reservando memoria para estos. Lo único que puedes hacer es hacer que los punteros a <char> de las nuevas <struct> apunten a las mismas cadenas literales.

Ahora sobre el <realloc()>. Si no reservas memoria con <malloc()> (cosa que no deberías hacer) lo único que tienes es un puntero a <t_alumno>. Entonces para "insertar" un nuevo <t_alumno> tendrás que hacer el <realloc()> antes, no después.

Para saber cuántos <t_alumno> hay en el filtro yo usaría otro parámetro por referencia para contabilizarlos y así no tener que poner el último <leg> a 0.

Código (c) [Seleccionar] Expandir


t_alumno* filtrar(t_alumno *arr, char cod_car, size_t *num_filtrados){
t_alumno *filtro = NULL; // tenemos un array vacio
*num_filtrados = 0;

for(size_t i = 0; i < SIZE; ++i){
if(arr[i].cod_car == cod_car){ // si son iguales...
(*num_filtrados)++; // ...tenemos un elemento mas en el filtro...
filtro = (t_alumno*) realloc(filtro, *num_filtrados * sizeof(t_alumno)); // ...y reservamos memoria para introducirlo
filtro[*num_filtrados-1].leg = arr[i].leg;
filtro[*num_filtrados-1].nombre = arr[i].nombre; // hacemos que apunte al mismo sitio que arr[i].nombre, no copiamos la cadena porque no hay memoria
filtro[*num_filtrados-1].cod_car = arr[i].cod_car;
}
}
printf("\nTERMINO EL FILTRADO\n");
return filtro;
}

La traza de un algoritmo (o programa) indica la secuencia de acciones (instrucciones) de su ejecución, así como, el valor de las variables del algoritmo (o programa) después de cada acción (instrucción).

Siguiendo esta definición de traza, como no hay variables sólo habría que indicar las instrucciones que se ejecutan. Yo en la traza mostraría la instrucción completa, no solo la salida por pantalla.

Código [Seleccionar] Expandir


printf(6)
fun(5)
printf(5)
...
printf(1)
fun(0)
printf("fin")
printf(0)
printf("fin de verdad")

No sé lo que quieres representar exactamente con "la traza", pero si lo que quieres es mostrar en que orden se van haciendo las sucesivas llamadas y cuales son las salidas que se obtienen, en tal caso, es correcto.
En el fondo es como la salida en sí misma, añadiendo las sucesivas llamadas a la función.

Te dejo un par de funciones para calcularlo sin iteraciones, es decir, sin bucles. Seguro que también se puede hacer con bucles de una forma más sencilla que la que tienes implementada, por si te apetece intentarlo.

Código (cpp) [Seleccionar] Expandir


// Calcula la cifra i-esima empezando a contar por la derecha
unsigned cifraIesimaBack(unsigned numero, unsigned cifra){
unsigned cifra_iesima = (numero % int(pow(10, cifra))) / pow(10, cifra-1);
return cifra_iesima;
}

// Calcula la cifra i-esima empezando a contar por la izquierda
unsigned cifraIesimaFront(unsigned numero, unsigned cifra){
unsigned cifra_iesima = numero / int(pow(10, numeroDigitos(numero)-cifra)) % 10;
return cifra_iesima;
}

// Calcula el numero de digitos que tiene un numero
unsigned numeroDigitos(unsigned numero){
unsigned digitos = (numero != 0); // esto considera que el 0 tiene 0 digitos. Para considerar que tiene 1 digito, inicializar en 1
while(numero > 9){
numero /= 10;
digitos++;
}
return digitos;
}

Para hacer ese ejercicio con lo que ya tienes solo necesitas esto:

Código (cpp) [Seleccionar] Expandir


while(numero > 0){
   ultima_cifra = numero % 10;
   numero /= numero;
}
Eso de ahí va sacando la última cifra de un número. Ahora adapta eso a lo que necesitas tú.
Suerte

Los ficheros en C son <FILE*>.
Busca información sobre trabajar con ficheros en C para orientarte más.

Supongamos que tienes un fichero "datos.txt" cuyo contenido es:

Código [Seleccionar] Expandir


ESTADO HABITACIONES
ST1 Libre
ST2 Ocupada
ST3 Libre
Que indica la clave de cada habitación y si está Libre/Ocupada. Y queremos buscar el estado de una habitación en concreto.

Código (c) [Seleccionar] Expandir


#define MAX_SIZE 100 // longitud para guardar una palabra

int main(){
    FILE *fichero;
    fichero = fopen("datos.txt", "r"); // abrimos el fichero en modo lectura
    char *clave_buscada = "ST2"; // clave que queremos buscar
    char palabra_actual[MAX_SIZE], estado_buscado[MAX_SIZE];
    bool encontrado = false; // si no quieres usar <stdbool.h> usa int encontrado = 0

    fgets(palabra_actual, MAX_SIZE, fichero); // guardamos la primera linea que no sirve para nada
    while(!feof(fichero) and !encontrado){ // mientras no lleguemos al final del fichero y no hayamos encontrado la palabra que buscamos
        fscanf(fichero, "%s", palabra_actual); // guardamos una palabra
        fgets(estado_buscado, MAX_SIZE, fichero); // guardamos el resto de la linea
        if(strncmp(clave_buscada, palabra_actual, 3) == 0) // comparamos los 3 primeros caracteres con la clave que buscamos y si son iguales...
            encontrado = true; // ...indicamos que ya la hemos encontrado para salir antes del bucle. Si no se ha usado bool, cambiar por encontrado = 1
    }

    if(encontrado) // si la hemos encontrado
        printf("La informacion de %s es: %s\n", clave_buscada, estado_buscado);
}
Se puede usar una sola variable (palabra_actual / estado). He usado 2 para que se vea más visual lo que hacemos. La clave yo la he elegido como he querido, lo suyo es pedírsela al usuario y elegir el formato que tendrá tu fichero y adaptarlo para que funcione. En el ejemplo te muestro cómo funciona tanto <fgets()> como <fscanf()> para que veas las diferencias.
El resto ya te queda a ti.
(El código no lo he probado por lo que puede tener algún error del que no me haya dado cuenta)

Estaba mirando el problema antes de ver la respuesta anterior así que te dejo una alternativa a la de @Loretz con los operadores más básicos y con arrays dinámicos.

Código (cpp) [Seleccionar] Expandir


string cadena_original = "abcde0fghij1kl";
size_t relleno = DIVISOR - (cadena_original.size() % DIVISOR);
for(size_t i = 0; i < relleno; ++i)
cadena_original += '0';

size_t num_subcadenas = cadena_original.size() / DIVISOR;
string *vector_string = new string [num_subcadenas];

for(size_t i = 0; i < num_subcadenas; ++i)
for(size_t j = 0; j < DIVISOR; ++j)
vector_string[i] += cadena_original[i*DIVISOR+j];

<fwrite()/fread()> son funciones para trabajar con ficheros en modo binario. Te recomiendo que no uses esos y te limites a usar <fgets> para leer cadenas del fichero y <fprintf()> para escribirlas.
Lo que debes hacer es abrir el fichero en modo lectura e ir leyendo por ejemplo la primera palabra de cada línea, si esta coincide con la que buscas, guardas el resto de la línea en otra variable y terminas. Si no coincide, lees el resto de la línea (porque el acceso es secuencial, no aleatorio) y pruebas con la primera palabra de la siguiente línea.