Si quieres quitar líneas claro que puedes, a costa de perder legibilidad:

• Las líneas 4, 5 y 6 las puedes poner junto a las declaraciones. (3 líneas menos)
• Los <if> y <while> con una sola sentencia dentro, puedes quitar las llaves. (4 líneas menos)
• Puedes cambiar un poco los incrementos. (8 líneas menos contando las 4 líneas menos anteriores)

Ganancias en eficiencia? Ninguna
Pérdidas en legibilidad? Muchas
 
Si quieres ganar un poco en eficiencia lo único que te diría es que los incrementos y decrementos los hagas en prefijo <++i> es ligeramente mejor que <i++>. Pero tampoco creas que te van a mejorar los tiempos de ordenación por hacer eso.

Ten en cuenta que no estás copiando los datos de <drce[indice].file_name> en <file_names_in_dir[indice]>... Lo que estás haciendo es que el puntero del array de punteros que has creado apunte al mismo lugar que el otro <char*>. Entonces si se modifica el valor de <drce[indice].file_name> antes de mostrar tu array, éste último mostrará el nuevo contenido que puede no ser lo que tú esperabas.

Y como bien dice @string Manolo, con ese trocillo de código no podemos ayudar mucho más.
Recordarte también que para que la cadena termine necesitas el caracter '\0' que igual no aparece y por eso la cadena no termina donde debería.

Hay infinidad de implementaciones para un mismo algoritmo por lo que puedes poner tu implementación y así es más fácil decirte si puedes simplificarlo más. La otra opción es esperar que alguien lo tenga más simplificado y te lo mande...
Y no sé a qué te refieres con "pero sin trampa". He supuesto que es a no poner varias instrucciones en una línea para reducir el número de líneas, motivo por el cual no es muy bueno medir la simplificación de un código por su número de líneas.

No estoy muy familiarizado con DLLs pero te dejo este link que quizás te ayude. Está en inglés, espero que te sirva, de todas formas es un inglés fácil de entender
https://stackoverflow.com/questions/4702732/the-program-cant-start-because-libgcc-s-dw2-1-dll-is-missing

Hasta donde yo conozco exclusivo de C no ya que C++ es como una "expansión" de C, añade cosas pero no las quita. Lo que pasa es que hay cosas que en C se usan mucho y son muy típicas y en C++ existen otras formas de hacerlo.
Utilidad a bajo nivel es la misma lo que pasa es que con C te ves obligado a trabajar a más bajo nivel mientras que con C++ no tienes que hacerlo si no quieres. Al tener esta facilidad en C++ es un paso que normalmente la gente se ahorra cuando aprende. Pero si trabajas con C vas a profundizar mucho más en tus conocimientos a bajo nivel. Tampoco quiero asustar, hay muchas cosas que son como en C++ pero acabarás aprendiendo aspectos de más bajo nivel.

Si compilas como C++, al tener C++ incluido todo lo de C más lo suyo propio, si usas cosas de C++ te las dará por válidas y no sabrás que no puedes usar eso en C. A no ser claro que aprendas primero de forma teórica lo que se puede y lo que no.
A mí personalmente me ayudó mucho para diferenciar ambos lenguajes el compilar desde la Terminal de Linux, usando el comando g++ para compilar en C++ y gcc para compilar en C y te olvidas de IDEs, sólo necesitas un editor de textos y la propia Terminal.

C++ es como una expansión de C por lo que todo lo que puedes hacer en C, lo puedes hacer en C++. Como es lógico, C++ es un "avance" por lo que tiene añadidos que facilitan algunas cosas. Por ejemplo en C olvídate de strings (debes usar <char*>), clases(debes usar <struct>), paso por referencia(tendrás que usar punteros), para usar <bool> tienes que incluir <stdbool.h> o usar <int> con valores de 0 y 1.
Al no estar orientado a objetos como C++ no tendrás cosas como:

ifstream fichero_entrada;
fichero_entrada.open("nombre_fichero.txt"); 

Sino que tendrás:

FILE *fichero_entrada;
fichero_entrada = fopen("nombre_fichero.txt", "r"); 

Y si quieres ver más diferencias puedes seguir mirando cómo se hace todo lo que haces en C++ en C. Pero asegúrate de compilar para C porque muchos comenten el error de decir que programan en C pero están compilando en C++ por lo que meten sentencias de C++ que no existen en C y no les da problemas.

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.

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;
} 

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.

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.