PRACTICA DIVIS

#define _CRT_SECURE_NO_DEPRECATE
#include <stdio.h>
#include <stdlib.h>

int main() {
int max, num, resto;

printf("Este programa imprime los numeros divisibles\n");

printf("por 7 menores que numero dado.\n\n");

printf("Introduzca el numero:");
scanf("%d", &max);

if (max <= 0) {
printf("El numero debe ser positivo!!\n");
}
else {
for (num = 1; num <= max; num++) {
resto = num % 7;

if (resto == 0) {
printf("%d es divisible por 7\n", num);
}
}
}

system("pause");
return 0;
}
 PRACTICA 1
#include <stdio.h>
#include <stdlib.h>
#define _CRT_SECURE_NO_DEPRECATE

int main()
{
int num, i, resto;

printf("Introduzca el numero:");
scanf_s("%d", &num);

if (num <= 0)
{
printf("el numero debe ser positivo\n");
}
else
{
for (i = 1; i <= num; i++)
{
resto=i%7;
if(resto==0)
{
printf("%d es divisible por 7\n", i);
}
}
}
system("pause");
return 0;
}
 PRACTICA 2
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>

//DECLARACIONES DE FUNCIONES
int menu();
int desplazar(int, int);
int parImpar(int);
void operacionesLogicasBits();
int ponerACeroBit(int, int);
long factorial(long);
int numeroBits(int);
int cambiarBits(int, int, int);
void intercambiar(double *, double *);
double mediaAritmetica(double, double, double, double);

int main()
{
//DEFINICIONES DE VARIABLES
int opcion;
int x = 0, y = 0, z = 0;
long xl = 0, yl = 0;
double a = 0, b = 0, c = 0, d = 0, media = 0, *p1, *p2;

setlocale(0, ""); //por defecto: configuracion regional

//setlocale(LC_CTYPE, "spanish"); //LC_CTYPE: caracteres, LC_ALL: todo

printf("PRÁCTICA 2\n");
printf("============\n");
opcion = menu();

while (opcion != 10)

{
switch (opcion)
{
case 1:
printf("Ejercicio 1: desplazar\n");
printf("Introduzca un número: ");
scanf("%d", &y);
printf("Posiciones a desplazar a la derecha: ");
scanf("%d", &z);
x = desplazar(y, z); //llamar a la funcion
printf("El numero desplazado es: %d\n\n", x);
break;

case 2:
printf("Ejercicio 2: par o impar\n");
printf("Introduzca un número: ");
scanf("%d", &y);
x = parImpar(y); //llamar a la funcion
if (x != 0)
printf("El número %d es impar\n\n", y);
else
printf("El número %d es par\n\n", y);
break;
 case 3:
printf("Ejercicio 3: operaciones lógicas a nivel de bits\n");
operacionesLogicasBits(); //llamar a la funcion
break;

case 4:
printf("Ejercicio 4: poner a cero un bit\n");
printf("Introduzca un número: ");
scanf("%d", &y);
printf("Posición del bit a poner a cero: ");
scanf("%d", &z);
x = ponerACeroBit(y, z); //llamar a la funcion
printf("El número modificado es: %d\n", x);
break;

case 5:
printf("Ejercicio 5: factorial\n");
do
{
printf("Introduzca un numero entero positivo:");
scanf("%ld", &yl);
} while (yl < 0);
xl = factorial(yl); //llamar a la funcion
if (yl < 0 || yl > 16)
printf("No es posible calcular el factorial\n");
else
printf("El factorial de %ld es: %ld\n\n", yl, xl);
break;

case 6:
printf("Ejercicio 6: número de bits\n");
do
{
printf("Introduzca un numero entero positivo:");
scanf("%d", &y);
} while (y < 0); //SIGNIFICA QUE SE REPITA MIENTRAS EL NUMERO SEA
NEGATIVO
x = numeroBits(y); //llamar a numerobits
printf("El numero de bits para representar %d es: %d\n", y, x);
break;

case 7:
printf("Ejercicio 7: cambiar bits\n");
do
{
printf("Introduzca un numero entero positivo:");
scanf("%d", &x);
} while (x < 0);
printf("Posicion del bit inicial a invertir:");
scanf("%d", &y);
printf("Numero de bits a invertir:");
scanf("%d", &z);
x = cambiarBits(x, y, z);
if (z > y)
{
printf("Numero de bits no valido");
return -1;
}
else
{
printf("El numero modificado es: %d\n", x);
return 0;
}
 break;

case 8:
printf("Ejercicio 8: intercambiar\n");
printf("Introduzca el valor de d1:");
scanf("%lf", &p1);
printf("Introduzca el valor de d2:");
scanf("%lf", &p2);
intercambiar(&p1,&p2);
printf("\nValores intercambiados: d1=%lf, d2=%lf", *p1, *p2);

break;

case 9:
printf("Ejercicio 9: media aritmética\n");
printf("Numero:");
scanf("%lf", &a);
printf("Numero:");
scanf("%lf", &b);
printf("Numero:");
scanf("%lf", &c);
printf("Numero:");
scanf("%lf", &d);
media = mediaAritmetica(a, b, c, d);//llamar a mediaaritmetica
printf("Media: %.3lf\n", media);
break;

default:
printf("ERROR: Opción incorrecta.\n");
break;
}
system("pause");
opcion = menu(); //llamar a menu
}
}

//DEFINICIONES DE FUNCIONES

int menu() //definicion de menu

{
int op;
do
{
system("cls");
printf("\n"
"\t01.- Ejercicio 1\n"
"\t02.- Ejercicio 2\n"
"\t03.- Ejercicio 3\n"
"\t04.- Ejercicio 4\n"
"\t05.- Ejercicio 5\n"
"\t06.- Ejercicio 6\n"
"\t07.- Ejercicio 7\n"
"\t08.- Ejercicio 8\n"
"\t09.- Ejercicio 9\n"
"\t10.- Salir\n"
"\n"
"Elija una opción: ");

scanf("%d", &op);

if (op < 1 || op > 10)

{
printf("Opción no válida\n");
 system("pause"); //detenerse hasta pulsar una tecla
}
} while (op < 1 || op > 10);
return op;
}

