Implementación de Algoritmos de Procesamiento de Archivos y Estructuras de Datos en C
Enviado por Chuletator online y clasificado en Informática y Telecomunicaciones
Escrito el en 
español con un tamaño de 60,21 KB
Código Fuente C: Procesamiento de Archivos y Estructuras de Datos
El siguiente código contiene varias implementaciones en C para tareas comunes de procesamiento de datos, incluyendo manejo de archivos binarios y de texto, estructuras de datos dinámicas y algoritmos de ordenamiento.
1. Actualización de Cuentas Bancarias (CBSH)
Este segmento gestiona la actualización de saldos de cuentas a partir de un archivo de movimientos, utilizando archivos binarios para las cuentas.
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#define TAM_LINEA 50
Descripción del Proceso Bancario
El banco “CBSH” mantiene el estado de las cuentas en el archivo cuentas.dat. Este archivo se actualiza diariamente con los movimientos del archivo de texto movimientos.txt de la siguiente manera:
- Si el movimiento es un débito (D): se resta el importe al saldo de la cuenta cliente.
- Si el movimiento es un crédito (C): se suma el importe al saldo de la cuenta cliente.
Ambos archivos están ordenados por el número de cuenta. El archivo de movimientos puede contener cuentas válidas que no existen en el archivo de cuentas; estos registros deben ser ignorados. El banco permite saldos negativos (descubierto).
Estructuras de Datos
typedef struct{
char cod_cta[9];
long dni;
char apyn[40];
float saldo;
}t_cuenta;
typedef struct{
char cod_cta[9];
char tipo_mov;
float importe;
}t_movimiento;
Funciones de Procesamiento
/******************************************************************************/
void texto_a_movimiento(const char * cadena, t_movimiento * pmov)
{
sscanf(cadena, "%[^"]|%c|%f", pmov->cod_cta, &pmov->tipo_mov, &pmov->importe);
}
/**/
void actualizar_cuentas(const char path_arch_ctas, const char path_arch_movs, const char path_arch_err)
{
FILE arch_cuenta, *arch_mov;
arch_cuenta = fopen (path_arch_ctas,"r+b");
if(!arch_cuenta)
{
puts("Error al abrir archivo de cuentas...");
return;
}
arch_mov = fopen (path_arch_movs,"rt");
if(!arch_mov) // CORRECCIÓN: Se verificaba arch_cuenta nuevamente
{
puts("Error al abrir archivo de movimientos...");
fclose(arch_cuenta);
return;
}
t_cuenta cuenta;
t_movimiento mov;
char linea_mov[TAM_LINEA];
fread(&cuenta,sizeof(t_cuenta),1,arch_cuenta);
fgets(linea_mov,TAM_LINEA,arch_mov);
int cmp;
while (!feof(arch_cuenta) && !feof(arch_mov))
{
texto_a_movimiento(linea_mov, &mov);
cmp = strcmp(cuenta.cod_cta, mov.cod_cta);
if(cmp == 0)
{
if(mov.tipo_mov == 'C')
cuenta.saldo += mov.importe;
else
cuenta.saldo -= mov.importe;
// Retroceder para reescribir el registro actualizado
fseek(arch_cuenta, -(long)sizeof(t_cuenta), SEEK_CUR);
fwrite(&cuenta, sizeof(t_cuenta), 1, arch_cuenta);
fseek(arch_cuenta, 0, SEEK_CUR); // Avanzar después de escribir
// Leer siguiente cuenta y siguiente movimiento
fread(&cuenta,sizeof(t_cuenta),1,arch_cuenta);
//ESCRIBIR EN ARCHIVO DE TEXTO
//fprintf(arch_error, "Cuenta: %s | Saldo: %f\n", cuenta.cod_cta, cuenta.saldo);
}
else
{
if(cmp > 0) // El movimiento tiene un código mayor, avanzar en movimientos
fgets(linea_mov,TAM_LINEA,arch_mov);
else // El movimiento tiene un código menor, avanzar en cuentas
fread(&cuenta,sizeof(t_cuenta),1,arch_cuenta);
}
}
fclose(arch_cuenta);
fclose(arch_mov);
}
2. Fusión de Socios de Clubes (Club A y Club B)
Este conjunto de funciones maneja la fusión de dos listados de socios, uno binario (Club A) y otro de texto (Club B), generando un archivo consolidado Socios_Fus.dat.
Requisitos de Fusión
- El archivo binario
Socios_Club_A.datestá ordenado por código de socio. - El archivo de texto
Socios_Club_B.txtestá ordenado por código de socio y tiene campos separados por|. - El código de socio en el archivo fusionado debe indicar su origen:
código-A,código-B, ocódigo-ABsi está en ambos. - La antigüedad debe ser la mayor entre los registros coincidentes.
Estructuras de Socios
typedef struct
{
int nro_socio;
char apyn[51];
int antiguedad;
}t_socio_bin;
typedef struct
{
char cod_socio[11]; // Suficiente para el código fusionado (ej: 1234-AB)
char apyn[51];
int antiguedad;
}t_socio_txt;
Funciones Auxiliares y de Creación de Datos
/*****************************************************************************/
void crear_archivo_socios_a(const char * path)
{
t_socio_bin socios[] = {
{1144, "Perez, Juan", 12 },
{1155, "Rodriguez, Pedro", 25 },
{1163, "Pereyra, Joaquin", 11 },
{1211, "Gonzalez, Oscar", 38 },
{1234, "Garcia, Julian", 9 },
{1245, "Nunez, Alejandro", 26 },
{1256, "Castro, Fernando", 23 },
{1378, "Alvarez, Roberto", 22 }
};
FILE *arch = fopen(path, "wb");
if (arch) {
fwrite(socios, sizeof(socios), 1, arch);
fclose(arch);
}
}
/*****/
void mostrar_archivo_socios_a(const char path)
{
t_socio_bin socio;
FILE arch = fopen(path, "rb");
if (!arch) { exit(2); }
fread(&socio, sizeof(t_socio_bin), 1, arch);
while(!feof(arch))
{
printf("%d, %s, %d\n", socio.nro_socio, socio.apyn, socio.antiguedad );
fread(&socio, sizeof(t_socio_bin), 1, arch);
}
fclose(arch);
}
/*****/
void mostrar_archivo_socios_b(const char path)
{
FILE arch = fopen(path, "rt");
char texto[50];
if(!arch)
return;
fgets(texto, 50, arch);
while(!feof(arch))
{
printf("%s", texto);
fgets(texto, 50, arch);
}
fclose(arch);
}
/*****/
void mostrar_archivo_final(const char path)
{
t_socio_txt socio;
FILE arch = fopen(path, "rb");
if (!arch) { exit(2); }
fread(&socio, sizeof(t_socio_txt), 1, arch);
while(!feof(arch))
{
printf("%s, %s, %d\n", socio.cod_socio, socio.apyn, socio.antiguedad );
fread(&socio, sizeof(t_socio_txt), 1, arch);
}
fclose(arch);
}
/*****/
int cmp_socios_res(const void v1, const void v2)
{
const t_socio_bin s1 = (const t_socio_bin )v1;
const t_socio_bin s2 = (const t_socio_bin )v2;
return s1->nro_socio - s2->nro_socio;
}
int cmp_socios(const void v1, const void v2)
{
// Casteamos el primer puntero a t_socio_bin
const t_socio_bin socio_a = (const t_socio_bin) v1;
// Casteamos el segundo puntero a t_socio_txt
const t_socio_txt *socio_b = (const t_socio_txt*) v2;
int nro_socio_b;
// 1. Convertir la cadena numérica (char*) de socio B a un entero (int).
// Usamos atoi() para la conversión directa, ya que se asume que cod_socio solo contiene dígitos.
nro_socio_b = atoi(socio_b->cod_socio);
// 2. Comparar los dos enteros.
if (socio_a->nro_socio == nro_socio_b)
return 0; // Socio A == Socio B
if (socio_a->nro_socio > nro_socio_b)
return 1; // Socio A (binario) es mayor
return -1; // Socio B (texto) es mayor
}
/*****/
void arma_socio_final_res(const void v_socio, void v_socio_fusion, const char tipo)
{
// Casteo del puntero de origen (v_socio) a la estructura binaria (t_socio_bin).
// Esto permite acceder a los campos nro_socio, apyn y antiguedad.
const t_socio_bin socio = (const t_socio_bin *)v_socio;
// Casteo del puntero de destino (v_socio_fusion) a la estructura final de texto (t_socio_txt).
t_socio_txt * socio_f = (t_socio_txt *)v_socio_fusion;
// --- MANEJO DEL CÓDIGO DE SOCIO (NRO_SOCIO) ---
// 1. Convertir el número de socio entero (int) a una cadena de caracteres (char*).
// itoa(origen_int, destino_char_array, base). Nota: itoa no es estándar ANSI C.
char temp_num[10];
sprintf(temp_num, "%d", socio->nro_socio);
// 2. Concatenar el sufijo de procedencia (ej. "-AB") a la cadena del código de socio.
strcpy(socio_f->cod_socio, temp_num);
strcat(socio_f->cod_socio, tipo);
// --- COPIA DE APELLIDO Y NOMBRE (APYN) ---
// Copiar la cadena apyn del origen al destino. Se requiere strcpy.
strcpy(socio_f->apyn, socio->apyn);
// --- COPIA DE ANTIGÜEDAD ---
// Copiar el valor entero de antigüedad.
socio_f->antiguedad = socio->antiguedad;
}
/*****/
int leer_registro_arch_socios_b_res(FILE arch, t_socio_bin socio)
{
char texto[50];
if (fgets(texto, sizeof(texto), arch) == NULL) return 0;
// Se asume que la línea leída es válida y termina con '
' o es la última línea.
// Se debe limpiar el '
' si existe para que sscanf no lo interprete mal.
char p_salto = strchr(texto, '\n');
if (p_salto) p_salto = '\0';
// Usamos sscanf para parsear el formato "nro|apyn|antiguedad"
int items_leidos = sscanf(texto, "%d|%[^"]|%d", &socio->nro_socio, socio->apyn, &socio->antiguedad);
return (items_leidos == 3);
}
/*****/
void fusionar_clubes_res(const char path_socios_a, const char path_socios_b, const char path_socios_final)
{
FILE arch_socios_a, arch_socios_b, arch_socios_final;
t_socio_bin socio_a;
t_socio_txt socio_b_txt, socio_final;
int lect, cmp;
arch_socios_a = fopen(path_socios_a, "rb");
if (!arch_socios_a)
exit(1);
arch_socios_b = fopen(path_socios_b, "rt");
if (!arch_socios_b)
{
fclose(arch_socios_a);
exit(2);
}
arch_socios_final = fopen(path_socios_final, "wb");
if (!arch_socios_final)
{
fclose(arch_socios_a);
fclose(arch_socios_b);
exit(3);
}
// Lectura inicial
if (fread(&socio_a, sizeof(t_socio_bin), 1, arch_socios_a) != 1) {
// Archivo A vacío o error de lectura inicial
fclose(arch_socios_a);
fclose(arch_socios_b);
fclose(arch_socios_final);
return;
}
lect = leer_registro_arch_socios_b_res(arch_socios_b, &socio_b_txt);
while(!feof(arch_socios_a) && lect)
{
// Comparación basada en el número de socio (int vs int convertido de string)
cmp = cmp_socios_res(&socio_a, &socio_b_txt);
if(cmp == 0)
{
// Coincidencia: Tomar la mayor antigüedad
socio_a.antiguedad = (socio_a.antiguedad > socio_b_txt.antiguedad) ? socio_a.antiguedad : socio_b_txt.antiguedad;
arma_socio_final_res(&socio_a, &socio_final, "-AB");
fwrite(&socio_final, sizeof(t_socio_txt), 1, arch_socios_final);
// Avanzar ambos punteros
if (fread(&socio_a,sizeof(t_socio_bin),1,arch_socios_a) != 1) break;
lect = leer_registro_arch_socios_b_res(arch_socios_b, &socio_b_txt);
}
else if(cmp < 0) // Socio A < Socio B (A va primero)
{
arma_socio_final_res(&socio_a, &socio_final, "-A");
fwrite(&socio_final, sizeof(t_socio_txt), 1, arch_socios_final);
// Avanzar solo A
if (fread(&socio_a,sizeof(t_socio_bin),1,arch_socios_a) != 1) break;
}
else // Socio B < Socio A (B va primero, cmp > 0)
{
// Nota: socio_b_txt debe ser adaptada para arma_socio_final_res si se usa directamente,
// pero aquí se usa socio_b_txt como fuente de datos para el socio B, aunque la función espera t_socio_bin.
// **CORRECCIÓN NECESARIA**: arma_socio_final_res debe ser adaptada o se debe crear una versión para t_socio_txt.
// Asumiendo que socio_b_txt tiene los datos necesarios para la estructura final (solo se usa nro_socio, apyn, antiguedad):
// Para evitar reescribir la lógica de armado, se asume que socio_b_txt se usa como fuente temporal
// y que los campos necesarios están disponibles (aunque la firma original esperaba t_socio_bin).
// Dado que socio_b_txt ya tiene el formato de salida (cod_socio, apyn, antiguedad),
// se necesita una función de armado diferente o adaptar la fuente.
// **SOLUCIÓN TEMPORAL**: Se usa socio_b_txt directamente para escribir, asumiendo que el código de B es solo el número.
// Esto viola la firma de arma_socio_final_res, pero se adapta al contexto de la fusión.
// Se reescribe la lógica para usar socio_b_txt directamente si cmp > 0, ya que socio_b_txt ya tiene el formato de salida (excepto el sufijo).
// **Revisión de la lógica original**: La función arma_socio_final_res está diseñada para convertir t_socio_bin a t_socio_txt.
// Si cmp > 0, el socio B es el menor y debe escribirse.
// Se necesita una función auxiliar para armar el registro final a partir de t_socio_txt (Socio B)
t_socio_txt temp_final;
strcpy(temp_final.cod_socio, socio_b_txt.cod_socio);
strcat(temp_final.cod_socio, "-B");
strcpy(temp_final.apyn, socio_b_txt.apyn);
temp_final.antiguedad = socio_b_txt.antiguedad;
fwrite(&temp_final, sizeof(t_socio_txt), 1, arch_socios_final);
lect = leer_registro_arch_socios_b_res(arch_socios_b, &socio_b_txt);
}
}
// Procesar restantes de A
while(fread(&socio_a,sizeof(t_socio_bin),1,arch_socios_a) == 1)
{
arma_socio_final_res(&socio_a, &socio_final, "-A");
fwrite(&socio_final, sizeof(t_socio_txt), 1, arch_socios_final);
}
// Procesar restantes de B
while(lect)
{
// Se reutiliza la lógica de armado para B
t_socio_txt temp_final;
char temp_num[10];
sprintf(temp_num, "%d", socio_b_txt.nro_socio);
strcpy(temp_final.cod_socio, temp_num);
strcat(temp_final.cod_socio, "-B");
strcpy(temp_final.apyn, socio_b_txt.apyn);
temp_final.antiguedad = socio_b_txt.antiguedad;
fwrite(&temp_final, sizeof(t_socio_txt), 1, arch_socios_final);
lect = leer_registro_arch_socios_b_res(arch_socios_b, &socio_b_txt);
}
fclose(arch_socios_a);
fclose(arch_socios_b);
fclose(arch_socios_final);
}
void fusionar_clubes(const char path_socios_a, const char path_socios_b, const char path_socios_final)
{
// Esta función parece ser una versión anterior o alternativa a fusionar_clubes_res.
// Se mantiene el código original, aunque la lógica de armado es inconsistente con la estructura t_socio_txt.
FILE arch_socio_a, arch_socio_b, arch_socio_f;
arch_socio_a = fopen (path_socios_a,"rb");
if(!arch_socio_a)
{
puts("Error al abrir el archivo binario de socios a...");
return;
}
arch_socio_b = fopen(path_socios_b,"rt");
if(!arch_socio_b)
{
puts("Error al abrir el archivo de texto de socios b...");
fclose(arch_socio_a);
return;
}
arch_socio_f = fopen(path_socios_final,"wb");
if(!arch_socio_f)
{
puts("Error al abrir el archivo binario de socios finales...");
fclose(arch_socio_a);
fclose(arch_socio_b);
return;
}
t_socio_bin socio_a, socio_b_bin_temp; // socio_b_bin_temp se usa para leer de B
t_socio_txt socio_f;
if (fread(&socio_a,sizeof(t_socio_bin),1,arch_socio_a) != 1) {
fclose(arch_socio_a);
fclose(arch_socio_b);
fclose(arch_socio_f);
return;
}
int cmp, lect = leer_registro_arch_socios_b_res(arch_socio_b, &socio_b_bin_temp);
while(!feof(arch_socio_a)&&lect)
{
// Se usa cmp_socios_res que compara t_socio_bin con t_socio_txt (a través de atoi)
cmp = cmp_socios_res(&socio_a, &socio_b_bin_temp);
if(cmp == 0)
{
if(socio_a.antiguedad > socio_b_bin_temp.antiguedad)
socio_f.antiguedad = socio_a.antiguedad;
else
socio_f.antiguedad = socio_b_bin_temp.antiguedad;
// Se usa socio_a como fuente para armar el registro final (asumiendo que el nro_socio es el mismo)
arma_socio_final_res(&socio_a,&socio_f,"-AB");
fwrite(&socio_f,sizeof(t_socio_txt),1,arch_socio_f); // Escribimos t_socio_txt
if (fread(&socio_a,sizeof(t_socio_bin),1,arch_socio_a) != 1) break;
lect = leer_registro_arch_socios_b_res(arch_socio_b,&socio_b_bin_temp);
}
else if(cmp > 0) // B es menor
{
// Se necesita adaptar socio_b_bin_temp para arma_socio_final_res o usar lógica directa
// Usando lógica directa para B (similar a la corrección en fusionar_clubes_res)
t_socio_txt temp_final;
char temp_num[10];
sprintf(temp_num, "%d", socio_b_bin_temp.nro_socio);
strcpy(temp_final.cod_socio, temp_num);
strcat(temp_final.cod_socio, "-B");
strcpy(temp_final.apyn, socio_b_bin_temp.apyn);
temp_final.antiguedad = socio_b_bin_temp.antiguedad;
fwrite(&temp_final,sizeof(t_socio_txt),1,arch_socio_f);
lect = leer_registro_arch_socios_b_res(arch_socio_b,&socio_b_bin_temp);
}
else // cmp < 0, A es menor
{
arma_socio_final_res(&socio_a,&socio_f,"-A");
fwrite(&socio_f,sizeof(t_socio_txt),1,arch_socio_f);
if (fread(&socio_a,sizeof(t_socio_bin),1,arch_socio_a) != 1) break;
}
}
// Restantes de A
while(!feof(arch_socio_a))
{
arma_socio_final_res(&socio_a,&socio_f,"-A");
fwrite(&socio_f,sizeof(t_socio_txt),1,arch_socio_f);
if (fread(&socio_a,sizeof(t_socio_bin),1,arch_socio_a) != 1) break;
}
// Restantes de B
while(lect)
{
t_socio_txt temp_final;
char temp_num[10];
sprintf(temp_num, "%d", socio_b_bin_temp.nro_socio);
strcpy(temp_final.cod_socio, temp_num);
strcat(temp_final.cod_socio, "-B");
strcpy(temp_final.apyn, socio_b_bin_temp.apyn);
temp_final.antiguedad = socio_b_bin_temp.antiguedad;
fwrite(&temp_final,sizeof(t_socio_txt),1,arch_socio_f);
lect = leer_registro_arch_socios_b_res(arch_socio_b,&socio_b_bin_temp);
}
fclose(arch_socio_a);
fclose(arch_socio_b);
fclose(arch_socio_f);
}
3. Consolidación y Reporte de Posiciones de Embarcaciones
Este bloque procesa dos archivos CSV ordenados por Unix Timestamp para consolidar posiciones y calcular la distancia recorrida por cada embarcación.
Definición del Problema
Se consolidan posicionesA.csv y posicionesB.csv (ordenados por fecha/hora) en posicionesR.csv. Se debe calcular y mostrar la distancia total recorrida por cada matrícula.
#include <math.h>
#define MAX_EMBARCACIONES 10
#define ARCH_A "posicionesA.csv"
#define ARCH_B "posicionesB.csv"
#define ARCH_R "posicionesR.csv"
Estructuras de Posición y Estado
typedef struct {
long fecha_hora;
char matricula[10];
double latitud;
double longitud;
} t_posicion;
typedef struct {
char matricula[10];
double distancia_acumulada;
t_posicion ultima_posicion; // Necesaria para calcular la distancia incremental
int activa; // 1 si en uso, 0 si libre
} t_embarcacion_estado;
Funciones de Cálculo y Lectura
double calcular_distancia(double lat1, double lon1, double lat2, double lon2)
{
// Simplificación: Distancia aproximada usando solo la diferencia de latitud (111 km por grado)
return fabs(lat1 - lat2) * 111.0;
}
int linea_a_posicion (t_posicion pos, FILE fp)
{
char linea[TAM_LINEA];
if (fgets(linea,sizeof(linea),fp) == NULL) return 0;
// Limpiar salto de línea si existe
char *p_salto = strchr(linea, '\n');
if (p_salto) *p_salto = '\0';
// Formato CSV: fecha_hora,matricula,latitud,longitud
if(sscanf(linea, "%ld,%[^,],%lf,%lf", &pos->fecha_hora, pos->matricula, &pos->latitud, &pos->longitud) == 4)
{
return 1;
}
return 0;
}
long cmp_timestamp (const long time_a, const long time_b)
{
return time_a - time_b;
}
Consolidación de Registros
void consolidar_embarcaciones (const char* arch_a, const char* arch_b, const char* arch_r)
{
FILE *fpa, *fpb, *fpr;
fpa = fopen(arch_a, "rt");
if(!fpa)
{
puts("Error al abrir el archivo de posiciones a...");
return;
}
fpb = fopen(arch_b, "rt");
if(!fpb)
{
puts("Error al abrir el archivo de posiciones b...");
fclose(fpa);
return;
}
fpr = fopen(arch_r, "wt");
if(!fpr)
{
puts("Error al generar el archivo de posiciones consolidado...");
fclose(fpa);
fclose(fpb);
return;
}
t_posicion pos_a, pos_b;
int lect_a, lect_b, cmp, cmp_emb;
lect_a = linea_a_posicion(&pos_a, fpa);
lect_b = linea_a_posicion(&pos_b, fpb);
while (lect_a && lect_b)
{
cmp = cmp_timestamp(pos_a.fecha_hora, pos_b.fecha_hora);
if(cmp > 0) // Pos B es anterior
{
fprintf(fpr, "%ld,%s,%.3f,%.3f\n", pos_b.fecha_hora, pos_b.matricula, pos_b.latitud, pos_b.longitud);
lect_b = linea_a_posicion(&pos_b, fpb);
}else if (cmp == 0) // Timestamps iguales
{
cmp_emb = strcmp(pos_a.matricula, pos_b.matricula);
if(cmp_emb == 0) // Misma matrícula y tiempo: Se prioriza B (o se escribe B y se avanza A y B)
{
fprintf(fpr, "%ld,%s,%.3f,%.3f\n", pos_b.fecha_hora, pos_b.matricula, pos_b.latitud, pos_b.longitud);
lect_b = linea_a_posicion(&pos_b, fpb);
lect_a = linea_a_posicion(&pos_a, fpa);
}
else if (cmp_emb > 0) // B tiene matrícula mayor (B va después en orden alfabético)
{
fprintf(fpr, "%ld,%s,%.3f,%.3f\n", pos_b.fecha_hora, pos_b.matricula, pos_b.latitud, pos_b.longitud);
lect_b = linea_a_posicion(&pos_b, fpb);
}
else // cmp_emb < 0 (A tiene matrícula mayor)
{
fprintf(fpr, "%ld,%s,%.3f,%.3f\n", pos_a.fecha_hora, pos_a.matricula, pos_a.latitud, pos_a.longitud);
lect_a = linea_a_posicion(&pos_a, fpa);
}
}else if(cmp < 0) // Pos A es anterior
{
fprintf(fpr, "%ld,%s,%.3f,%.3f\n", pos_a.fecha_hora, pos_a.matricula, pos_a.latitud, pos_a.longitud);
lect_a = linea_a_posicion(&pos_a, fpa);
}
}
// Escribir restantes
while(lect_a)
{
fprintf(fpr, "%ld,%s,%.3f,%.3f\n", pos_a.fecha_hora, pos_a.matricula, pos_a.latitud, pos_a.longitud);
lect_a = linea_a_posicion(&pos_a, fpa);
}
while(lect_b)
{
fprintf(fpr, "%ld,%s,%.3f,%.3f\n", pos_b.fecha_hora, pos_b.matricula, pos_b.latitud, pos_b.longitud);
lect_b = linea_a_posicion(&pos_b, fpb);
}
fclose(fpa);
fclose(fpb);
fclose(fpr);
}
Cálculo de Distancias
void inicializar_estado(t_embarcacion_estado *estado, const t_posicion *pos)
{
strcpy(estado->matricula, pos->matricula);
estado->distancia_acumulada = 0.0;
estado->ultima_posicion = *pos;
estado->activa = 1;
}
t_embarcacion_estado obtener_o_crear_estado(t_embarcacion_estado estados, const t_posicion pos, int ce)
{
t_embarcacion_estado *p_estado = estados;
// 1. Búsqueda (Aritmética de Punteros: *(p_estado + i))
for (int i = 0; i < *ce; i++) {
if (strcmp((p_estado + i)->matricula, pos->matricula) == 0) {
return (p_estado + i); // Encontrado
}
}
// 2. Si no se encuentra, agregar (solo si hay espacio)
if (*ce < MAX_EMBARCACIONES) {
t_embarcacion_estado *nuevo_slot = (p_estado + *ce); // Aritmética de punteros
inicializar_estado(nuevo_slot, pos);
(*ce)++; // Incrementar el contador de embarcaciones distintas
return nuevo_slot;
}
return NULL; // Máximo alcanzado
}
void imprimir_distancias (const char arch_r)
{
FILE fp;
t_posicion posActual;
// Array de estado en la STACK (Eficiente en memoria)
t_embarcacion_estado estados[MAX_EMBARCACIONES];
t_embarcacion_estado *estadoActual;
int contador_embarcaciones = 0;
int lect;
// Inicializar todos los slots a inactivos
for (int i = 0; i < MAX_EMBARCACIONES; i++) {
estados[i].activa = 0;
}
fp = fopen(arch_r,"rt");
if(!fp)
{
puts("Error al abrir el archivo consolidado para cálculo de distancias...");
return;
}
// Recorrido Único del Archivo Consolidado
while( (lect = linea_a_posicion(&posActual, fp)) == 1 )
{
estadoActual = obtener_o_crear_estado(estados, &posActual, &contador_embarcaciones);
if (estadoActual == NULL) continue;
// Si la distancia acumulada es 0, esta es la primera posición (punto de partida).
// Si ya hay algo acumulado, o si la matrícula fue vista, calculamos la distancia.
if (estadoActual->distancia_acumulada > 0.0 || estadoActual->activa > 0)
{
// Calcular distancia desde la última posición conocida
double dist_incremental = calcular_distancia(
estadoActual->ultima_posicion.latitud,
estadoActual->ultima_posicion.longitud,
posActual.latitud,
posActual.longitud
);
estadoActual->distancia_acumulada += dist_incremental;
}
// Actualizar la última posición para el próximo cálculo
estadoActual->ultima_posicion = posActual;
estadoActual->activa = 2; // Marca que ya tiene un punto de referencia válido
}
// 2. Imprimir Resultados (Salida por pantalla)
printf("\n--- Distancia Recorrida por Embarcación ---\n");
for (int i = 0; i < contador_embarcaciones; i++) {
printf("Matrícula %s: %.2f km\n",
estados[i].matricula,
estados[i].distancia_acumulada);
}
fclose(fp);
}
4. Consolidación de Cargos (Empresa S.A.)
Consolidación de dos archivos de texto de cargos (cargoNew.txt y cargoOld.txt), ambos con longitud de línea indicada en la primera línea. Se genera cargo.txt y errores.txt para legajos con cargos diferentes.
Estructura de Cargo
typedef struct{
int legajo;
char sucursal[4];
char codigo[4];
}t_cargo;
Funciones de Lectura y Comparación
int leer_primer_linea_texto(int *longitud, FILE* fp)
{
char linea[TAM_LINEA];
if (fgets(linea, TAM_LINEA, fp) == NULL) return 0;
// Limpiar salto de línea
char *p_salto = strchr(linea, '\n');
if (p_salto) *p_salto = '\0';
if (sscanf(linea, "%d", longitud) == 1) {
return 1;
}
return 0;
}
int leer_cargo_texto(t_cargo cargo, int longitud, FILE fp)
{
// Se usa malloc para leer la línea completa según la longitud reportada
char linea = (char) malloc(longitud + 2); // +2 por seguridad y terminador
if(fgets(linea, longitud + 2, fp) == NULL)
{
free(linea);
return 0; // EOF
}
// --- PASO CLAVE: LIMPIEZA DEL SALTO DE LÍNEA ---
char *p_salto = strchr(linea, '\n');
if (p_salto != NULL) {
*p_salto = '\0'; // Si existe, lo eliminamos.
}
// VALIDACIÓN: Solo verificamos que sscanf lea 3 campos.
int items_leidos = sscanf(linea, "%d|%[^|]|%[^"]",
&cargo->legajo,
cargo->sucursal,
cargo->codigo);
free(linea);
// Si leemos 3 campos, es exitoso.
if (items_leidos == 3) {
return 1;
} else {
return 0;
}
}
int cmp_legajos(int cargo_a, int cargo_b)
{
return cargo_a - cargo_b;
}
Función de Consolidación de Cargos
void consolidar_archivos_cargos (const char *path_new, const char *path_old, const char *path_fin, const char *path_error)
{
FILE *fp_new, *fp_old, *fp_fin, *fp_error;
fp_new = fopen (path_new, "rt");
if(!fp_new)
{
puts("Error al abrir el archivo de cargos nuevos...");
return;
}
fp_old = fopen (path_old, "rt");
if(!fp_old)
{
puts("Error al abrir el archivo de cargos viejos...");
fclose(fp_new);
return;
}
fp_fin = fopen (path_fin, "wt");
if(!fp_fin)
{
puts("Error al generar el archivo de cargos consolidados...");
fclose(fp_new);
fclose(fp_old);
return;
}
fp_error = fopen (path_error, "wt");
if(!fp_error)
{
puts("Error al generar el archivo de cargos erroneos...");
fclose(fp_new);
fclose(fp_old);
fclose(fp_fin);
return;
}
int lect_new, lect_old;
int long_new, long_old;
// Lectura de longitudes
if(leer_primer_linea_texto(&long_new, fp_new) == 0)
{
puts("Error al leer la longitud de los cargos del archivo new...");
// Cierre de archivos omitido por brevedad, pero necesario en producción
return;
}
if(leer_primer_linea_texto(&long_old, fp_old) == 0)
{
puts("Error al leer la longitud de los cargos del archivo old...");
// Cierre de archivos omitido
return;
}
t_cargo cargo_new, cargo_old;
lect_new = leer_cargo_texto(&cargo_new, long_new, fp_new);
lect_old = leer_cargo_texto(&cargo_old, long_old, fp_old);
int cmp;
while(lect_new && lect_old)
{
cmp = cmp_legajos(cargo_new.legajo, cargo_old.legajo);
if(cmp > 0) // Old es menor
{
fprintf(fp_fin, "%d|%s|%s\n", cargo_old.legajo, cargo_old.sucursal, cargo_old.codigo);
lect_old = leer_cargo_texto(&cargo_old, long_old, fp_old);
}else if(cmp == 0) // Mismo legajo
{
if(strcmp(cargo_new.codigo, cargo_old.codigo) == 0)
{
// Mismo cargo, se escribe uno (el viejo, por ejemplo)
fprintf(fp_fin, "%d|%s|%s\n", cargo_old.legajo, cargo_old.sucursal, cargo_old.codigo);
}
else
{
// Cargos diferentes: registrar ambos en error
fprintf(fp_error, "%d|%s|%s\n", cargo_old.legajo, cargo_old.sucursal, cargo_old.codigo);
fprintf(fp_error, "%d|%s|%s\n", cargo_new.legajo, cargo_new.sucursal, cargo_new.codigo);
}
lect_old = leer_cargo_texto(&cargo_old, long_old, fp_old);
lect_new = leer_cargo_texto(&cargo_new, long_new, fp_new);
}else if(cmp < 0) // New es menor
{
fprintf(fp_fin, "%d|%s|%s\n", cargo_new.legajo, cargo_new.sucursal, cargo_new.codigo);
lect_new = leer_cargo_texto(&cargo_new, long_new, fp_new);
}
}
// Restantes
while(lect_new)
{
fprintf(fp_fin, "%d|%s|%s\n", cargo_new.legajo, cargo_new.sucursal, cargo_new.codigo);
lect_new = leer_cargo_texto(&cargo_new, long_new, fp_new);
}
while(lect_old)
{
fprintf(fp_fin, "%d|%s|%s\n", cargo_old.legajo, cargo_old.sucursal, cargo_old.codigo);
lect_old = leer_cargo_texto(&cargo_old, long_old, fp_old);
}
fclose(fp_error);
fclose(fp_fin);
fclose(fp_new);
fclose(fp_old);
}
5. Frecuencia de Palabras en un Texto
Esta sección procesa un archivo de texto para encontrar las 10 palabras más frecuentes, utilizando memoria dinámica (heap) para almacenar las frecuencias.
Definición y Estructuras
#include <string.h>
#include <ctype.h>
#define MAX_PALABRA 30
#define TAM_BLOQUE 50 // Tamaño para el realloc (crecer de a bloques)
#define TOP_FRECUENCIA 10
#define MAX_LINEA 256
typedef struct
{
char palabra[MAX_PALABRA];
int contador;
} t_frecuencia;
Funciones de Conteo y Ordenamiento
int palabra_valida(const char *palabra_inicio, size_t longitud)
{
const char *p = palabra_inicio;
const char *p_fin = palabra_inicio + longitud;
// Aritmética de punteros para recorrer la subcadena
while (p < p_fin)
{
if (*p == '?')
{
return 0; // Inválida
}
p++;
}
return 1; // Válida
}
int cmp_frecuencias(const void a, const void b)
{
const t_frecuencia fa = (const t_frecuencia )a;
const t_frecuencia fb = (const t_frecuencia )b;
// Orden descendente (Mayor a menor)
return fb->contador - fa->contador;
}
void agregar_palabra(t_frecuencia *tabla, int ce, int capacidad, const char palabra)
{
// 1. Búsqueda secuencial (por aritmética de punteros)
for (int i = 0; i < *ce; i++)
{
// *(tabla) + i es la dirección del i-ésimo elemento.
if (strcmp( (*tabla + i)->palabra, palabra) == 0)
{
(*tabla + i)->contador++; // Palabra encontrada: incrementar
return;
}
}
// 2. Palabra no encontrada: Preparar para inserción
// Verificar si necesitamos redimensionar (Heap)
if (*ce >= *capacidad)
{
*capacidad += TAM_BLOQUE;
// Redimensionar el bloque de memoria
t_frecuencia *nuevo_tabla = (t_frecuencia*)realloc(*tabla, (*capacidad) * sizeof(t_frecuencia));
if (nuevo_tabla == NULL)
{
perror("Error de memoria (realloc)");
exit(EXIT_FAILURE);
}
*tabla = nuevo_tabla;
}
// 3. Inserción en el nuevo slot
t_frecuencia *nuevo_slot = (*tabla + *ce); // Aritmética de punteros
strcpy(nuevo_slot->palabra, palabra);
nuevo_slot->contador = 1;
(*ce)++; // Incrementar contador de elementos (palabras únicas)
}
void ordenar_e_imprimir_top(const t_frecuencia *tabla, int ce)
{
if (ce == 0)
{
printf("No se encontraron palabras válidas en el manuscrito.\n");
return;
}
// Usar qsort para ordenar el array dinámico (Heap)
// Se ordena solo el área utilizada (ce)
qsort((void *)tabla, ce, sizeof(t_frecuencia), cmp_frecuencias);
printf("\n--- TOP %d Palabras más Frecuentes ---\n", TOP_FRECUENCIA);
printf("Frecuencia | Palabra\n");
printf("--------------------------------\n");
int limite = (ce < TOP_FRECUENCIA) ? ce : TOP_FRECUENCIA;
for (int i = 0; i < limite; i++)
{
printf("%10d | %s\n", tabla[i].contador, tabla[i].palabra);
}
}
void procesar_manuscrito(const char archivo_nombre)
{
FILE fp;
char linea[MAX_LINEA];
// Estructuras de control para la tabla dinámica (Heap)
t_frecuencia *tabla_frecuencias = NULL;
int ce = 0; // Cantidad de Elementos (palabras únicas)
int capacidad = 0; // Capacidad total actual del bloque de memoria
// Buffer temporal para la palabra segmentada.
char palabra_temp[MAX_PALABRA];
fp = fopen(archivo_nombre, "rt");
if (fp == NULL)
{
perror("Error al abrir el archivo del Manuscrito");
return;
}
// Recorrido ÚNICO del archivo
while (fgets(linea, sizeof(linea), fp) != NULL)
{
char *p_inicio = linea;
while (*p_inicio != '\0')
{
// Buscar el delimitador '.'
char *p_delimitador = strchr(p_inicio, '.');
// Determinar la longitud de la palabra actual
size_t longitud;
if (p_delimitador == NULL)
{
// Última palabra de la línea
longitud = strlen(p_inicio);
} else
{
// Palabra delimitada por '.'
longitud = p_delimitador - p_inicio;
}
// Procesar la palabra
if (longitud > 0 && longitud < MAX_PALABRA)
{
// 1. Copiar al buffer temporal
strncpy(palabra_temp, p_inicio, longitud);
palabra_temp[longitud] = '\0'; // Asegurar el terminador nulo
// 2. Validación y Conteo
if (palabra_valida(palabra_temp, longitud))
{
agregar_palabra(&tabla_frecuencias, &ce, &capacidad, palabra_temp);
}
}
// 3. Avanzar al inicio de la siguiente palabra
if (p_delimitador == NULL)
{
break; // Llegamos al final de la línea
}
p_inicio = p_delimitador + 1; // Saltar el delimitador '.'
while (*p_inicio != '\0' && isspace(*p_inicio))
{
p_inicio++;
}
}
}
fclose(fp);
// 4. Reporte y Limpieza
ordenar_e_imprimir_top(tabla_frecuencias, ce);
// 5. Liberar memoria del Heap
free(tabla_frecuencias);
}
Funciones Auxiliares de Texto
/**
* Función Auxiliar: Lee una línea de texto de forma segura, eliminando el salto de línea.
* Retorna 1 si hay línea, 0 si es EOF.
*/
int leer_linea(FILE* fp, char* linea)
{
char *p_salto; // Declaración ANSI C
// Usamos fgets para evitar sobrepasar el límite garantizado
if (fgets(linea, MAX_LINEA_SALIDA, fp) == NULL)
{
return 0; // EOF
}
// --- CORRECCIÓN CRÍTICA: Eliminar el salto de línea para evitar problemas en el parser ---
p_salto = strchr(linea, '\n');
if (p_salto != NULL)
{
*p_salto = '\0';
}
// ------------------------------------------------------------------------------------------
return 1;
}
/**
PARSER ROBUSTO: Extrae una palabra usando aritmética de punteros.
Define una palabra como cualquier secuencia contigua de caracteres alfabéticos.
*/
int extraer_siguiente_palabra(char *p_linea, char destino)
{
char p_inicio_palabra;
char p_fin_palabra;
int longitud = 0;
// 1. Saltar delimitadores y espacios iniciales (usando isalpha)
while (p_linea != '\0' && !isalpha(p_linea))
{
(*p_linea)++; // Aritmética de punteros para avanzar
}
if (**p_linea == '\0')
{
return 0; // Fin de línea
}
// 2. Marcar el inicio y buscar el final de la palabra
p_inicio_palabra = p_linea;
p_fin_palabra = p_linea;
while (p_fin_palabra != '\0' && isalpha(p_fin_palabra))
{
p_fin_palabra++;
}
// 3. Calcular la longitud
longitud = (int)(p_fin_palabra - p_inicio_palabra);
// 4. Copiar la palabra (usando strncpy) y asegurar terminador nulo
if (longitud > 0)
{
// Copia hasta MAX_PALABRA_LARGO, aunque se garantiza que no supera 64
strncpy(destino, p_inicio_palabra, longitud);
destino[longitud] = '\0';
}
// 5. Actualizar el puntero de la línea para el siguiente llamado
*p_linea = p_fin_palabra;
return longitud;
}
/**
LÓGICA CLAVE: Inserta la nueva palabra en la posición correcta del TOP 15
(ordenado de mayor a menor longitud) y desplaza los elementos menores.
/
void insertar_en_top(t_palabra top_15, const char *palabra_nueva, int len_nueva)
{
int i;
int j;
// 1. FILTRO RÁPIDO: Si la nueva palabra es estrictamente más corta que la última, descartar.
if (len_nueva < top_15[TOP_15 - 1].longitud)
{
return;
}
// 2. Buscar la posición de inserción 'i' y verificar la unicidad
for (i = 0; i < TOP_15; i++)
{
// 2a. FILTRO DE UNICIDAD: Si la palabra ya existe, la descartamos.
if (top_15[i].longitud == len_nueva && strcmp(top_15[i].palabra, palabra_nueva) == 0)
{
return; // Palabra duplicada, descartar.
}
// 2b. BUSQUEDA DE POSICIÓN: Si la palabra nueva es más larga, esta es la posición 'i'.
if (len_nueva > top_15[i].longitud)
{
break; // Encontrada la posición 'i'
}
}
// 2c. DESCARTE: Si el bucle terminó sin encontrar una posición estrictamente mayor,
// significa que la palabra es de la misma longitud que la más corta del TOP y
// no es un duplicado, pero como el TOP ya está lleno, la descartamos.
if (i == TOP_15)
{
return;
}
// 3. DESPLAZAMIENTO: Desplazar los elementos menores hacia abajo (de 14 a i+1)
for (j = TOP_15 - 1; j > i; j--)
{
top_15[j] = top_15[j - 1]; // Copia de estructura
}
// 4. INSERCIÓN: Colocar la nueva palabra en la posición 'i'
top_15[i].longitud = len_nueva;
// Utilizamos memcpy y terminador manual para máxima robustez de memoria
memcpy(top_15[i].palabra, palabra_nueva, len_nueva);
top_15[i].palabra[len_nueva] = '\0';
}
/**
Reporte Final: Escribe el contenido del TOP 15 al archivo de salida.
/
void escribir_top15_a_archivo(FILE fp_salida, const t_palabra top_15)
{
// Uso de aritmética de punteros para recorrer el arreglo top_15
const t_palabra p_palabra = top_15;
fprintf(fp_salida, "--- TOP %d Palabras más Largas ---\n", TOP_15);
fprintf(fp_salida, "Longitud | Palabra\n");
fprintf(fp_salida, "--------------------------------\n");
for (int i = 0; i < TOP_15; i++)
{
// Imprimir solo si se encontró una palabra (longitud > 0)
if (p_palabra->longitud > 0)
{
fprintf(fp_salida, "%8d | %s\n", p_palabra->longitud, p_palabra->palabra);
}
p_palabra++; // Avanza al siguiente elemento del arreglo
}
}
6. Ordenamiento de Archivos Binarios (Selection Sort Externo)
Implementación de Selection Sort para ordenar un archivo binario sin cargarlo completamente en memoria, utilizando buffers auxiliares en el heap.
Estructura y Comparador
typedef struct
{
int clave;
char descripcion[30];
float valor;
} t_registro;
int cmp_registro_clave(const void r1, const void r2)
{
// Es crucial castear los void a la estructura de destino (t_registro)
const t_registro reg1 = (const t_registro )r1;
const t_registro reg2 = (const t_registro *)r2;
return reg1->clave - reg2->clave;
}
Funciones de Lectura/Escritura Genéricas
//Lee un elemento genérico de posición 'pos_elem' del archivo binario.
int f_leer(FILE *fp, void *destino, long pos_elem, size_t tam)
{
long desplazamiento = pos_elem * tam;
// Mover el puntero al inicio del elemento
if (fseek(fp, desplazamiento, SEEK_SET) != 0)
{
return 0; // Error de fseek
}
// Leer el elemento
if (fread(destino, tam, 1, fp) != 1)
{
return 0; // Error de lectura
}
return 1;
}
/**
Escribe un elemento genérico en la posición 'pos_elem' del archivo binario.
/
int f_escribir(FILE fp, const void origen, long pos_elem, size_t tam)
{
long desplazamiento = pos_elem tam;
// Mover el puntero al inicio del elemento
if (fseek(fp, desplazamiento, SEEK_SET) != 0)
{
return 0; // Error de fseek
}
// Escribir el elemento
if (fwrite(origen, tam, 1, fp) != 1)
{
return 0; // Error de escritura
}
return 1;
}
Implementación del Selection Sort Externo
int fselectionSort ( const char* archNom, size_t tam, int (*cmp) (const void*, const void*))
{
FILE *fp;
long tam_archivo;
long num_elementos;
long i, j, pos_minimo;
// Buffers auxiliares en el HEAP para manejar el tipo genérico de tamaño 'tam'
void *buffer_actual = malloc(tam); // Buffer para el elemento 'j'
void *buffer_minimo = malloc(tam); // Buffer para el elemento mínimo conocido
if (buffer_actual == NULL || buffer_minimo == NULL)
{
if (buffer_actual) free(buffer_actual);
if (buffer_minimo) free(buffer_minimo);
return 0; // Error de asignación de memoria
}
fp = fopen(archNom, "r+b");
if (!fp)
{
free(buffer_actual);
free(buffer_minimo);
return 0;
}
// 1. Obtener el número total de elementos
fseek(fp, 0, SEEK_END);
tam_archivo = ftell(fp);
num_elementos = tam_archivo / tam;
// Regresar el puntero al inicio
fseek(fp, 0, SEEK_SET);
// Bucle externo: i recorre el área desordenada
for (i = 0; i < num_elementos - 1; i++)
{
pos_minimo = i;
// 2. Leer el elemento 'i' y establecerlo como el mínimo inicial.
if (!f_leer(fp, buffer_minimo, i, tam)) continue;
// Bucle interno: Buscar el verdadero mínimo desde i + 1
for(j = i + 1; j < num_elementos; j++)
{
// 3. Leer el elemento 'j' de forma aleatoria.
if (!f_leer(fp, buffer_actual, j, tam)) continue;
// 4. Comparación Genérica: Usamos la función 'cmp' provista.
// Si cmp(actual, minimo) < 0, entonces el actual es menor.
if (cmp(buffer_actual, buffer_minimo) < 0)
{
// Encontrado un nuevo mínimo:
pos_minimo = j;
// Actualizar el contenido del buffer_minimo usando memcpy.
memcpy(buffer_minimo, buffer_actual, tam);
}
}
// 5. Intercambio Condicional
if (pos_minimo != i)
{
// A. Leer el elemento original de 'i' para no perderlo.
if (!f_leer(fp, buffer_actual, i, tam)) continue;
// B. Escribir el MÍNIMO (buffer_minimo) en la posición 'i'.
f_escribir(fp, buffer_minimo, i, tam);
// C. Escribir el ORIGINAL DE 'i' (buffer_actual) en el hueco 'pos_minimo'.
f_escribir(fp, buffer_actual, pos_minimo, tam);
}
}
// Limpieza
free(buffer_actual);
free(buffer_minimo);
fclose(fp);
return 1; // Éxito
}
7. Identificación de las Palabras Más Largas (Top 15)
Procesa un archivo de texto para encontrar las 15 palabras más largas, permitiendo repeticiones.
Estructuras y Constantes
#define MAX_LINEA_SALIDA 512
#define MAX_PALABRA_LARGO 64
#define TOP_15 15
typedef struct
{
char palabra[MAX_PALABRA_LARGO + 1];
int longitud;
}t_palabra;
Lógica de Inserción y Reporte
/**
* LÓGICA CLAVE: Inserta la nueva palabra en la posición correcta del TOP 15
* (ordenado de mayor a menor longitud) y desplaza los elementos menores.
*/
void insertar_en_top(t_palabra *top_15, const char *palabra_nueva, int len_nueva)
{
int i;
int j;
// 1. FILTRO RÁPIDO: Si la nueva palabra es estrictamente más corta que la última, descartar.
if (len_nueva < top_15[TOP_15 - 1].longitud)
{
return;
}
// 2. Buscar la posición de inserción 'i' y verificar la unicidad
for (i = 0; i < TOP_15; i++)
{
// 2a. FILTRO DE UNICIDAD: Si la palabra ya existe, la descartamos.
if (top_15[i].longitud == len_nueva && strcmp(top_15[i].palabra, palabra_nueva) == 0)
{
return; // Palabra duplicada, descartar.
}
// 2b. BUSQUEDA DE POSICIÓN: Si la palabra nueva es más larga, esta es la posición 'i'.
if (len_nueva > top_15[i].longitud)
{
break; // Encontrada la posición 'i'
}
}
// 2c. DESCARTE: Si el bucle terminó sin encontrar una posición estrictamente mayor,
// significa que la palabra es de la misma longitud que la más corta del TOP y
// no es un duplicado, pero como el TOP ya está lleno, la descartamos.
if (i == TOP_15)
{
return;
}
// 3. DESPLAZAMIENTO: Desplazar los elementos menores hacia abajo (de 14 a i+1)
for (j = TOP_15 - 1; j > i; j--)
{
top_15[j] = top_15[j - 1]; // Copia de estructura
}
// 4. INSERCIÓN: Colocar la nueva palabra en la posición 'i'
top_15[i].longitud = len_nueva;
// Utilizamos memcpy y terminador manual para máxima robustez de memoria
memcpy(top_15[i].palabra, palabra_nueva, len_nueva);
top_15[i].palabra[len_nueva] = '\0';
}
void palabrasMasLargasMIO(const char path_entrada, const char path_salida)
{
// --- Declaraciones ANSI C al inicio ---
FILE fp_entrada, fp_salida;
t_palabra top15_palabras[TOP_15];
char linea[MAX_LINEA_SALIDA];
char palabra_temp[MAX_PALABRA_LARGO + 1]; // Buffer para la palabra extraída
char *p_recorrido;
int lect;
int i;
int len_palabra; // Declaración de variables usadas en el bucle
fp_entrada = fopen(path_entrada,"rt");
if(!fp_entrada)
{
puts("Error al abrir el archivo de entrada...");
return;
}
fp_salida = fopen(path_salida,"wt"); // Corregido el modo de apertura a "wt"
if(!fp_salida)
{
puts("Error al abrir el archivo de salida...");
fclose(fp_entrada);
return;
}
// Inicialización del TOP 15
for(i = 0; i < TOP_15; i++)
{
top15_palabras[i].longitud = 0;
}
// Bucle de recorrido único
lect = leer_linea(fp_entrada, linea);
while(lect)
{
// El puntero de recorrido debe ser un puntero a char, inicializado al inicio de la línea.
p_recorrido = linea;
// Bucle Interno: Extrae palabras de la línea usando aritmética de punteros
while ((len_palabra = extraer_siguiente_palabra(&p_recorrido, palabra_temp)) > 0)
{
if (len_palabra > 0)
{
// La función clave que gestiona el ordenamiento y el descarte
insertar_en_top(top15_palabras, palabra_temp, len_palabra);
}
}
// Leer la siguiente línea
lect = leer_linea(fp_entrada, linea);
}
// 6. Reporte Final
escribir_top15_a_archivo(fp_salida, top15_palabras);
printf("Procesamiento completado. Resultado en: %s\n", path_salida);
// 7. Cierre de Archivos
fclose(fp_entrada);
fclose(fp_salida);
}
/**
Reporte Final: Escribe el contenido del TOP 15 al archivo de salida.
/
void escribir_top15_a_archivo(FILE fp_salida, const t_palabra top_15)
{
// Uso de aritmética de punteros para recorrer el arreglo top_15
const t_palabra p_palabra = top_15;
fprintf(fp_salida, "--- TOP %d Palabras más Largas ---\n", TOP_15);
fprintf(fp_salida, "Longitud | Palabra\n");
fprintf(fp_salida, "--------------------------------\n");
for (int i = 0; i < TOP_15; i++)
{
// Imprimir solo si se encontró una palabra (longitud > 0)
if (p_palabra->longitud > 0)
{
fprintf(fp_salida, "%8d | %s\n", p_palabra->longitud, p_palabra->palabra);
}
p_palabra++; // Avanza al siguiente elemento del arreglo
}
}
8. Fusión de Listados de Socios (Alternativa 2)
Este bloque implementa una fusión de socios (Club A binario vs Club B texto) generando cuatro archivos de salida basados en la pertenencia:
socios_en_ambos.txt(Todos los socios, con antigüedad máxima).socios_en_comun.txt(Solo socios compartidos).socios_solo_en_primero.txt(Solo socios del Club A).socios_nada_en_comun.txt(Socios exclusivos de A o B, equivalente a la unión menos la intersección).
Estructura y Comparadores
typedef struct {
int codigo_socio;
char nombre[50];
int anio_antiguedad; // Cuanto más bajo el año, mayor la antigüedad
} t_socio;
int cmp_socios (t_socio socio_1, t_socio socio_2)
{
if (socio_1->codigo_socio < socio_2->codigo_socio) {
return -1;
}
if (socio_1->codigo_socio > socio_2->codigo_socio) {
return 1;
}
return 0;
}
void armar_socio_resultante (t_socio socio_destino, t_socio socio_origen)
{
socio_destino->codigo_socio = socio_origen->codigo_socio;
strcpy(socio_destino->nombre, socio_origen->nombre);
socio_destino->anio_antiguedad = socio_origen->anio_antiguedad;
}
int leer_txt_socio_b (FILE arch, t_socio socio_b)
{
char linea[TAM_LINEA];
if(fgets(linea,TAM_LINEA,arch) == NULL) return 0;
// Limpieza de salto de línea
char *p_salto = strchr(linea, '\n');
if (p_salto) *p_salto = '\0';
if(sscanf(linea,"%d|%[^"]|%d", &socio_b->codigo_socio, socio_b->nombre, &socio_b->anio_antiguedad) == 3)
{
return 1;
}
return 0;
}
Función Principal de Fusión de Clubes (Alternativa 2)
void fusionar_clubes(const char *arch_a, const char *arch_b, const char *arch_ambos, const char *arch_comun, const char *arch_primero, const char *arch_nada, int (*cmp)(t_socio*, t_socio*))
{
FILE *fpa, *fpb, *fp_ambos, *fp_comun, *fp_primero, *fp_nada;
fpa = fopen(arch_a,"rb");
if(!fpa)
{
puts("Error al abrir el archivo de socios a...");
return;
}
fpb = fopen(arch_b,"rt");
if(!fpb)
{
perror("Error al abrir Socios_Club_B.txt");
fclose(fpa);
return;
}
fp_ambos = fopen(arch_ambos,"wt");
if(!fp_ambos)
{
puts("Error al abrir el archivo socios_en_ambos...");
fclose(fpa);
fclose(fpb);
return;
}
fp_comun = fopen(arch_comun,"wt");
if(!fp_comun)
{
puts("Error al abrir el archivo socios_en_comun...");
fclose(fpa);
fclose(fpb);
fclose(fp_ambos);
return;
}
fp_primero = fopen(arch_primero,"wt");
if(!fp_primero)
{
puts("Error al abrir el archivo socios_solo_en_primero...");
fclose(fpa);
fclose(fpb);
fclose(fp_ambos);
fclose(fp_comun);
return;
}
fp_nada = fopen(arch_nada,"wt");
if(!fp_nada)
{
puts("Error al abrir el archivo socios_nada_en_comun...");
fclose(fpa);
fclose(fpb);
fclose(fp_ambos);
fclose(fp_comun);
fclose(fp_primero);
return;
}
t_socio socio_a, socio_b, socio_r;
// Lectura inicial de A
if (fread(&socio_a,sizeof(t_socio),1,fpa) != 1) {
fclose(fpa); fclose(fpb); fclose(fp_ambos); fclose(fp_comun); fclose(fp_primero); fclose(fp_nada);
return;
}
int lect = leer_txt_socio_b(fpb, &socio_b);
int cmp_res;
while(!feof(fpa)&&lect)
{
cmp_res = cmp(&socio_a, &socio_b);
if(cmp_res == 1) // B es menor
{
armar_socio_resultante(&socio_r, &socio_b);
fprintf(fp_ambos,"%d|%s|%d\n", socio_r.codigo_socio, socio_r.nombre, socio_r.anio_antiguedad);
fprintf(fp_nada,"%d|%s|%d\n", socio_r.codigo_socio, socio_r.nombre, socio_r.anio_antiguedad);
lect = leer_txt_socio_b(fpb, &socio_b);
}
else if(cmp_res == 0) // Coincidencia
{
// Antigüedad: menor año significa mayor antigüedad
if(socio_a.anio_antiguedad < socio_b.anio_antiguedad)
armar_socio_resultante(&socio_r, &socio_a);
else
armar_socio_resultante(&socio_r, &socio_b);
fprintf(fp_ambos,"%d|%s|%d\n", socio_r.codigo_socio, socio_r.nombre, socio_r.anio_antiguedad);
fprintf(fp_comun,"%d|%s|%d\n", socio_r.codigo_socio, socio_r.nombre, socio_r.anio_antiguedad);
fread(&socio_a,sizeof(t_socio),1,fpa);
lect = leer_txt_socio_b(fpb, &socio_b);
}
else if(cmp_res == -1) // A es menor
{
armar_socio_resultante(&socio_r, &socio_a);
fprintf(fp_primero,"%d|%s|%d\n", socio_r.codigo_socio, socio_r.nombre, socio_r.anio_antiguedad);
fprintf(fp_ambos,"%d|%s|%d\n", socio_r.codigo_socio, socio_r.nombre, socio_r.anio_antiguedad);
fprintf(fp_nada,"%d|%s|%d\n", socio_r.codigo_socio, socio_r.nombre, socio_r.anio_antiguedad);
fread(&socio_a,sizeof(t_socio),1,fpa);
}
}
// Restantes de A
while(!feof(fpa))
{
armar_socio_resultante(&socio_r, &socio_a);
fprintf(fp_ambos,"%d|%s|%d\n", socio_r.codigo_socio, socio_r.nombre, socio_r.anio_antiguedad);
fprintf(fp_primero,"%d|%s|%d\n", socio_r.codigo_socio, socio_r.nombre, socio_r.anio_antiguedad);
fprintf(fp_nada,"%d|%s|%d\n", socio_r.codigo_socio, socio_r.nombre, socio_r.anio_antiguedad);
if (fread(&socio_a,sizeof(t_socio),1,fpa) != 1) break;
}
// Restantes de B
while(lect)
{
armar_socio_resultante(&socio_r, &socio_b);
fprintf(fp_ambos,"%d|%s|%d\n", socio_r.codigo_socio, socio_r.nombre, socio_r.anio_antiguedad);
fprintf(fp_nada,"%d|%s|%d\n", socio_r.codigo_socio, socio_r.nombre, socio_r.anio_antiguedad);
lect = leer_txt_socio_b(fpb, &socio_b);
}
fclose(fpa);
fclose(fpb);
fclose(fp_ambos);
fclose(fp_comun);
fclose(fp_nada);
fclose(fp_primero);
}