Función para reemplazar string en C

/* El programa recibe como entrada un código de
	 error con formato 99X, siendo la X uno de los
	 símbolos abajo detallados, y lo convierte al 
	 código real con formato +/-999. La tabla de
	 equivalencias usada es la siguiente:

 {        +0 
 A        +1 
 B        +2 
 C        +3 
 D        +4 
 E        +5 
 F        +6 
 G        +7 
     H        +8 
 I        +9 

 }        -0 
 J        -1 
 K        -2 
 L        -3 
 M        -4 
 N        -5 
 O        -6 
 P        -7 
 Q        -8 
 R        -9

 Así, una entrada de por ejemplo '80L', 
 daría como salida '-803'; y una entrada
 de '10{' daría como salida '100'. */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>

#define LEN  10  // Longitud de cada array

char positivos[LEN]; // Letras A-I + {
char negativos[LEN]; // Letras J-R + }
char valores[LEN]; // Valores del 0 al 9

struct resultados {  

	char posicion;    // Posición del array en la que se encontró la letra
	char signo;  // Signo que le corresponde al valores[i] según si la letra se encontro en positivios[] o negativos[]
};             // 0 si se encontró en positivos[]; 1 si encontró en negativos[];

void print_cabecera() {
	puts("###############################################################################");
	puts("###############################################################################");
	puts("#####  @PROGRAM: Error Converter v0.1 #########################################");
	puts("#####  @AUTHOR: Yo                             #########################################");
	puts("#####  @DATE: 22/05/2011              #########################################");
	puts("###############################################################################");
	puts("###############################################################################\n\n");
}

/* RELLENA LOS ARRAYS positivos[], negativos[],
   Y valores[]. */

void rellenar_arrays() {
	char i;
	char mayus_ascii;

positivos[0] = 123; // 123 equivale al símbolo {

for (i=1, mayus_ascii=65; i<LEN; i++, mayus_ascii++) {
	positivos[i] = mayus_ascii;
}

negativos[0] = 125; // 125 equivale al símbolo }

for (i=1; i<LEN; i++, mayus_ascii++) { // mayus_asci ya tiene el valor correcto del bucle anterior
	negativos[i] = mayus_ascii;
}

for (i=0; i<LEN; i++)
	valores[i] = i;
}

/* DEVUELVE LA ÚLTIMA LETRA DEL STRING QUE 
	 RECIBE COMO ÚNICO PARÁMETRO */

char separar_cod(char* input) {
	char letra;

for (int i=strlen(input)-1; i<strlen(input); i++)
	letra = input[i];

return letra;
}

 /*  BUSCA LA LETRA RECIBIDA POR PARÁMETRO EN LOS
	 ARRAYS positivos[] y negativos[]. DEVUELVE
	 UNA ESTRUCTURA CON EL ÍNDICE EN EL QUE SE
	 ENCONTRÓ LA COINCIDENCIA, Y EL SIGNO QUE
	 INDICA EN CUÁL DE LOS DOS ARRAYS. */

resultados buscar_char (char input) {
	struct resultados result;

for (int i=0; i<LEN; i++)
	if (positivos[i] = input) {
		result.posicion = i;
		result.signo = 0;

		return result;
	} else
		if (negativos[i] = input) {
			result.posicion = i;
			result.signo = 1;

	    return result;
		}
}

int main(void) {
	char cod_error[3];
	char* cod_num;
	char cod_letra;
	char primera_vez = 1;
	struct resultados result;
	char* str_output;

print_cabecera();
rellenar_arrays();

do {
	if (primera_vez = 1) {
		puts("Introduzca el código de error ignorando los ceros a la izqu. Máx 3 chars (p.ej. '80L'):");
		primera_vez = 0;
	} else
		puts("Exceso de longitud o caracter no válido. Debe ser {, } o estar comprendido entre A-R");

  gets(cod_error);

	if (strlen(cod_error) <= 3) {
		cod_num = (char*)malloc(sizeof(cod_error)-1);
		strncpy(cod_num, cod_error, strlen(cod_error)-1);
		cod_num[strlen(cod_error)-1] = '\0';
		cod_letra = separar_cod(cod_error);
	} 

	//printf("Num: %s \n", cod_num);
	//printf("Letra: %c %d \n", cod_letra, cod_letra);
} while ( cod_letra < 65 || ( cod_letra > 82 &&  cod_letra != 123 && cod_letra != 125) );

result = buscar_char(cod_letra);

if (result.signo = 0)
	strcat("-", cod_num);
  
str_output = (char*)malloc(sizeof resultados);
strcpy(str_output, cod_num);
strcat(str_output, &valores[result.posicion]);
printf("\n El código equivalente es: %s", str_output);

free(cod_num);     // Ver cómo y dónde liberar la memoria de forma correcta
free(str_output);  // Ver cómo y dónde liberar la memoria de forma correcta
system("pause");
return 0;
}