int desplazar(int n, int nPos)

{
int nDesplazado = 0;
nDesplazado = n >> nPos;
return nDesplazado;
}

int parImpar(int n)
{
int resultado;
resultado = n % 2;
return resultado;
}

void operacionesLogicasBits()
{
int a = 8, b = 0, c = 15, d = 93, e, r1, r2, r3, r4, r5, r6;

r1 = a && b || c && !d;

r2 = !a || b && c || d;
r3 = a < b || !c > d;
r4 = a + b > d - c;
r5 = a && b && !c || !(a && b) && c;

a = 0x12; b = 0x56; c = 0x9a; d = 0x0f; e = 0306;

r1 = a & b | c;
r2 = c & 0177;
r3 = ~a | b ^ c;
r4 = e & c;
r5 = r4 & ~077;
r6 = (a&d) << 4 | (a&e) >> 4;
}

int ponerACeroBit(int n, int nPosBit)

{
int resultado, mascara;
mascara = 1 << nPosBit;
resultado = n & ~mascara; //IMPORTANTE
return resultado;
}

long factorial(long n)
{
long i = 0, factorial = 1;
if (n < 0 || n>16)
return -1;
else
for (i = 1; i < n; n--)
{
factorial = n*factorial;
}
return factorial;
/*
i=1;
while(i<n){
factorial=factorial*n;
 n--;
}
*/
}

int numeroBits(int n)
{
int dosElevadoN = 2, nbits = 1; //2^1=2
while (dosElevadoN <= n)//do
{
dosElevadoN = dosElevadoN * 2;
nbits++;
}//while (dosElevadoN <= n);
return nbits;
}

int cambiarBits(int n, int posbit, int nbitscero)

{
int mascara = ~(~0 << nbitscero) << (posbit - nbitscero + 1);
return n ^ mascara;
}

void intercambiar(double *p1, double *p2)

{
double p = 0;
p = *p1;
*p1 = *p2;
*p2 = p;
}

double mediaAritmetica(double a, double b, double c, double d)

{
double media;
media = a + b + c + d;
media = media / 4;
return media;
}
 PRACTICA 3.1
#include <stdio.h>

int potencia(int base, int exp);

int factorial(int num);

int main()
{
int opcion = 0, base, exponente, numero;
while (opcion < 3)
{
printf("Elija una opcion:\n");
printf("1-Calcular la potencia\n");
printf("2-Calcular el factorial\n");
printf("3-Salir\n");

scanf_s("%d", &opcion);
if (opcion == 1)
{
printf("Introduzca la base:");
scanf_s("%d", &base);
do
{
printf("Introduzca el exponente:");
scanf_s("%d", &exponente);
} while (exponente < 0);
printf("El resultado es %d\n", potencia(base, exponente));
}
if (opcion == 2)
{
printf("Introduzca un numero:");
scanf_s("%d", &numero);
printf("El factorial es %d\n", factorial(numero));
}
}
return 0;
}

int potencia(int base, int exponente)

{
int resultado = 0; //i=0;
resultado = base;

if (exponente == 0)
{
resultado = 1;
}
else
{
while (exponente > 1)
{
resultado *= base; //resultado= resultado*base
exponente--; //exponente= exponente - 1
}
/* for(i=1;exponente>i;exponente--)
{
 resultado*=base;
}*/

}
return resultado;
}

int factorial(int numero)

{
int resultado;//i=0;
if (numero == 0)
{
resultado = 1;
}
else
{
resultado = numero;
}
while (numero > 1)
{
numero--;
resultado *= numero;
}
/*for(i=1;numero>i;numero--)
{
resultado*=numero;
}*/
return resultado;
}
 PRACTICA 3.2
#include <stdio.h>
#include<stdlib.h>
#define MAX 10

int main()
{
int numeros[MAX], i;

for (i = 0; i < MAX; i++)

{
printf("\tIntroduzca el elemento %d: ", i);
scanf_s("%d", &numeros[i]);
}
printf("\n****LISTADO DE LOS NUMEROS LEIDOS****\n\n");

for (i = 0; i < MAX; i++) // si se pone i<=MAX se imprimen 11 elementos, por eso el ultimo contiene basura,
ya que el array solo consta de 10 elementos(0-9)
{
printf("%d, ", numeros[i]);
}
printf("\n\n");
system("pause");
return 0;
}
 PRACTICA 3.2.1
#include <stdio.h>
#include <stdlib.h>

void cuenta_billetes_monedas(int, int[]);

int main()
{
int valor[9] = { 500,200,100,50,20,10,5,2,1 };
int cantidad;

printf("Practica 3, ejercicio 2\n");

printf("Introduce una cantidad de euros(sin centimos):");

scanf_s("%d", &cantidad);

if (cantidad <= 0)
{
printf("ERROR:La cantidad debe ser mayor que cero.\n");
system("pause");
return -1;
}

else
{
cuenta_billetes_monedas(cantidad, valor);
system("pause");
return 0;
}
}

void cuenta_billetes_monedas(int cantidad, int valor[])

{
int i = 0, n = 0;
for (i = 0; cantidad > 0; i++)
{
n = cantidad / valor[i];
cantidad = cantidad % valor[i];
if (n > 0)
printf("%d billetes/monedas de %d euros.\n", n, valor[i]);
}
}
 PRACTICA 3.2.2
#include <stdio.h>
#include <stdlib.h>
#define _CRT_SECURE_NO_DEPRECATE
#define MAXIMO 100

int main()
{
double array[MAXIMO], temp;
int i, j, n, m;

printf("¿Cuantos numeros quiere introducir?");

scanf_s("%d", &n);

for (m = 0; m < n; m++)

{
printf("Introduzca el numero %d:", m);
scanf_s("%lf", &array[m]);
}

printf("\nNumeros desordenados:");
for (m = 0; m < n; m++)
{
printf("%.2lf, ", array[m]);
}

for (i = 0; i < n; i++)

{
j = i - 1;
temp = array[i];
while (array[j] > temp && j >= 0)
{
array[j + 1] = array[j];
j--;
}
array[j + 1] = temp;
}

printf("\nNumeros ordenados:");
for (j = 0; j < n; j++)
{
printf("%.2lf, ", array[j]);
}
printf("\n\n");
system("pause");
return 0;
}
 PRACTICA 3.2.3
