Acá van mis soluciones para los ejercicios de informática electrónica práctica 3.
Todas las soluciones fueron implementadas usando 4.4.3
AVISO: No me siento exactamente muy alegre con todas las soluciones 😉
Ejercicio 2:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct Indice Indice;
char ** oraciones;
long int cant_oraciones;
long int tam_oraciones;
char acumulador[256];
void agregarPalabra(char *palabra){
if ( cant_oraciones == tam_oraciones ){
// agrandar Buffer
if (tam_oraciones)
tam_oraciones = tam_oraciones << 2; // multiplicar por 2 tamaño
else
tam_oraciones = 1;
oraciones = realloc(oraciones, sizeof(char **) * tam_oraciones);
};
oraciones[cant_oraciones]=strdup(palabra);
cant_oraciones++;
}
int main(void){
char buffer[1000]; // buffer de lectura
char ** puntero;
int len = 0;
int i = 0;
char car;
printf("Ingrese texto, presione enter para terminar\n");
printf("Una linéa vacia o EOF se considera fin\n");
while (1){
printf("> ");
gets(buffer);//buffer, sizeof(buffer), stdin); // leer entrada
len = strlen(buffer);
if (len==0 || buffer[0]=='\n'){
printf("FIN\n");
break;
}
for (i=0; i<len; i++){
car = buffer[i] & 0xff; // limitar a ASCII de 8 bits
acumulador[(int)(car&0x00ff)]+=1;
}
agregarPalabra(buffer);
}
i = 0;
puntero=oraciones;
if (!puntero)
return 0;
while (i < cant_oraciones){
printf("%i: %s\n", i+1, *puntero);
i++;
puntero++;
}
for (i=0; i<255; i++){
car = (char) i & 0xff;
if (acumulador[i]==0)
continue;
printf("%c\t%0X:\t%i\n", car, 0xff&car, acumulador[i]);
}
return 0;
}
Ejercicio 3:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
char ** frases=0;
int * ocurrencias=0;
int cant_frases=0;
int espacio_reservado=0;
void agregar(const char * frase){
int i;
// primero verificar si la conocemos
for ( i = 0; i < cant_frases; i++){
if (strcmp(frase, frases[i]) == 0)
{
ocurrencias[i]+=1;
return;
}
}
// ok no la conocemos a agregarla a la lista.
if ( i == espacio_reservado){
// crecimiento exponencial del consumo de memoria
if (espacio_reservado)
espacio_reservado=espacio_reservado<<1;
else
espacio_reservado=2;
printf("realloc para %i elementos\n", espacio_reservado);
frases = realloc(frases, sizeof(char*)*espacio_reservado);
ocurrencias = realloc(ocurrencias, sizeof(int)*espacio_reservado);
}
frases[i] = strdup(frase);
ocurrencias[i] = 1;
cant_frases+=1;
}
int leerPalabra(char * buffer){
char c;
while ( 1 ){
c = getchar();
if ( isspace(c) || ispunct(c) || c==0 ){
*buffer=0;
return 0;
}
if (c==EOF){
*buffer=0;
return 1;
}
*buffer = c;
buffer++;
}
}
void ordenar(){
int i, j;
char * tempc;
int tempi;
int test; /* permite saber si esta terminado */
for(i = cant_frases - 1; i > 0; i--)
{
test=0;
for(j = 0; j < i; j++)
{
if(strcmp(frases[j], frases[j+1]) > 0)
/* comparar elementos vecinos */
{
tempc = frases[j]; /* intercambiar elementos*/
frases[j] = frases[j+1];
frases[j+1] = tempc;
tempi = ocurrencias[j]; /* intercambiar elementos*/
ocurrencias[j] = ocurrencias[j+1];
ocurrencias[j+1] = tempi;
test=1;
}
} /*end for j*/
if(test==0) break; /*will exit if the list is sorted!*/
} /*end for i*/
}
int main(void){
char buffer[1000]; // buffer de lectura
char c;
int len, i;
printf("Ingrese palabras, EOF para terminar\n");
while (1){
i = leerPalabra(&buffer);
len = strlen(buffer);
printf ("%s\n", buffer);
if (len > 0){
agregar(buffer);
continue;
}
if (i==1){
printf("FIN\n");
break;
}
}
printf("SIN ORDENAR\n");
for (i=0; i<cant_frases; i++){
printf("%s: %i\n", frases[i], ocurrencias[i]);
}
printf("\n\n");
printf("ORDENADO\n");
ordenar();
for (i=0; i<cant_frases; i++){
printf("%s: %i\n", frases[i], ocurrencias[i]);
}
return 0;
}
Ejercicio 4:
Similar al 3 pero con estructuras!
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
typedef struct Frase Frase;
struct Frase{
char * frase;
int ocurrencias;
};
Frase * frases=0;
int cant_frases=0;
int espacio_reservado=0;
void agregar(const char * frase){
int i;
// primero verificar si la conocemos
for ( i = 0; i < cant_frases; i++){
if (strcmp(frase, frases[i].frase) == 0)
{
frases[i].ocurrencias+=1;
return;
}
}
// ok no la conocemos a agregarla a la lista.
if ( i == espacio_reservado){
// crecimiento exponencial del consumo de memoria
if (espacio_reservado)
espacio_reservado=espacio_reservado<<1;
else
espacio_reservado=2;
printf("realloc para %i elementos\n", espacio_reservado);
frases = realloc(frases, sizeof(Frase)*espacio_reservado);
}
frases[i].frase = strdup(frase);
frases[i].ocurrencias = 1;
cant_frases+=1;
}
int leerPalabra(char * buffer){
char c;
while ( 1 ){
c = getchar();
if ( isspace(c) || ispunct(c) || c==0 ){
*buffer=0;
return 0;
}
if (c==EOF){
*buffer=0;
return 1;
}
*buffer = c;
buffer++;
}
}
void ordenar(){
int i, j;
Frase temp;
int test; /* permite saber si esta terminado */
for(i = cant_frases - 1; i > 0; i--)
{
test=0;
for(j = 0; j < i; j++)
{
if(strcmp(frases[j].frase, frases[j+1].frase) > 0)
/* comparar elementos vecinos */
{
temp = frases[j]; /* intercambiar elementos*/
frases[j] = frases[j+1];
frases[j+1] = temp;
test=1;
}
} /*end for j*/
if(test==0) break; /*will exit if the list is sorted!*/
} /*end for i*/
}
int main(void){
char buffer[1000]; // buffer de lectura
int len, i;
printf("Ingrese palabras, EOF para terminar\n");
while (1){
i = leerPalabra(&buffer);
len = strlen(buffer);
printf ("%s\n", buffer);
if (len > 0){
agregar(buffer);
continue;
}
if (i==1){
printf("FIN\n");
break;
}
}
printf("SIN ORDENAR\n");
for (i=0; i<cant_frases; i++){
printf("%s: %i\n", frases[i].frase, frases[i].ocurrencias);
}
printf("\n\n");
printf("ORDENADO\n");
ordenar();
for (i=0; i<cant_frases; i++){
printf("%s: %i\n", frases[i].frase, frases[i].ocurrencias);
}
return 0;
}
Ejercicio 5:
Usando lista enlazada, ordenando al momento de cargar, cómo me gusta las estructuras es lo más semejante que conozco a las estructuras de python :D.
Si me preguntan la forma más eficiente de hacerlo, sobre todo con MUCHOS datos!
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
typedef struct Frase Frase;
struct Frase{
char * frase;
int ocurrencias;
Frase * proxima;
};
Frase * inicio=0;
void agregar(const char * frase){
int i;
Frase * puntero = inicio;
Frase * previo = 0; //estupido C no inicializa en 0, sin esto tira verdura!
Frase * nueva;
printf("agregando %s\n", frase);
// primero verificar si la conocemos
while ( puntero ){
i = strcmp(frase, puntero->frase);
if ( i == 0 )
// la encontramos
{
printf("conocida sumando\n");
puntero->ocurrencias+=1;
return;
} else
if (i < 0){
// estamos metiendo una nueva frase que es mayor a la última
// que estabamos mostrando, entonces podemos insertar de forma
// ordenada
nueva = malloc(sizeof(Frase));
nueva->frase = strdup(frase);
nueva->ocurrencias = 1;
nueva->proxima = puntero;
if (previo){
previo->proxima = nueva;
printf("agreagando entre %s y %s\n", previo->frase, puntero->frase);
}
else {
inicio = nueva;
printf("a la cabeza\n");
}
return;
}
previo = puntero;
if (puntero->proxima==NULL)
break;
puntero = puntero->proxima;
}
// puntero apunta a la última frase
// no la conocemos a agregarla a la lista al final.
printf("agregando al final\n");
nueva = malloc(sizeof(Frase));
nueva->frase = strdup(frase);
nueva->ocurrencias = 1;
nueva->proxima = 0;
if (puntero){
printf("agregando luego de %s\n", puntero->frase);
puntero->proxima = nueva;
}
if (!inicio){
printf("inicio de la lista\n");
inicio = nueva;
}
}
int leerPalabra(char * buffer){
char c;
while ( 1 ){
c = getchar();
if ( isspace(c) || ispunct(c) || c==0 ){
*buffer=0;
return 0;
}
if (c==EOF){
*buffer=0;
return 1;
}
*buffer = c;
buffer++;
}
}
int main(void){
char buffer[1000]; // buffer de lectura
int len, i;
Frase * puntero;
printf("Ingrese palabras, EOF para terminar\n");
while (1){
i = leerPalabra(&buffer);
len = strlen(buffer);
printf ("%s\n", buffer);
if (len > 0){
agregar(buffer);
continue;
}
if (i==1){
printf("FIN\n");
break;
}
}
printf("ORDENADA\n");
puntero = inicio;
while (puntero){
printf("%s: %i\n", puntero->frase, puntero->ocurrencias);
puntero = puntero->proxima;
}
return 0;
}
Ejercicio 6:
Si me preguntan no sé quién escribió un código tan feo, es cómo rascarse la oreja izquierda con la mano derecha, igualmente lo corregí para compilar en GCC.
#include <stdlib.h>
#include <stdio.h>
void main () {
int *vector, *matriz, *resultado;
int i,j, nCol, *pi, *pm, *pr;
srand48 (time(NULL));
printf("Introduce el numero de columnas del vector/matriz: ");
scanf("%d",&nCol);
/* Asignamos memoria para vectores y matrices */
vector = malloc(sizeof(int)*nCol);
matriz = malloc(sizeof(int)*nCol*nCol);
resultado = malloc(sizeof(int)*nCol);
if(vector == NULL || matriz == NULL || resultado == NULL){
printf("\nError en la memoria");
return;
}
printf("\nLa memoria asignada es: ");
printf("$\n%10s%10s%10s%10s", "Area","Inicio","Largo","Ultima");
printf("\n%10s%10x%10d%10x", "Vector", vector, sizeof(int)*nCol, vector+nCol);
pm=matriz+nCol*nCol;
printf("\n%10s%10x%10d%10x", "Matriz", matriz, sizeof(int)*nCol*nCol, pm);
pi=resultado;
pm=resultado+nCol;
printf("\n%10s%10x%10d%10x", "Resultado", pi, pm - resultado, pm);
/* "Introduce valores para el vector: "; */
printf("\n\nEl vector es:\n");
/*for (i=0, pi=vector; i<nCol; i++, pi++){*/
for (pi=vector, pm=(vector+nCol); pi<pm; pi++){
*pi = (int) (drand48() * 10);
printf("%10d", *pi);
}
/* "Introduce valores para la fila " */
printf("\n\nLa matriz es:\n");
for (i=0,pi=matriz, pm=(matriz+nCol*nCol); pi<pm; pi++, i++){
*pi = (int) (drand48() * 10);;
printf("%10d", *pi);
if((i+1)%nCol==0)
printf("\n");
}
/* Multiplicando */
printf("\n\nOperaciones realizadas:\n");
pi=vector;
pm=matriz;
pr=resultado;
for (i=0; i<nCol; i++, pi++, pr++) {
*pr = 0;
for ( j=0; j<nCol; j++, pm++) {
*pr += *pi * *pm;
printf("%5d*%-4d", *pi,*pm);
}
printf("= %d\n", *pr);
}
printf("\nEl resultado es: \n");
for (i=0,pi=resultado; i<nCol; i++, pi++)
printf("%10d", *pi);
printf("\n");
}
Ejercicio 7
Haciendo el acceso a matrices un poco más coherentes.
#include <stdlib.h>
#include <stdio.h>
int main (void) {
int *matriz1, *matriz2, *resultado;
int i,j, k, nCol1, nFil1, nCol2, nFil2, *pi, *pm, *pr;
srand48 (time(NULL));
printf("Introduce el numero de columnas y filas de la matriz 1 (separadas con espacios): ");
scanf("%d %d",&nCol1, &nFil1);
printf("Introduce el numero de columnas y filas de la matriz 2 (separadas con espacios): ");
scanf("%d %d",&nCol2, &nFil2);
if (nCol1 != nFil2){
printf("Tamaños de matrices incompatibles\n");
return 1;
}
matriz1 = malloc(sizeof(int)*nCol1*nFil1);
matriz2 = malloc(sizeof(int)*nCol2*nFil2);
resultado = malloc(sizeof(int)*nCol2*nFil1);
if(matriz1 == NULL || matriz2 == NULL || resultado == NULL){
printf("\nError en la memoria");
return 1;
}
printf("\nLa memoria asignada es: ");
printf("$\n%10s%10s%10s%10s", "Area","Inicio","Largo","Ultima");
printf("\n%10s%10x%10d%10x", "Matriz1", matriz1, sizeof(int)*nCol1*nFil1, matriz2-1);
printf("\n%10s%10x%10d%10x", "Matriz2", matriz2, sizeof(int)*nCol2*nFil2, resultado-1);
printf("\n%10s%10x%10d%10x", "Resultado", resultado, sizeof(int)*nFil1*nCol2, resultado+(nCol1*nFil2));
printf("\n\nLa matriz 1 es:\n");
pi=matriz1;
for (i=0; i<nFil1; i++){
for (j=0; j<nCol1; j++){
*(pi+i*nCol1+j) = (int) (drand48() * 10);
printf("%10d", *(pi+i*nCol1+j));
};
printf("\n");
};
printf("\n\nLa matriz 2 es:\n");
pi=matriz2;
for (i=0; i<nFil2; i++){
for (j=0; j<nCol2; j++){
*(pi+i*nCol2+j) = (int) (drand48() * 10);
printf("%10d", *(pi+i*nCol2+j));
};
printf("\n");
};
printf("\n\nOperaciones realizadas:\n");
pi=matriz1;
pm=matriz2;
pr=resultado;
for(i=0; i<nFil1; i++){
for(j=0; j<nCol2; j++){
for(k=0; k<nCol1; k++){
*(pr+i*nCol2+j)+=*(pi+i*nCol1+k) * *(pm+k*nCol2+j);
printf("%5d*%-4d", *(pi+i*nCol1+k), *(pm+k*nCol2+j));
}
printf("= %d\n", *(pr+i*nCol2+j));
}
}
pi = resultado;
printf("\nEl resultado es: \n");
for (i=0; i<nCol2; i++){
for (j=0; j<nFil1; j++){
printf("%10d", *(pi+i*nFil1+j));
}
printf("\n");
}
printf("\n");
}
Ejercicio 9:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
typedef struct Articulo Articulo;
struct Articulo{
long int id;
char * nombre;
double precio;
long int cantidad;
};
Articulo * articulos;
long int cantidad_articulos=0;
long int capacidad_memoria=0;
void agregar(Articulo * art){
int i;
for (i=0; i<cantidad_articulos; i++){
if (articulos[i].id==art->id){
printf("ID repetido, no se agrega\n");
return;
}
}
if ( capacidad_memoria == cantidad_articulos ){
if ( ! capacidad_memoria )
capacidad_memoria = 2;
else
capacidad_memoria = capacidad_memoria << 1;
articulos = realloc(articulos, sizeof(Articulo)*capacidad_memoria);
}
articulos[cantidad_articulos] = *art;
cantidad_articulos+=1;
}
int main(void){
Articulo art, *temp;
long int id, cantidad;
double precio;
char buffer[1000];
int i;
printf("Ingrese id, nombre, precio, cantidad. EOF para terminar\n");
while (1){
if (scanf(
"%ld %s %lf %ld",
&(id),
&(buffer),
&(precio),
&(cantidad)
)!=4){
printf("FIN\n");
break;
}
temp=malloc(sizeof(Articulo));
if (temp==NULL){
printf("Error de memoria\n");
break;
}
temp->id = id;
temp->nombre = strdup(buffer);
temp->precio = precio;
temp->cantidad = cantidad;
agregar(temp);
}
printf("ID\t\tNombre\t\tPrecio\t\tCantidad\t\tCosto Stock\n");
for (i = 0; i < cantidad_articulos; i++){
*temp = articulos[i];
printf("%li\t\t%s\t\t%.2lf\t\t%li\t\t\t%.2lf\n",
temp->id,
temp->nombre,
temp->precio,
temp->cantidad,
temp->precio * temp->cantidad);
}
return 0;
}
Ejercicio 9:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
typedef struct Sensor Sensor;
typedef struct Medicion Medicion;
struct Medicion{
double valor;
Medicion * proxima;
Medicion * previa;
};
struct Sensor{
char id[3];
Medicion * primera;
Medicion * ultima;
double prom_50;
double prom_25;
double prom_5;
};
Sensor * sensores;
long int cantidad_sensores=0;
long int capacidad_memoria=0;
Sensor* getSensor(char* id){
int i;
for (i=0; i<cantidad_sensores; i++){
if (strcmp(sensores[i].id, id)==0){
return &sensores[i];
}
}
if ( capacidad_memoria == cantidad_sensores ){
if ( ! capacidad_memoria )
capacidad_memoria = 2;
else
capacidad_memoria = capacidad_memoria << 1;
sensores = realloc(sensores, sizeof(Sensor)*capacidad_memoria);
}
sensores[cantidad_sensores].id[0]=id[0];
sensores[cantidad_sensores].id[1]=id[1];
sensores[cantidad_sensores].id[2]=id[2];
sensores[cantidad_sensores].primera = NULL;
cantidad_sensores+=1;
printf("Nuevo ID %s\n", id);
return &sensores[cantidad_sensores-1];
}
void agregarMedicion(char* id, double value){
int i = 0;
Sensor * sensor = getSensor(id);
Medicion * puntero = sensor->primera;
Medicion * temp;
double acu;
while ( puntero ) { // ir hasta cola de sensado
i++;
printf("%.2lf\n", puntero->valor);
puntero = puntero->proxima;
}
printf("Se conocen %d lecturas\n", i);
if (i > 49){
printf("Se tienen más de 50 lecturas, sacando: %d\n", 50-i+1);
temp = sensor->ultima;
for ( i = 0; i < 49; i++ ){
if (temp->previa) // proteger por seg faults
temp = temp->previa;
else
break;
}
sensor->primera=temp;
}
temp = malloc(sizeof(Medicion));
temp->valor = value;
temp->previa = sensor->ultima;
if ( sensor->primera == NULL)
sensor->primera = temp;
if (sensor->ultima)
sensor->ultima->proxima=temp;
sensor->ultima = temp;
// verificar últimas 5 mediciones
acu = 0;
for (i = 0, temp=sensor->ultima; i<5; i++){
if (temp)
acu+=temp->valor;
else
break;
temp=temp->previa;
}
sensor->prom_5 = acu/i; // promediar
// verificar últimas 25 mediciones
acu = 0;
for (i = 0, temp=sensor->ultima; i < 25; i++){
if (temp)
acu+=temp->valor;
else
break;
temp = temp->previa;
}
sensor->prom_25 = acu/i; // promediar
// verificar últimas 50 mediciones
acu = 0;
for (i = 0, temp=sensor->ultima; i < 50; i++){
if (temp)
acu+=temp->valor;
else
break;
temp = temp->previa;
}
sensor->prom_50 = acu/i; // promediar
printf("Sensor: %s, Promedios: %.2lf %.2lf %.2lf\n",
sensor->id,
sensor->prom_5,
sensor->prom_25,
sensor->prom_50);
}
int main(void){
char id[1000];
double medicion;
int i;
printf("Ingrese id, medicion\n");
while (1){
scanf("%s %lf", &id, &medicion);
if (strlen(id)==0)
break;
agregarMedicion(id, medicion);
id[0]=0;
}
return 0;
}
