Les dejo el "primer" parcial que nos tomaron, les adjunto el enunciado xd.
Parece largo pero lo documente todo así lo pueden separar si quieren
Global.h
/**
* \file global.h
* \brief Prototipos de funciones de convertir.c - dividir.c - imprimir.c - ingreso.c - limpiar.c
* \brief main.c - ocurrencias.c - ordenamiento.c
* \author
* \date 2011.09.22
* \version 1.0.0
*/
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<errno.h>
//defines
#define MAX_PAL 32
#define CANT_PAL 1024
#define FALSE 1
#define TRUE 0
//----------------
//-- Prototipos --
//----------------
struct OCURRENCIA_S{
int cant;
char palabra[MAX_PAL+1];
};
int ingreso(void);
void dividir(char *texto,int *posicion,char* palabras);
void limpiar(char *palabras);
void ocurrencias(char *palabra, struct OCURRENCIA_S *contenido,int *cantpalabras);
void imprimir(struct OCURRENCIA_S *contenido,int cantpalabras, int cant_carac, int cant_palabras);
void ordenamiento(struct OCURRENCIA_S *contenido,int cantpalabras);
void strlwr(char *cadena);
Funciones (cada una en un .c distinto xd)
/**
* \file main.c
* \brief Contiene funciones que realizan operaciones matematicas
* \author
* \date 2011.09.22
* \version 1.0.0
*/
//--------------
//-- Includes --
//--------------
#include "global.h"
/**
\ **fn int main (void)*
\brief Llama a ingreso.
\author
\date 2011.09.22
\return La función retorna 0.
*/
int main (void){
system("clear");
puts("\r\n"
"****************************************************************\r\n"
"* *\r\n"
"* Primer Parcial Informatica I *\r\n"
"* *\r\n"
"****************************************************************\r\n");
ingreso();
return (0);
}
/**
* \file convertir.c
* \brief Contiene función que convierte a minúsculas.
* \author
* \date 2011.09.22
* \version 1.0.0
*/
//--------------
//-- Includes --
//--------------
#include "global.h"
/**
\ *fn void strlwr(char *cadena)*
\brief Convierte una cadena de caracteres a minúsculas.
\author
\date 2011.09.22
\param cadena Texto a convertir.
\return La función no retorna.
*/
void strlwr(char *cadena){
int i, len;
len = strlen(cadena);
for(i=0; i< len; i++)
if( *(cadena + i)>='A' && *(cadena + i) <= 'Z') *(cadena + i ) += 'a' -'A';
}
/**
* \file dividir.c
* \brief Contiene la funcion que divide el texto en palabras.
* \author
* \date 2011.09.22
* \version 1.0.0
*/
//--------------
//-- Includes --
//--------------
#include "global.h"
/**
\ **fn int dividir(char *texto,int com_pal,char* palabras)
\brief Función que obtiene palabras a partir del texto
\author
\date 2011.09.22
\param texto Fragmento ingresado por teclado.
\param com_pal Posición actual en el texto ingresado
\param palabras es utilizada para devolver por referencia la palabra apartada del texto.
\return Retorna la posicion de inicio de la siguiente palabra.
*/
void dividir(char *texto,int *posicion,char* palabras){
int j;
int cont=0;
limpiar(palabras);
for(j=*posicion;j <((*posicion)+MAX_PAL);j++){
if((*(texto+j) != ' ')&&(*(texto+j)!=0)&&(*(texto+j)!='\n')&&(*(texto+j)!='\r')){
if((96 <*(texto+j))&&(*(texto+j)< 123)){
*(palabras+cont) = *(texto+j);
cont++;
}
}
else{
*posicion = j+1;
break;
}
}
*posicion = j+1;
}
/**
* \file imprimir.c
* \brief Contiene funciones que realizan operaciones matematicas
* \author
* \date 2011.09.22
* \version 1.0.0
*/
//--------------
//-- Includes --
//--------------
#include "global.h"
/**
\ **fn void imprimir(struct OCURRENCIA_S *contenido,int cantpalabras,int cant_carac)*
\brief Imprime estadisticas.
\author
\date 2011.09.22
\param contenido Vector de estructuras contenedoras de palabras y cantidad de las mismas.
\param cantpalabras cantidad de palabras distintas.
\param cant_carac cantidad de caracteres ingresados por teclado.
\return La función no retorna.
*/
void imprimir(struct OCURRENCIA_S *contenido,int cantpalabras,int cant_carac,int cant_palabras){
int i;
int j=0;
system("clear");
puts("\r\n"
"****************************************************************\r\n"
"* *\r\n"
"* EStadisticas Generales *\r\n"
"* *\r\n"
"****************************************************************\r\n");
printf("\tCantidad de palabras ingresadas: %d\r\n",cant_palabras);
printf("\tCantidad de caracteres ingresados: %d\r\n",cant_carac);
printf("\tCantidad de palabras ingresadas(distintas): %d\r\n", cantpalabras);
ordenamiento(contenido, cantpalabras);
printf("\tPalabra con mayor ocurrencia: %s\r\n",contenido->palabra);
printf("\tPalabra con menor ocurrencia: %s\r\n",(contenido+cantpalabras - 1)->palabra);
for(i=0;i<cantpalabras;i++){
printf("\tPalabra: %s\tCantidad que aparece: %d\n",(contenido+i)->palabra,(contenido+i)->cant);
j += (contenido+i)->cant;
}
printf("\r\n\n\t\tFIN DEL PROGRAMA\r\n\n");
}
/**
* \file ingreso.c
* \brief Contiene funciones que realizan operaciones matematicas
* \author
* \date 2011.09.22
* \version 1.0.0
*/
//--------------
//-- Includes --
//--------------
#include "global.h"
/**
\ **fn void ingreso(void)*
\brief Ingreso del texto y distribución de procesados.
\author
\date 2011.09.22
\return La función no retorna.
*/
int ingreso(void){
char *texto=NULL;
char palabras[MAX_PAL+1];
int cmax;
int posicion=0;
int cantpalabras=0;
int cant_palabras=-1;
int cant_carac=0;
struct OCURRENCIA_S *contenido = NULL;
do{
puts("Ingrese la cantidad de caracteres maximos a ingresar: ");
scanf("%d",&cmax);
if((cmax<0)||(cmax>32768)){
puts("\t~ Por favor ingrese un numero mayor a 0 y menor a 32768 ~\r\n");
}
}while((cmax<0)||(cmax>32768));
getchar();
texto = (char*) malloc(cmax);
if(texto==NULL){
printf("%d",errno);
return(-1);
}
contenido=(struct OCURRENCIA_S*) calloc(MAX_PAL,sizeof(struct OCURRENCIA_S));
if(contenido==NULL){
printf("%d",errno);
return(-1);
}
do{
puts("Ingrese texto: ");
fgets(texto,cmax,stdin);
cant_carac = cant_carac + strlen(texto)-1;
strlwr(texto);
do{
dividir(texto,&posicion,palabras);
cant_palabras++;
ocurrencias(palabras, contenido,&cantpalabras);
}while(posicion < strlen(texto));
posicion = 0;
}while(*texto != '\n');
imprimir(contenido,cantpalabras,cant_carac,cant_palabras);
free(texto);
free(contenido);
return(0);
}
/**
* \file limpiar.c
* \brief Contiene funciones que realizan operaciones matematicas
* \author
* \date 2011.09.22
* \version 1.0.0
*/
//--------------
//-- Includes --
//--------------
#include "global.h"
/**
\ **fn void limpiar(char *palabras)*
\brief Limpia el vector donde se aloja cada palabra que se separa del texto.
\author
\date 2011.09.22
\param palabras Vector donde se guarda la palabra que se separa del texto.
\return La función no retorna.
*/
void limpiar(char *palabras){
int i;
for(i=0;i<MAX_PAL+1;i++)
*(palabras+i)=0;
}
/**
* \file ocurrencias.c
* \brief Contiene funciones que realizan operaciones matematicas
* \author
* \date 2011.09.22
* \version 1.0.0
*/
//--------------
//-- Includes --
//--------------
#include "global.h"
/**
\ **fn int ocurrencias(char *palabra, struct OCURRENCIA_S *contenido,int cantpalabras)*
\brief Función encargada de llevar la cantidad de palabras ingresadas iguales.
\author
\date 2011.09.22
\param palabra Palabra separada del texto para ser procesada
\param contenido Vector de estructuras contenedoras de palabras y cantidad de las mismas.
\param cantpalabras Cantidad de palabras ingresadas distintas.
\return La función retorna la cantidad de palabras distintas.
*/
void ocurrencias(char *palabra, struct OCURRENCIA_S *contenido,int *cantpalabras){
int i;
int flag=1;
int validacion;
for(i=0;i< CANT_PAL; i++){
validacion = strcmp(palabra,(contenido+i)->palabra);
if(validacion==0){
(contenido+i)->cant++;
flag = TRUE;
break;
}
else{
flag = FALSE;
}
}
if(flag){
strcpy((contenido+(*cantpalabras))->palabra,palabra);
(contenido + (*cantpalabras))->cant++;
*cantpalabras= *cantpalabras+1;
}
}
/**
* \file ordenamiento.c
* \brief Contiene funciones que realizan operaciones matematicas
* \author
* \date 2011.09.22
* \version 1.0.0
*/
//--------------
//-- Includes --
//--------------
#include "global.h"
/**
\ **fn void ordenamiento(struct OCURRENCIA_S *contenido,int cantpalabras)*
\brief Ordena las palabras según orden de ocurrencias.
\author
\date 2011.09.22
\param contenido Vector de estructuras contenedoras de palabras y cantidad de las mismas.
\param cantpalabras Cantidad de palabras ingresadas distintas.
\return La función no retorna.
*/
void ordenamiento(struct OCURRENCIA_S *contenido,int cantpalabras){
int i,j;
struct OCURRENCIA_S aux;
for(i=0;i<(cantpalabras-1);i++){
for(j=i+1;j<cantpalabras;j++){
if((contenido+i)->cant<(contenido+j)->cant){
aux.cant = (contenido+i)->cant;
(contenido+i)->cant = (contenido+j)->cant;
(contenido+j)->cant=aux.cant;
strcpy(aux.palabra,(contenido+i)->palabra);
strcpy((contenido+i)->palabra,(contenido+j)->palabra);
strcpy((contenido+j)->palabra,aux.palabra);
}
}
}
}
![[-]](images/collapse.gif)
Feer recibio 2 Gracias por este post