#include <stdio.h>
#include <stdlib.h>
#define _CRT_SECURE_NO_WARNINGS
#define MAXIMO 100

int main()
{
double array[MAXIMO], temp;
int i, j, n, m, bajo, alto, x, central;

printf("¿Cuantos numeros quiere introducir?");

scanf_s("%d", &n);

for (m = 0; m < n; m++)

{
printf("Introduzca el numero %d:", m+1);
scanf_s("%lf", &array[m]);
}

for (i = 1; i < n; i++) //ordenar numeros

{
j = i - 1;
temp = array[i];
while (array[j] > temp && j >= 0)
{
array[j + 1] = array[j];
j--;
}
array[j + 1] = temp;
}

printf("Introduzca el valor a buscar:");

scanf_s("%d", &x);
bajo = 0;
alto = n - 1;

while (bajo <= alto)

{
central = (alto + bajo) / 2;//division entera
if (x == array[central])
{
printf("Exito. El elemento esta en la posicion %d\n", central);
system("pause");
return 0;
}
if (x > array[central])
{
bajo = central + 1;
}
if (x < array[central])
{
alto = central - 1;
}
}
printf("Fracaso. El numero buscado no esta en el array\n");
system("pause");
}

PRACTICA 3.2.4
“MENU.H”
#include <stdio.h>
#include <stdlib.h>

#define MAX 10
#define SALIR 6

int Menu();
int introducir_array(int[]);
void visualizar_array(int Array[], int n_eltos);
void ordenar_insercion(int A[], int num);
int busqueda_binaria(int x, int valores[], int num);
int introducir_valor(int x, int Array[], int pos);

“MENU.C”
#include "Menu.h"

int main()
{
int Array[MAX], n_eltos = 0;
int op = 0, x, pos, resu;
while ((op = Menu()) != SALIR)
{
switch (op)
{
case 1:
n_eltos = introducir_array(Array);
break;

case 2:
visualizar_array(Array, n_eltos);
system("pause");
break;

case 3:
ordenar_insercion(Array, n_eltos);
break;

case 4:
printf("Introduzca el valor a buscar:");
scanf_s("%d", &x);
pos = busqueda_binaria(x, Array, n_eltos);
if (pos == -1)
{
printf("\nFracaso.El numero introducido no se encuentra en el array\n");
system("pause");
}
else
{
printf("\nEl numero se encuentra en la posicion %d\n", pos);
system("pause");
}
break;
 case 5:
printf("Introduzca el valor a buscar: ");
scanf_s("%d", &x);
pos = busqueda_binaria(x, Array, n_eltos);
if (pos == -1)
{
printf("Fracaso. El numero introducido no se encuentra en el array\n");
}
else
{
printf("Introduzca el nuevo valor: ");
scanf_s("%d", &resu);
if (introducir_valor(x, Array, pos) == -1)
{
printf("Error, array lleno.\n");
}
else
{
printf("Intercambio realizado correctamente.\n");
}
}
system("pause");
break;

case 6:
printf("Saliendo del programa......\n\n");
break;
}
}
}

“FUNCIONES.C”
#include "Menu.h"

int Menu()
{
int op;
system("cls");
do
{
system("cls");
printf("\n");
printf("\t1.Introducir array\n");
printf("\t2.Visualizar array\n");
printf("\t3.Ordenar array\n");
printf("\t4.Buscar un elemento en el array\n");
printf("\t5.Modificar un elemento en el array\n");
printf("\t6.Salir\n");
printf("Seleccione la opcion deseada: ");
scanf_s("%d", &op);
printf("\n\n");
} while (op < 1 || op>6);
return op;
}

int introducir_array(int Array[])

{
int i, n;
printf("Cuantos elementos quiere introducir?: ");
do
{
scanf_s("%d", &n);
} while (n <= 0 || n >= 10);
 for (i = 0; i < n; i++)
{
printf("Introduzca el elemento %d: ", i + 1);
scanf_s("%d", &Array[i]);
}
printf("\n\n");
system("pause");
return n;
}

void visualizar_array(int Array[], int n_eltos)

{
int i;
printf("Elementos del array: \n");
for (i = 0; i < n_eltos; i++)
{
printf("%d, ", Array[i]);
}
printf("\n\n");
system("pause");
}

void ordenar_insercion(int A[], int num)

{
int i, j, temp;
for (i = 1; i < num; i++)
{
j = i - 1;
temp = A[i];
while (A[j] > temp && j >= 0)
{
A[j + 1] = A[j];
j--;
}
A[j + 1] = temp;
}
printf("Elementos del array ordenados: ");
for (j = 0; j < num; j++)
{
printf("%d, ", A[j]);
}
printf("\n\n");
system("pause");
}

int busqueda_binaria(int x, int valores[], int num)

{
int bajo, alto, central;
bajo = 0;
alto = num - 1;

while (bajo <= alto)

{
central = (alto + bajo) / 2;//division entera
if (x == valores[central])
{
return central;
}
if (x > valores[central])
{
bajo = central + 1;
}
if (x < valores[central])
 {
alto = central - 1;
}
}
return -1;
}

int introducir_valor(int x, int Array[], int pos)

{
if (pos >= MAX || pos < 0)
{
return -1;
}
else
{
Array[pos] = x;
return 0;
}
}
 PRACTICA 4.1
“DICCIONARIO.H”
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_PAL 100

#define MAX_CAD 20

typedef struct
{
char ingles[MAX_CAD];
char espanyol[MAX_CAD];
}tPalabra;

int menu();
void LeeCadena(char cadena[], int max);
int anyadir_palabra(tPalabra Dicc[], int num);
void traducir_palabra(tPalabra Dicc[], int num);
void mostrar_diccionario(tPalabra Dicc[], int num);

“MAIN DICC.C”
#include "diccionario.h"

int main()
{
tPalabra Diccionario[MAX_PAL]; //la estructura ha sido renombrada a Diccionario
int num_pal = 0;
int opcion;

printf("PROGRAMA DICCIONARIO\n");
printf("====================\n");

while ((opcion = menu()) != 4)

{
switch (opcion)
{
case 1:
num_pal = anyadir_palabra(Diccionario, num_pal);
printf("Hay %d palabras en el diccionario.\n", num_pal);
system("pause");
break;

case 2:
traducir_palabra(Diccionario, num_pal);
break;

case 3:
mostrar_diccionario(Diccionario, num_pal);
break;

}
}

}
“FUNCIONES.C”
#include "diccionario.h"

int menu()
{
int op;
do
{
system("cls");
printf("\n"
"\t1.-Anyadir palabra\n"
"\t2.-Traducir palabra\n"
"\t3.-Mostrar diccionario\n"
"\t4.-Salir\n"
"\n"
"Elija una opcion: ");
scanf("%d", &op);
while (getchar() != '\n'); //fflush(stdin)
} while ((op < 1) || (op > 4));
return op;
}

void LeeCadena(char cadena[], int max)

{
char *p;
int n;

p = fgets(cadena, max, stdin);

if (p != NULL)
{
n = strlen(cadena);
if (n > 0 && cadena[n - 1] == '\n')
{
cadena[n - 1] = '\0';
}
}
}

int anyadir_palabra(tPalabra Dicc[], int num)

{
if (num >= MAX_PAL)
{
printf("El diccionario esta lleno.\n");
return num;
}
else
{
printf("Introduzca la palabra en espanyol:");
LeeCadena(Dicc[num].espanyol, MAX_CAD);
printf("Introduzca la palabra en ingles:");
LeeCadena(Dicc[num].ingles, MAX_CAD);
num++;
return num;
}
}
void traducir_palabra(tPalabra Dicc[], int num)
{
char palabra[MAX_CAD];
int i, encontrado = 0;

printf("Introduzca la palabra a traducir: ");

LeeCadena(palabra, MAX_CAD);

for (i = 0; i < num; i++) //DA ERROR!!!

{
if (strcmp(Dicc[i].espanyol, palabra) == 0) // compara la palabra letra a letra, si el resultado=0
SON IGUALES
{
printf("Traduccion: %s\n", Dicc[i].ingles);
encontrado = 1;
}
else if (strcmp(Dicc[i].ingles, palabra) == 0)
{
printf("Traduccion: %s\n", Dicc[i].espanyol);
encontrado = 1;
}
}
if (encontrado == 0)
{
printf("Palabra no encontrada en el diccionario.\n");
}
system("pause");
}

void mostrar_diccionario(tPalabra Dicc[], int num)

{
int i;

printf("ESPANYOL \t\tINGLES\n");
printf("-------- \t\t------\n");

for (i = 0; i < num; i++)

{
printf("%s\t\t\t", Dicc[i].espanyol);
printf("%s\n", Dicc[i].ingles);
}
printf("\n\n");
system("pause");
}
 PRACTICA 4.2
“ESTADISTICA.H”
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define _CRT_SECURE_NO_WARNINGS

#define MAX_CAD 20
#define MAX_ALUM 100
#define NUM_NOTAS 5

typedef struct
{
char nombre[MAX_CAD];
char DNI[10];
double nota;
}tficha;

int main();
tficha LeeAlumno();
void LeeCadena(char cadena[], int max);
int PedirDatos(tficha ficha[]);
void MuestraAlumnos(tficha ficha[], int num);
void MuestraAlumno(tficha ficha);
void ImprimirEstadistica(double suma, int cont[], int num);
void CalcularEstadistica(tficha ficha[], int num);

“MAIN.C”
#include "estadistica.h"

int main()
{
tficha ficha[MAX_ALUM];
int num = 0;
printf("Programa estadistica\n");
num = PedirDatos(ficha);
if (num > 0)
{
MuestraAlumnos(ficha, num);
CalcularEstadistica(ficha, num);
}
system("pause");
}

“ESTADISTICA.C”
#include "estadistica.h"

void CalcularEstadistica(tficha Fichas[], int num)

{
double suma = 0;
int i, cont[NUM_NOTAS] = { 0 };
for (i = 0; i < num; i++)
{
suma += Fichas[i].nota;
if ((Fichas[i].nota >= 0) && (Fichas[i].nota < 5))
cont[0]++;
 else if ((Fichas[i].nota >= 5) && (Fichas[i].nota < 7))
cont[1]++;
else if ((Fichas[i].nota >= 7) && (Fichas[i].nota < 9))
cont[2]++;
else if ((Fichas[i].nota >= 9) && (Fichas[i].nota < 10))
cont[3]++;
else if ((Fichas[i].nota == 10))
cont[4]++;
}
ImprimirEstadistica(suma, cont, num);
}

“ENTRADA.C”
#include "estadistica.h"

void LeeCadena(char cadena[], int max)

{
char *p;
int n;

p = fgets(cadena, max, stdin);

if (p != NULL)
{
n = strlen(cadena);
if (n > 0 && cadena[n - 1] == '\n')
{
cadena[n - 1] = '\0';
}
}
}

tficha LeeAlumno()
{
tficha alumnos;
printf("Nombre: ");
while (getchar() != '\n');
LeeCadena(alumnos.nombre, 50);
printf("DNI: ");
LeeCadena(alumnos.DNI, 50);

do
{
printf("Nota: ");
scanf_s("%lf", &alumnos.nota);
} while (alumnos.nota < 0 || alumnos.nota>10);
printf("\n");

return alumnos;
}

int PedirDatos(tficha ficha[])

{
int n, i;
do
{
printf("Introduzca el numero de alumnos de la clase (maximo %d):", MAX_ALUM);
scanf_s("%d", &n);
} while (n < 1 || n > MAX_ALUM);

for (i = 0; i < n; i++)

{
 printf("Alumno %d: \n", (i+1));
ficha[i] = LeeAlumno();
}
return n;
}

“SALIDA.C”
#include "estadistica.h"

void MuestraAlumnos(tficha ficha[], int num)

{
int i;

printf("\tNOMBRE\t\tDNI\t\tNOTA\n");
printf("\t------\t\t---\t\t----\n");
for (i = 0; i < num; i++)
{
MuestraAlumno(ficha[i]);
}
}

void MuestraAlumno(tficha ficha)

{
printf("\t%s\t\t%s\t\t%.2lf\n", ficha.nombre, ficha.DNI, ficha.nota);
}

void ImprimirEstadistica(double suma, int cont[], int num)

{
float porc;
int cero = 0;
char calificaciones[NUM_NOTAS][20] =
{ "Suspenso", "Aprobado", "Notable", "Sobresaliente", "Matricula"};

printf("\n");
printf("La nota media de la clase es: %.2lf\n", suma / num);

if (cont[0] != 0)
printf("Suspenso: %.2lf %c\n", (((float)cont[0] / num) * 100), 37);
else
printf("Suspenso: %d %c.\n", cero, 37);

if (cont[1] != 0)
printf("Aprobado: %.2lf %c\n", (((float)cont[1] / num) * 100), 37);
else
printf("Aprobado: %d %c.\n", cero, 37);

if (cont[2] != 0)
printf("Notable: %.2lf %c\n", (((float)cont[2] / num) * 100), 37);
else
printf("Notable: %d %c.\n", cero, 37);

if (cont[3] != 0)
printf("Sobresaliente: %.2lf %c\n", (((float)cont[3] / num) * 100), 37);
else
printf("Sobresaliente: %d %c.\n", cero, 37);

if (cont[4] != 0)
printf("Matricula: %.2lf %c\n", (((float)cont[4] / num) * 100), 37);
else
printf("Matricula: %d %c.\n", cero, 37);
}
 PRACTICA 5.1
“CABECERA.H”
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "MemoryManager.h"

typedef enum
{
blanco, amarillo, naranja, rosa, rojo, verde, azul, morado, marrón, negro
}tColor;

typedef enum
{
camiseta, camisa, pantalon, falda, vestido, zapatos, jersey, chaqueta
}tTipoPrenda;

typedef struct
{
char ref[15];
char talla[5];
tColor color;
tTipoPrenda tipo;
char h_m;
int n_uds;
float precio;
}tPrenda;

typedef struct
{
char direccion[50];
char tfno[10];
char e_mail[50];
}tContacto;

typedef struct
{
int codigo;
tContacto contacto;
int n_prendas;
tPrenda *p_prendas;
}tTienda;

typedef struct
{
tContacto contacto; // Estructura con dirección, teléfono y correo-e de la oficina donde se gestionan las tiendas
int n_tiendas; // Número total de tiendas
tTienda *p_tiendas; // Puntero al inicio del array dinámico de las tiendas de la cadena
}tCadena;

int Menu();

void LeeCadena(char cadena[], char *p_mensaje, int max);

tContacto LeerContacto();
int CrearTiendas(tCadena *p_cadena);
int IniTienda(tTienda *pTienda);
int IniTiendas(tTienda *p_tiendas, int n_tiendas);
tPrenda IniPrenda();
void IniPrendasUnaTienda(tPrenda *p_prendas, int n_prendas);
void IniPrendasTiendas(tCadena cadena);
int AnyadirTienda(tCadena *p_cadena);

void VisuContacto(tContacto contacto);

void VisuPrenda(tPrenda prenda);
void VisuTienda(tTienda tienda);
void VisuCadena( tCadena cadena);
void ErrorMemoria(tCadena cadena, char *pcadena);

void EliminaPrenda(tPrenda *pp_prendas, int posPrenda, int n_prendas);

void EliminarPrendaDeTiendas(tCadena cadena);
void LiberaMemoria(tCadena cadena);

“SOURCE.C”
#include "cabecera.h"
#include"MemoryManager.h"

int AnyadeElemento(int **, int);

int EliminaElemento(int *, int, int);

int main()
{
int nelementos, i, k, n, *p;
p = NULL;

//Lectura del numero de elementos que formaran el array

printf("Introduzca el numero de elementos\n");
scanf("%d", &nelementos);

//Reserva de memoria para nelementos

p = (int*)realloc(p, nelementos * sizeof(int));
if (p == NULL)
{
printf("Error al asignar memoria");
return -1;
}

//Inicializacion del array

printf("\n\nIntroduzca los datos del array\n\n");
for (i = 0; i < nelementos; i++)
{
printf("\nDato %d: ",i + 1);
scanf("%d", &p[i]);
}

//Impresion de los datos por pantalla

printf("Los datos almacenados en el array son: \n\n");
for (i = 0; i < nelementos; i++)
{
printf("\t%d", p[i]);
}
printf("\n\n");

//Añadir nuevo elemento

printf("Se va a a%cadir un nuevo elemento\n", 164);
n = AnyadeElemento(&p, nelementos);
 if (n != -1)
nelementos = n;
else
{
printf("Error al reservar memoria\n");
free(p);
return -1;
}

//Eliminar elemento
printf("Introduzca a posicion de elemento a eliminar: \n");
scanf("%d", &k);
k = EliminaElemento(&p, nelementos, k);

//Liberacion de memoria
free(p);
MemoryManager_DumpMemoryLeaks();
system("pause");
return 0;
}

int AnyadeElemento(int **p, int nelementos)

{
int *paux = *p;
paux = (int *)realloc(*p, (nelementos + 1) * sizeof(int));
if (paux != NULL)
{
printf("Introduce el nuevo valor\n\n");
scanf("%d", &paux[nelementos]);
*p = paux;
return ++nelementos;
}
else
return -1;
}

int EliminaElemento(int *p, int nelementos, int k)

{
int i;

for (i = k; i <= nelementos - 2; i++)

p[i] = p[i + 1];
p = (int*)realloc(p, (nelementos - 1) * sizeof(int));

nelementos = nelementos - 1;
return nelementos;
}
 PRACTICA 5.2.1
“CABECERA.H”
#define MAX_CARAC 30
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "MemoryManager.h"

typedef struct
{
char nombre[MAX_CARAC];
float nota;
}tficha;

void LeeCadena(char cadena[], int max);

void LeeAlumnos(tficha *palumno, int nalumnos);
tficha LeeAlumno();
void MuestraAlumnos(tficha *palumno, int nalumnos);
void MuestraAlumno(tficha *palumno);

“MAIN.C”
#include "cabecera.h"

int main()
{
tficha *palumno;
int nalumnos;

//Lectura del numero de alumnos

do
{
printf("Introduzca el numero de alumnos\n");
scanf_s("%d", &nalumnos);
} while (nalumnos <= 0);

//Creacion del array dinamico

palumno = (tficha*)malloc(nalumnos * sizeof(tficha));
if (palumno == NULL)
{
printf("Error al asignar memoria");
return -1;
}

//Inicializacion del array dimanico

LeeAlumnos(palumno, nalumnos);

//Visualizacion del array dinamico

MuestraAlumnos(palumno, nalumnos);

//Liberacion de memoria
free(palumno);

MemoryManager_DumpMemoryLeaks();
 system("pause");
return 0;
}

“FUNCIONES.C”
#include "cabecera.h"

void LeeCadena(char cadena[], int max)

{
char *p;
int n;

p = fgets(cadena, max, stdin);

if (p != NULL)
{
n = strlen(cadena);
if (n > 0 && cadena[n - 1] == '\n')
{
cadena[n - 1] = '\0';
}
}
}

void LeeAlumnos(tficha *palumno, int nalumnos)

{
int i;
for (i = 0; i < nalumnos; i++)
{
palumno[i] = LeeAlumno();
}
}

tficha LeeAlumno()
{
tficha alumnos;
printf("Nombre: ");
while (getchar() != '\n');
LeeCadena(alumnos.nombre, MAX_CARAC);
do
{
printf("Nota: ");
scanf_s("%f", &alumnos.nota);
} while (alumnos.nota < 0 || alumnos.nota>10);
printf("\n");

return alumnos;
}

void MuestraAlumnos(tficha *palumno, int nalumnos)

{
int i;

printf("\tNOMBRE\t\tNOTA\n");
printf("\t------\t\t----\n");
for (i = 0; i < nalumnos; i++)
{
MuestraAlumno(palumno+i);
}
}
void MuestraAlumno(tficha *palumno)
{
printf("\t%s\t\t%f\n", palumno->nombre, palumno->nota);
}

PRACTICA 5.2.2
“CABECERA.H”
#define MAX_CARAC 30
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "MemoryManager.h"

typedef struct
{
char nombre[MAX_CARAC];
float nota;
}tficha;

void LeeCadena(char cadena[], int max);

void LeeAlumnos(tficha *palumno, int nalumnos);
void LeeAlumno(tficha *palumno);
void MuestraAlumnos(tficha *palumno, int nalumnos);
void MuestraAlumno(tficha *palumno);

“MAIN.C”
#include "cabecera.h"

int main()
{
tficha *palumno;
int nalumnos;

//Lectura del numero de alumnos

do
{
printf("Introduzca el numero de alumnos\n");
scanf_s("%d", &nalumnos);
} while (nalumnos <= 0);

//Creacion del array dinamico

palumno = (tficha*)malloc(nalumnos * sizeof(tficha));
if (palumno == NULL)
{
printf("Error al asignar memoria");
return -1;
}

//Inicializacion del array dimanico

LeeAlumnos(palumno, nalumnos);

//Visualizacion del array dinamico

MuestraAlumnos(palumno, nalumnos);

//Liberacion de memoria
free(palumno);

MemoryManager_DumpMemoryLeaks();
system("pause");
 return 0;
}

“FUNCIONES.C”
#include "cabecera.h"

void LeeCadena(char cadena[], int max)

{
char *p;
int n;

p = fgets(cadena, max, stdin);

if (p != NULL)
{
n = strlen(cadena);
if (n > 0 && cadena[n - 1] == '\n')
{
cadena[n - 1] = '\0';
}
}
}

void LeeAlumnos(tficha *palumno, int nalumnos)

{
int i;
for (i = 0; i < nalumnos; i++)
{
LeeAlumno(palumno + i);
}
}

void LeeAlumno(tficha *palumno)

{
printf("Nombre: ");
while (getchar() != '\n');
LeeCadena(palumno->nombre, MAX_CARAC);
printf("Nota: ");
scanf_s("%f", &palumno->nota);
}

void MuestraAlumnos(tficha *palumno, int nalumnos)

{
int i;

printf("\tNOMBRE\t\tNOTA\n");
printf("\t------\t\t----\n");
for (i = 0; i < nalumnos; i++)
{
MuestraAlumno(palumno + i);
}
}

void MuestraAlumno(tficha *palumno)

{
printf("\t%s\t\t%f\n", palumno->nombre, palumno->nota);
}
 PRACTICA 5.2.3
“CABECERA.H”
#define MAX_CARAC 30
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "MemoryManager.h"

typedef struct
{
char *pnombre;
float nota;
}tficha;

void LeeCadena(char cadena[], int max);

int LeeAlumnos(tficha *palumno, int nalumnos);
int LeeAlumno(tficha *palumno);
void MuestraAlumnos(tficha *palumno, int nalumnos);
void MuestraAlumno(tficha *palumno);
void LiberaMemoria(tficha *palumno, int nalumnos);

“MAIN.C”
#include "cabecera.h"

int main()
{
tficha *palumno;
int nalumnos, nal_leidos;

//Lectura del numero de alumnos

do
{
printf("Introduzca el numero de alumnos\n");
scanf_s("%d", &nalumnos);
} while (nalumnos <= 0);

//Creacion del array dinamico

palumno = (tficha*)malloc(nalumnos * sizeof(tficha));
if (palumno == NULL)
{
printf("Error al asignar memoria");
return -1;
}

//Inicializacion del array dimanico

nal_leidos = LeeAlumnos(palumno, nalumnos);

if (nal_leidos < nalumnos)

{
printf("Error al reservar la memoria de los nombres\n");
if (nal_leidos == 0)
{
free(palumno);
return -1;
 }
}

//Visualizacion del array dinamico

MuestraAlumnos(palumno, nalumnos);

//Liberacion de memoria
LiberaMemoria(palumno, nal_leidos);

MemoryManager_DumpMemoryLeaks();
system("pause");
return 0;
}

“FUNCIONES.C”
#include "cabecera.h"

void LeeCadena(char cadena[], int max)

{
char *p;
int n;

p = fgets(cadena, max, stdin);

if (p != NULL)
{
n = strlen(cadena);
if (n > 0 && cadena[n - 1] == '\n')
{
cadena[n - 1] = '\0';
}
}
}

int LeeAlumnos(tficha *palumno, int nalumnos)

{
int i, nal;
for (i = 0; i < nalumnos; i++)
{
nal = LeeAlumno(&palumno[i]);
if (nal == -1)
break;
}
return i;
}

int LeeAlumno(tficha *palumno)

{
char A[MAX_CARAC];
printf("Nombre: ");
while (getchar() != '\n');
LeeCadena(A, MAX_CARAC);
palumno->pnombre = (char*)malloc((strlen(A) + 1) * sizeof(char));
if (palumno->pnombre == NULL)
{
pritf("Error");
return -1;
}
strcpy(palumno->pnombre, A);
printf("Nota: ");
scanf_s("%f", &palumno->nota);
return 0;
}
void MuestraAlumnos(tficha *palumno, int nalumnos)
{
int i;

printf("\tNOMBRE\t\tNOTA\n");
printf("\t------\t\t----\n");
for (i = 0; i < nalumnos; i++)
{
MuestraAlumno(palumno + i);
}
}

void MuestraAlumno(tficha *palumno)

{
printf("\t%s\t\t%f\n", palumno->pnombre, palumno->nota);
}

void LiberaMemoria(tficha *palumno, int nalumnos)

{
int i;
for (i = 0; i < nalumnos; i++)
free(palumno[i].pnombre);
free(palumno);
}
 PRACTICA 5.3
“CABECERA.H”
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "MemoryManager.h"

typedef enum
{
blanco, amarillo, naranja, rosa, rojo, verde, azul, morado, marrón, negro
}tColor;

typedef enum
{
camiseta, camisa, pantalon, falda, vestido, zapatos, jersey, chaqueta
}tTipoPrenda;

typedef struct
{
char ref[15];
char talla[5];
tColor color;
tTipoPrenda tipo;
char h_m;
int n_uds;
float precio;
}tPrenda;

typedef struct
{
char direccion[50];
char tfno[10];
char e_mail[50];
}tContacto;

typedef struct
{
int codigo;
tContacto contacto;
int n_prendas;
tPrenda *p_prendas;
}tTienda;

typedef struct
{
tContacto contacto; // Estructura con dirección, teléfono y correo-e de la oficina donde se gestionan las tiendas
int n_tiendas; // Número total de tiendas
tTienda *p_tiendas; // Puntero al inicio del array dinámico de las tiendas de la cadena
}tCadena;

int Menu();
void LeeCadena(char cadena[], char *p_mensaje, int max);
tContacto LeerContacto();
int CrearTiendas(tCadena *p_cadena);
int IniTienda(tTienda *pTienda);
int IniTiendas(tTienda *p_tiendas, int n_tiendas);
tPrenda IniPrenda();
void IniPrendasUnaTienda(tPrenda *p_prendas, int n_prendas);
void IniPrendasTiendas(tCadena cadena);
int AnyadirTienda(tCadena *p_cadena);

void VisuContacto(tContacto contacto);

void VisuPrenda(tPrenda prenda);
void VisuTienda(tTienda tienda);
void VisuCadena( tCadena cadena);
void ErrorMemoria(tCadena cadena, char *pcadena);

void EliminaPrenda(tPrenda *pp_prendas, int posPrenda, int n_prendas);

void EliminarPrendaDeTiendas(tCadena cadena);
void LiberaMemoria(tCadena cadena);

“MAIN.C”
#include "cabecera.h"
char Colores[10][10]={"blanco", "amarillo", "naranja", "rosa", "rojo", "verde", "azul", "morado", "marrón", "negro"};
char TiposPrendas[8][10]={"camiseta", "camisa", "pantalon", "falda", "vestido", "zapatos", "jersey", "chaqueta"};

main()
{
int op, n_tiendas=0;
tCadena cadena;

cadena.n_tiendas=0;
cadena.p_tiendas=NULL;

do
{
op=Menu();

if (op!=6)
{
switch (op)
{
case 1: // crear array de tiendas
if (CrearTiendas(&cadena)==-1)
ErrorMemoria(cadena, "las tiendas");
system("pause");
break;
case 2: //Inicializar las tiendas y crear arrays de prendas
if (IniTiendas(cadena.p_tiendas, cadena.n_tiendas)==-1)
ErrorMemoria(cadena, "las prendas");
system("pause");
break;
case 3:
//VisuTiendas(cadena.p_tiendas,cadena.n_tiendas);
VisuCadena(cadena);
system("pause");
break;
case 4: //Abrir una tienda: crearla e inicializarla
 if (AnyadirTienda(&cadena)==-1)
ErrorMemoria(cadena, "las tiendas");
system("pause");
break;

case 5: //Eliminar un tipo de prenda de las tiendas

EliminarPrendaDeTiendas(cadena);
system("pause");
break;
} // fin del switch
} // fin del if

}while (op!=6);

LiberaMemoria(cadena);

MemoryManager_DumpMemoryLeaks();
return 0;
}

int Menu()
{
int op;
do
{
system("cls");
printf("\n\n");
printf("\t1. Crear array de tiendas\n");
printf("\t2. Inicializar tiendas y prendas\n");
printf("\t3. Visualizar datos\n");
printf("\t4. Anyadir tienda\n");
printf("\t5. Eliminar un tipo de prenda de las tiendas\n");
printf("\t6. Salir\n");

printf("\n Selecciones la opcion deseada\n\n");

scanf("%d",&op);
}while ((op<1) || (op>6));
return op;
}

“ENTRADADATOS.C”
#include "cabecera.h"

void LeeCadena(char cadena[], char *p_mensaje, int max)

{
char *p;
int n;
printf("Introduzca %s\n",p_mensaje);
fflush(stdin);
p = fgets(cadena, max, stdin);
if (p != NULL)
{
n = strlen(cadena);
if (n>0 && cadena[n - 1] == '\n')
cadena[n - 1] = '\0';
}
}
tContacto LeeContacto()
{
tContacto contacto;
while (getchar() != '\n');
LeeCadena(contacto.direccion, "Introduzca la direccion", 50);
LeeCadena(contacto.tfno, "Introduzca el tfno", 50);
LeeCadena(contacto.e_mail, "Introduzca el e-mail", 50);
return contacto;
}

int CrearTiendas(tCadena *p_cadena)

{
int i;
system("cls");
printf("Introduzca el numero de tiendas\n");
scanf("%d", &p_cadena->n_tiendas);
p_cadena->p_tiendas = (tTienda*)malloc(p_cadena->n_tiendas * sizeof(tTienda));
if (p_cadena->p_tiendas == NULL)
return -1;
for (i = 0; i < p_cadena->n_tiendas; i++)
{
p_cadena->p_tiendas[i].p_prendas = NULL;
}
return 0;
}

int IniTiendas(tTienda *p_tiendas, int n_tiendas)

{
int i;
system("cls");
for (i = 0; i < n_tiendas; i++)
{
if (IniTienda(&p_tiendas[i]) == -1)
{
return -1;
}
IniPrendasUnaTienda(p_tiendas[i].p_prendas, p_tiendas[i].n_prendas);
}
return 0;
}

int IniTienda(tTienda *pTienda)

{
pTienda->contacto = LeerContacto();
printf("Introudzca el codigo:\n");
scanf("%d", &pTienda->codigo);
printf("Introduzca la cantidad de prendas:\n");
scanf("%d", &pTienda->n_prendas);
printf("\n\n");

pTienda->p_prendas = (tPrenda*)malloc(pTienda->n_prendas * sizeof(tPrenda));

if (pTienda->p_prendas == NULL)
{
return -1;
}
return 0;
}

void IniPrendasUnaRienda(tPrenda *p_prendas, int n_prendas)

{
int i;
for (i = 0; i < n_prendas; i++)
 {
printf("Prenda numero %d", (i + 1));
p_prendas[i] = IniPrenda();
}
}

tPrenda IniPrenda()
{
tPrenda ropa = { 0 };
printf("\n\n");
do
{
printf("0.Camiseta, 1.Camisa, 2.Pantalon, 3.Falda, 4.Vestido, 5.Zapatos, 6.Jersey, 7.Chaqueta\n");
printf("Elige el tipo de prenda, intrduciendo su numero correspondiente: \n");
scanf("%d", &ropa.tipo);
} while (ropa.tipo < 0 || ropa.tipo>7);

do
{
printf(" 0. blanco, 1. amarillo, 2. naranja, 3. rosa, 4. rojo, 5.verde, 6. azul, 7. morado, 8. marrón,
9. negro\n");
printf("Elige el color, introduciendo su numero correspondiente :\n");
scanf("%d", &ropa.color);
} while (ropa.color < 0 || ropa.color > 9);

while (getchar() != '\n');

LeeCadena(ropa.ref, "La referencia", 15);
LeeCadena(ropa.talla, "La talla", 5);
printf("Hombre o Mujer\n");
scanf("%c", &ropa.h_m);
printf("Numero de unidades disponibles\n");
scanf("%d", &ropa.n_uds);
printf("El precio\n");
scanf("%lf", &ropa.precio);
return ropa;
}

int AnyadirTienda(tCadena *p_cadena)

{
p_cadena->p_tiendas = (tTienda *)realloc(p_cadena->p_tiendas, sizeof(tTienda) * (p_cadena->n_tiendas +
1));
if (p_cadena->p_tiendas == NULL)
{
return -1;
}
IniTienda(&p_cadena->p_tiendas[p_cadena->n_tiendas]);
IniPrendasUnaTienda(p_cadena->p_tiendas[p_cadena->n_tiendas].p_prendas, p_cadena-
>p_tiendas[p_cadena->n_tiendas].n_prendas);
p_cadena->n_tiendas++;
return 0;
}

“VISUALIZARDATOS.C”
#include "cabecera.h"

extern char Colores[10][10];

extern char TiposPrendas[8][10];
void ErrorMemoria(tCadena cadena, char *pcadena)
{
printf("Error al reservar la memoria de %s\n",pcadena);
LiberaMemoria(cadena);
exit(-1);
}

void VisuCadena(tCadena cadena)

{
int i;
system("cls");
for (i = 0; i < cadena.n_tiendas; i++)
{
VisuTienda(cadena.p_tiendas[i]);
}
}

void VisuTienda(tTienda tienda)

{
int i;
VisuContacto(tienda.contacto);
for (i = 0; i < tienda.n_prendas; i++)
{
VisuPrenda(tienda.p_prendas[i]);
}
}

void VisuPrenda(tPrenda prenda)

{
printf("\n");
printf("Tipo de prenda : %s\n", TiposPrendas[prenda.tipo]);
printf("Color de la prenda : %s\n", Colores[prenda.color]);
printf("La referencia de la prenda : %s\n", prenda.ref);
printf("La talla de la prenda : %s\n", prenda.talla);
printf("Para %c (H : Hombre , M : Mujer)\n", prenda.h_m);

printf("Cantidades disponible : %d\n", prenda.n_uds);

printf("El precio : %.2lf\n", prenda.precio);
}

void VisuContacto(tContacto contacto)

{
printf("La dirección : %s\n", contacto.direccion);
printf("Numero de telefono : %s\n", contacto.tfno);
printf("E-mail %s : \n", contacto.e_mail);
}