diff --git a/6. Arreglos multidimensionales/Programas/Programa 6.1/Programa 6.1.c b/6. Arreglos multidimensionales/Programas/Programa 6.1/Programa 6.1.c new file mode 100644 index 0000000..a621cbd --- /dev/null +++ b/6. Arreglos multidimensionales/Programas/Programa 6.1/Programa 6.1.c @@ -0,0 +1,44 @@ +#include + +/* Diagonal principal. +El programa, al recibir como dato una matriz de tipo entero, escribe la +diagonal principal. */ + +#define TAM 10 + +void Lectura(int[][TAM], int); /* Prototipo de funciones. */ +void Imprime(int[][TAM], int); +/* Observa que siempre es necesario declarar el número de columnas. Si no lo +➥haces, el compilador marcará un error de sintaxis. */ + +void main(void) +{ + int MAT[TAM][TAM]; + Lectura(MAT, TAM); + Imprime(MAT, TAM); +} + +void Lectura(int A[][TAM], int F) +/* La función Lectura se utiliza para leer un arreglo bidimensional. Observa +➥que sólo se debe pasar como parámetro el número de filas ya que la matriz +➥es cuadrada. */ +{ + int I, J; + for (I = 0; I < F; I++) + for (J = 0; J < F; J++) + { + printf("Ingrese el elemento %d %d: ", I + 1, J + 1); + scanf("%d", &A[I][J]); + } +} + +void Imprime(int A[][TAM], int F) +/* La función Imprime se utiliza para escribir un arreglo bidimensional +➥cuadrado de F filas y columnas. */ +{ + int I, J; + for (I = 0; I < F; I++) + for (J = 0; J < TAM; J++) + if (I == J) + printf("\nDiagonal %d %d: %d", I, J, A[I][J]); +} diff --git a/6. Arreglos multidimensionales/Programas/Programa 6.10/Programa 6.10.c b/6. Arreglos multidimensionales/Programas/Programa 6.10/Programa 6.10.c new file mode 100644 index 0000000..664bdf5 --- /dev/null +++ b/6. Arreglos multidimensionales/Programas/Programa 6.10/Programa 6.10.c @@ -0,0 +1,51 @@ +#include + +/* Cuadrado mágico. +El programa genera un cuadrado mágico siguiendo los criterios enunciados +➥anteriormente. */ + +#define MAX 50 +void Cuadrado(int[][MAX], int); +void Imprime(int[][MAX], int); /* Prototipos de funciones. */ + +void main(void) +{ + int CMA[MAX][MAX], TAM; + do + { + printf("Ingrese el tamaño impar de la matriz: "); + scanf("%d", &TAM); + + } while ((TAM > MAX || TAM < 1) && (TAM % 2)); + /* Se verifica el tamaño del arreglo y el orden (impar) del mismo. */ + + Cuadrado(CMA, TAM); + Imprime(CMA, TAM); +} + +void Cuadrado(int A[][MAX], int N) +/* Esta función se utiliza para formar el cuadrado mágico. */ +{ + int I = 1, FIL = 0, COL = N / 2, NUM = N * N; + while (I <= NUM) + { + A[FIL][COL] = I; + if (I % N != 0) + { + FIL = (FIL - 1 + N) % N; + COL = (COL + 1) % N; + } + else + FIL++; + I++; + } +} + +void Imprime(int A[][MAX], int N) +/* Esta función se utiliza para escribir el cuadrado mágico. */ +{ + int I, J; + for (I = 0; I < N; I++) + for (J = 0; J < N; J++) + printf("\nElemento %d %d: %d", I + 1, J + 1, A[I][J]); +} diff --git a/6. Arreglos multidimensionales/Programas/Programa 6.11/Programa 6.11.c b/6. Arreglos multidimensionales/Programas/Programa 6.11/Programa 6.11.c new file mode 100644 index 0000000..c609e69 --- /dev/null +++ b/6. Arreglos multidimensionales/Programas/Programa 6.11/Programa 6.11.c @@ -0,0 +1,105 @@ +#include + +/* Casa de bolsa. +El programa, al recibir como datos los precios mensuales de las acciones de sus +➥cinco fondos de inversión, además del precio de las acciones al 31 de diciembre +➥del 2003, genera información estadística importante para la empresa. */ + +void LecturaM(float[][12], int, int); +void LecturaV(float*, int); +void F1(float[][12], int, int, float*, float*); /* Prototipos de funciones. */ +void F2(float[][12], int, int); +void F3(float*, int); + +void main(void) +{ + float FON[5][12], PRE[5], REN[5]; + /* REN es un arreglo unidimensional de tipo real que se utilizará para almacenar + ➥el rendimiento anual de los fondos de inversión. */ + LecturaM(FON, 5, 12); + LecturaV(PRE, 5); + F1(FON, 5, 12, PRE, REN); + F2(FON, 5, 12); + F3(REN, 5); +} + +void LecturaM(float A[][12], int F, int C) +/* Esta función se utiliza para leer un arreglo bidimensional de tipo real de F +➥filas y C columnas. */ +{ + int I, J; + for (I = 0; I < F; I++) + for (J = 0; J < C; J++) + { + printf("Precio fondo %d\t mes %d: ", I + 1, J + 1); + scanf("%f", &A[I][J]); + } +} + +void LecturaV(float A[], int T) +/* Esta función se utiliza para leer un arreglo unidimensional de tipo real de T +➥elementos. */ +{ + int I; + printf("\n"); + for (I = 0; I < T; I++) + { + printf("Precio Fondo %d al 31/12/2003: ", I + 1); + scanf("%f", &A[I]); + } +} + +void F1(float A[][12], int F, int C, float B[], float V[]) +{ + /* La función F1 se utiliza para calcular el rendimiento anual de los fondos de + ➥inversión. El resultado se almacena en el arreglo unidimensional V. */ + int I; + printf("\nRENDIMIENTOS ANUALES DE LOS FONDOS"); + for (I = 0; I < F; I++) + { + V[I] = (A[I][C - 1] - B[I]) / B[I] * 100; + printf("\nFondo %d: %.2f", I + 1, V[I]); + } +} + +void F2(float A[][12], int F, int C) +{ + /* Esta función calcula el promedio anualizado de las acciones de los diferentes + ➥fondos. */ + int I, J; + float SUM, PRO; + + printf("\n\nPROMEDIO ANUALIZADO DE LAS ACCIONES DE LOS FONDOS"); + for (I = 0; I < F; I++) + { + SUM = 0; + for (J = 0; J < C; J++) + SUM += A[I][J]; + + PRO = SUM / C; + printf("\nFondo %d: %.2f", I + 1, PRO); + } +} + +void F3(float A[], int F) +/* Esta función permite calcular los fondos con el mejor y peor rendimiento. */ +{ + float ME = A[0], PE = A[0]; + int M = 0, P = 0, I; + for (I = 1; I < F; I++) + { + if (A[I] > ME) + { + ME = A[I]; + M = I; + } + if (A[I] < PE) + { + PE = A[I]; + P = I; + } + } + printf("\n\nMEJOR Y PEOR FONDO DE INVERSION"); + printf("\nMejor fondo: %d\tRendimiento: %.2f", M + 1, ME); + printf("\nPeor fondo: %d\tRendimiento: %.2f", P + 1, PE); +} diff --git a/6. Arreglos multidimensionales/Programas/Programa 6.12/Programa 6.12.c b/6. Arreglos multidimensionales/Programas/Programa 6.12/Programa 6.12.c new file mode 100644 index 0000000..2893c26 --- /dev/null +++ b/6. Arreglos multidimensionales/Programas/Programa 6.12/Programa 6.12.c @@ -0,0 +1,109 @@ +#include + +/* Lluvias. +El programa, al recibir como dato un arreglo tridimensional que contiene +➥información sobre lluvias, genera información estadística. */ + +#define PRO 24 +#define MES 12 +#define AÑO 10 + +void Lectura(float[PRO][MES][AÑO], int, int, int); +void Funcion1(float[PRO][MES][AÑO], int, int, int); +void Funcion2(float[PRO][MES][AÑO], int, int, int); /* Prototipos de funciones. */ +void Funcion3(float[PRO][MES][AÑO], int, int, int); + +void main(void) +{ + float LLU[PRO][MES][AÑO]; + + Lectura(LLU, PRO, MES, AÑO); + Funcion1(LLU, PRO, MES, AÑO); + Funcion2(LLU, PRO, MES, AÑO); + Funcion3(LLU, 18, MES, 5); +} + +void Lectur(float A[][MES][AÑO], int F, int C, int P) +/* Esta función se utiliza para leer un arreglo tridimensional de tipo real de +➥F filas, C columnas y P planos de profundidad. */ +{ + int K, I, J; + for (K = 0; K < P; K++) + for (I = 0; I < F; I++) + for (J = 0; J < C; J++) + { + printf("Año: %d\tProvincia: %d\tMes: %d", K + 1, I + 1, J + 1); + scanf("%f", &A[I][J][K]); + } +} + +void Funcion1(float A[][MES][AÑO], int F, int C, int P) +/* Esta función se utiliza para localizar la provincia que tuvo el mayor registro +➥de precipitación pluvial en los últimos 10 años. Escribe además el registro +➥correspondiente. */ +{ + int I, K, J, EMAY = -1; + float ELLU = -1.0, SUM; + + for (I = 0; I < F; I++) + { + SUM = 0.0; + + for (K = 0; K < P; K++) + for (J = 0; J < C; J++) + SUM += A[I][J][K]; + + SUM /= P * C; + if (SUM > ELLU) + { + ELLU = SUM; + EMAY = I; + } + } + printf("\n\nProvincia con mayor registro de lluvias: %d", EMAY + 1); + printf("\nRegistro: %.2f", ELLU); +} + +void Funcion2(float A[][MES][AÑO], int F, int C, int P) +/* Esta función se utiliza para localizar la provincia que tuvo el menor registro +➥de lluvias en el último año. Escribe además el registro correspondiente. */ +{ + int I, J, EMEN = 0; + float ELLU = 1000, SUM; + + for (I = 0; I < F; I++) + { + SUM = 0; + + for (J = 0; J < C; J++) + SUM += A[I][J][P - 1]; + + SUM /= C; + + if (SUM < ELLU) + { + ELLU = SUM; + EMEN = I; + } + } + printf("\n\nProvincia con menor registro anual de lluvias en el ultimo año: %i", EMEN + 1); + printf("\nRegistro anual: %.2f", ELLU); +} + +void Funcion3(float A[][MES][AÑO], int F, int C, int P) +/* Esta función se utiliza para localizar el mes con mayor registro de lluvias en +➥la provincia 18 en el quinto año. Escribe además el registro correspondiente. */ +{ + int J, EMES = -1; + float ELLU = -1.0; + + for (J = 0; J < C; J++) + { + if (A[F - 1][J][P - 1] > ELLU) + { + ELLU = A[F - 1][J][P - 1]; + EMES = J; + } + } + printf("\n\nMes: %d Lluvias: %.2f", EMES + 1, ELLU); +} \ No newline at end of file diff --git a/6. Arreglos multidimensionales/Programas/Programa 6.13/Programa 6.13.c b/6. Arreglos multidimensionales/Programas/Programa 6.13/Programa 6.13.c new file mode 100644 index 0000000..2150844 --- /dev/null +++ b/6. Arreglos multidimensionales/Programas/Programa 6.13/Programa 6.13.c @@ -0,0 +1,112 @@ +#include + +/* Empresa textil. +El programa, al recibir un arreglo tridimensional que contiene información +➥sobre las ventas mensuales de tres departamentos en los últimos ocho años, +➥genera información estadística valiosa para la empresa. */ + +#define MES 12 +#define DEP 3 +#define AÑO 8 + +void Lectura(float[MES][DEP][AÑO], int, int, int); +void Funcion1(float[MES][DEP][AÑO], int, int, int); +void Funcion2(float[MES][DEP][AÑO], int, int, int); /* Prototipos de funciones. */ +void Funcion3(float[MES][DEP][AÑO], int, int, int); + +void main(void) +{ + float PRO[MES][DEP][AÑO]; + Lectura(PRO, MES, DEP, AÑO); + Funcion1(PRO, MES, DEP, 2); + Funcion2(PRO, MES, DEP, AÑO); + Funcion3(PRO, MES, DEP, AÑO); +} + +void Lectura(float A[][DEP][AÑO], int F, int C, int P) +/* La función Lectura se utiliza para leer un arreglo tridimensional de tipo real de F filas, C columnas y P planos de profundidad. */ +{ + int K, I, J; + + for (K = 0; K < P; K++) + for (I = 0; I < F; I++) + for (J = 0; J < C; J++) + { + printf("Año: %d\tMes: %d\tDepartamento: %d", K + 1, I + 1, J + 1); + scanf("%f", &A[I][J][K]); + } +} + +void Funcion1(float A[][DEP][AÑO], int F, int C, int P) +/* Esta función se utiliza para obtener las ventas totales de la empresa en el segundo año. */ +{ + int I, J; + float SUM = 0.0; + + for (I = 0; I < F; I++) + for (J = 0; J < C; J++) + SUM += A[I][J][P - 1]; + + printf("\n\nVentas totales de la empresa en el segundo año: %.2f", SUM); +} + +void Funcion2(float A[][DEP][AÑO], int F, int C, int P) +/* Esta función se utiliza para obtener el departamento que tuvo las mayores ventas en el último año. Genera además el importe de las ventas. */ +{ + int I, J; + float SUM1 = 0, SUM2 = 0, SUM3 = 0; + for (I = 0; I < F; I++) + for (J = 0; J < C; J++) + switch (J + 1) + { + case 1: SUM1 += A[I][J][P - 1]; + break; + case 2: SUM2 += A[I][J][P - 1]; + break; + case 3: SUM3 += A[I][J][P - 1]; + break; + } + if (SUM1 > SUM2) + if (SUM1 > SUM3) + { + printf("\n\nDepartamento con mayores ventas en el ultimo año: Hilos"); + printf("Ventas: %.2f", SUM1); + } + else + { + printf("\n\nDepartamento con mayores ventas en el ultimo año: Licra"); + printf("Ventas: %.2f", SUM3); + } + else + if (SUM2 > SUM3) + { + printf("\n\nDepartamento con mayores ventas en el ultimo año: Lanas"); + printf("Ventas: %.2f", SUM2); + } + else + { + printf("\n\nDepartamento con mayores ventas en el ultimo año: Licra"); + printf("Ventas: %.2f", SUM3); + } +} + +void Funcion3(float A[][DEP][AÑO], int F, int C, int P) +/* Esta función se utiliza para obtener el departamento, mes y año con la mayor venta. Escribe también el monto de las ventas. */ +{ + int K, I, J, DE = 0, ME = 0, AN = 0; + float VEN = -1.0; + + for (K = 0; K < P; K++) + for (I = 0; I < F; I++) + for (J = 0; J < C; J++) + if (A[I][J][K] > VEN) + { + VEN = A[I][J][K]; + DE = J; + ME = I; + AN = K; + } + + printf("\n\nDepartamento: %d\tMes: %d\tAño: %d", DE + 1, ME + 1, AN + 1); + printf("\tVentas: %.2f", VEN); +} diff --git a/6. Arreglos multidimensionales/Programas/Programa 6.2/Programa 6.2.c b/6. Arreglos multidimensionales/Programas/Programa 6.2/Programa 6.2.c new file mode 100644 index 0000000..4b5b188 --- /dev/null +++ b/6. Arreglos multidimensionales/Programas/Programa 6.2/Programa 6.2.c @@ -0,0 +1,78 @@ +#include + +/* Suma matrices. +El programa, al recibir como datos dos arreglos bidimensionales del mismo +➥tamaño, calcula la suma de ambos y la almacena en un tercer arreglo +➥bidimensional. */ + +#define MAX 50 + +/* Prototipo de funciones. */ +void Lectura(int[][MAX], int, int); +void Suma(int[][MAX], int[][MAX], int[][MAX], int, int); +void Imprime(int[][MAX], int, int); + +void main(void) +{ + int MA[MAX][MAX], MB[MAX][MAX], MC[MAX][MAX]; + /* Declaración de los tres arreglos */ + int FIL, COL; + do + { + printf("Ingrese el numero de filas de los arreglos: "); + scanf("%d", &FIL); + } while (FIL > MAX || FIL < 1); + /* Se verifica que el número de filas sea correcto. */ + + do + { + printf("Ingrese el numero de columnas de los arreglos: "); + scanf("%d", &COL); + } while (COL > MAX || COL < 1); + /* Se verifica que el número de columnas sea correcto. */ + + printf("\nLectura del Arreglo MA\n"); + + Lectura(MA, FIL, COL); + + printf("\nLectura del Arreglo MB\n"); + + Lectura(MB, FIL, COL); + Suma(MA, MB, MC, FIL, COL); + + printf("\nImpresion del Arreglo MC\n"); + Imprime(MC, FIL, COL); +} + +void Lectura(int A[][MAX], int F, int C) +/* La función Lectura se utiliza para leer un arreglo bidimensional entero de F +➥filas y C columnas. */ +{ + int I, J; + for (I = 0; I < F; I++) + for (J = 0; J < C; J++) + { + printf("Ingrese el elemento %d %d: ", I + 1, J + 1); + scanf("%d", &A[I][J]); + } +} + +void Suma(int M1[][MAX], int M2[][MAX], int M3[][MAX], int F, int C) +/* La función Suma se utiliza para sumar los arreglos y almacenar el resultado +➥en un tercer arreglo bidimensional. */ +{ + int I, J; + for (I = 0; I < F; I++) + for (J = 0; J < C; J++) + M3[I][J] = M1[I][J] + M2[I][J]; +} + +void Imprime(int A[][MAX], int F, int C) +/* La función Imprime se utiliza para escribir un arreglo bidimensional de tipo +➥entero de F filas y C columnas. */ +{ + int I, J; + for (I = 0; I < F; I++) + for (J = 0; J < C; J++) + printf("\nElemento %d %d: %d", I, J, A[I][J]); +} diff --git a/6. Arreglos multidimensionales/Programas/Programa 6.3/Programa 6.3.c b/6. Arreglos multidimensionales/Programas/Programa 6.3/Programa 6.3.c new file mode 100644 index 0000000..3ff0d23 --- /dev/null +++ b/6. Arreglos multidimensionales/Programas/Programa 6.3/Programa 6.3.c @@ -0,0 +1,107 @@ +#include + +/* Universidad. +El programa, al recibir información sobre el número de alumnos que han ingresado +➥a sus ocho diferentes carreras en los dos semestres lectivos de los últimos +➥cinco años, obtiene información útil para el departamento de escolar. */ + +#define F 8 +#define C 2 +#define P 5 +/* Se declaran constantes para la fila, la columna y la profundidad. */ + +void Lectura(int[][C][P], int, int, int); +void Funcion1(int[][C][P], int, int, int); +void Funcion2(int[][C][P], int, int, int); +void Funcion3(int[][C][P], int, int, int); +/* Prototipo de funciones. Cada prototipo de función corresponde a uno de los +➥incisos. */ + +void main(void) +{ + int UNI[F][C][P]; + Lectura(UNI, F, C, P); + Funcion1(UNI, F, C, P); + Funcion2(UNI, F, C, P); + Funcion3(UNI, 6, C, P); + /* Se coloca el 6 como parámetro ya que es la clave de la Ingeniería en + ➥Computación. */ +} + +void Lectura(int A[][C][P], int FI, int CO, int PR) +/* La función Lectura se utiliza para leer un arreglo tridimensional de tipo +➥entero de FI filas, CO columnas y PR profundidad. Observa que al ser +➥tridimensional se necesitan tres ciclos para recorrer el arreglo. */ +{ + int K, I, J; + for (K = 0; K < PR; K++) + for (I = 0; I < FI; I++) + for (J = 0; J < CO; J++) + { + printf("Año: %d\tCarrera: %d\tSemestre: %d" , K + 1, I + 1, J + 1); + scanf("%d", &A[I][J][K]); + } +} + +void Funcion1(int A[][C][P], int FI, int CO, int PR) +/* Esta función se utiliza para determinar el año en el que ingresó el mayor +➥número de alumnos a la universidad. Observa que el primer ciclo externo +➥corresponde a los años. */ +{ + int K, I, J, MAY = 0, AO = -1, SUM; + for (K = 0; K < PR; K++) + /* Por cada año se suma el ingreso de los dos semestres de las ocho carreras. + */ + { + SUM = 0; + for (I = 0; I < FI; I++) + for (J = 0; J < CO; J++) + SUM += A[I][J][K]; + if (SUM > MAY) + { + MAY = SUM; + AO = K; + } + } + printf("\n\nAño con mayor ingreso de alumnos: %d Alumnos: %d", AO + 1, MAY); +} + +void Funcion2(int A[][C][P], int FI, int CO, int PR) +/* Esta función se utiliza para determinar la carrera que recibió el mayor +➥número de alumnos el último año. Observa que no se utiliza un ciclo para los +➥planos de la profundidad, ya que es un dato (PR). */ +{ + int I, J, MAY = 0, CAR = -1, SUM; + for (I = 0; I < FI; I++) + { + SUM = 0; + for (J = 0; J < CO; J++) + SUM += A[I][J][PR - 1]; + if (SUM > MAY) + { + MAY = SUM; + CAR = I; + } + } + printf("\n\nCarrera con mayor numero de alumnos: %d Alumnos: %d", CAR + 1, MAY); +} + +void Funcion3(int A[][C][P], int FI, int CO, int PR) +/* Esta función se utiliza para determinar el año en el que la carrera +➥Ingeniería en Computación recibió el mayor número de alumnos. Observa que no +➥se utiliza un ciclo para trabajar con las filas, ya que es un dato (FI). */ +{ + int K, J, MAY = 0, AO = -1, SUM; + for (K = 0; K < PR; K++) + { + SUM = 0; + for (J = 0; J < CO; J++) + SUM += A[FI - 1][J][K]; + if (SUM > MAY) + { + MAY = SUM; + AO = K; + } + } + printf("\n\nAño con mayor ingreso de alumnos: %d Alumnos: %d", AO + 1, MAY); +} diff --git a/6. Arreglos multidimensionales/Programas/Programa 6.4/Programa 6.4/Programa 6.4.c b/6. Arreglos multidimensionales/Programas/Programa 6.4/Programa 6.4/Programa 6.4.c new file mode 100644 index 0000000..b8677f6 --- /dev/null +++ b/6. Arreglos multidimensionales/Programas/Programa 6.4/Programa 6.4/Programa 6.4.c @@ -0,0 +1,60 @@ +#include + +/* Simétrico. +El programa, al recibir como dato un arreglo bidimensional cuadrado, determina +si el mismo es simétrico. */ + +#define MAX 100 + +void Lectura(int[][MAX], int); /* Prototipos de funciones. */ +int Simetrico(int[][MAX], int); + +void main(void) +{ + int MAT[MAX][MAX], N, RES; + do + { + printf("Ingrese el tamaño del arreglo: "); + scanf("%d", &N); + } while (N > MAX || N < 1); /* Se verifica que el tamaño del arreglo sea + válido. */ + Lectura(MAT, N); + RES = Simetrico(MAT, N); + if (RES) + printf("\nEl arreglo bidimensional es simetrico"); + else + printf("\nEl arreglo bidimensional no es simetrico"); +} + +void Lectura(int A[][MAX], int T) +/* La función Lectura se utiliza para leer un arreglo bidimensional cuadrado de +tipo entero de T filas y T columnas. */ +{ + int I, J; + for (I = 0; I < T; I++) + for (J = 0; J < T; J++) + { + printf("Fila: %d\tColumna: %d", I + 1, J + 1); + scanf("%d", &A[I][J]); + } +} + +int Simetrico(int A[][MAX], int T) +/* La función Simétrico se utiliza para determinar si el arreglo bidimensional +➥cuadrado es simétrico. Si es simétrico regresa 1, en caso contrario, 0. +➥Observa que en el segundo ciclo solamente se recorre la matriz triangular +➥inferior, sin la diagonal principal. */ +{ + int I = 0, J, F = 1; + while ((I < T) && F) + { + J = 0; + while ((J < I) && F) + if (A[I][J] == A[J][I]) + J++; + else + F = 0; + I++; + } + return (F); +} diff --git a/6. Arreglos multidimensionales/Programas/Programa 6.5/Programa 6.5.c b/6. Arreglos multidimensionales/Programas/Programa 6.5/Programa 6.5.c new file mode 100644 index 0000000..a53a5f1 --- /dev/null +++ b/6. Arreglos multidimensionales/Programas/Programa 6.5/Programa 6.5.c @@ -0,0 +1,80 @@ +#include + +/* Alumnos. +El programa, al recibir un arreglo bidimensional que contiene información +➥sobre calificaciones de alumnos en cuatro materias diferentes, obtiene +➥resultados estadísticos. */ + +#define MAX 50 +#define EXA 4 + +void Lectura(float[MAX][EXA], int); +void Funcion1(float[MAX][EXA], int); /* Prototipos de funciones. */ +void Funcion2(float[MAX][EXA], int); + +void main(void) +{ + int NAL; + float ALU[MAX][EXA]; + do + { + printf("Ingrese el numero de alumnos del grupo: "); + scanf("%d", &NAL); + } /* Se verifica que el número de alumnos del grupo sea válido. */ + while (NAL > MAX || NAL < 1); + + Lectura(ALU, NAL); + Funcion1(ALU, NAL); + Funcion2(ALU, NAL); +} +void Lectura(float A[][EXA], int N) +/* La función Lectura se utiliza para leer un arreglo bidimensional de tipo +real de N filas y EXA columnas. */ +{ + int I, J; + for (I = 0; I < N; I++) + for (J = 0; J < EXA; J++) + { + printf("Ingrese la calificacion %d del alumno %d: ", J + 1, I + 1); + scanf("%f", &A[I][J]); + } +} +void Funcion1(float A[][EXA], int T) +/* Esta función se utiliza para obtener el promedio de cada estudiante. */ +{ + int I, J; + float SUM, PRO; + for (I = 0; I < T; I++) + { + SUM = 0; + for (J = 0; J < EXA; J++) + SUM += A[I][J]; + + PRO = SUM / EXA; + + printf("\nEl promedio del alumno %d es: %.2f", I + 1, PRO); + } +} +void Funcion2(float A[][EXA], int T) +/* Esta función se utiliza tanto para obtener el promedio de cada examen, así +como también el examen que obtuvo el promedio más alto. */ +{ + int I, J, MAY; + float SUM, PRO, MPRO = 0; + printf("\n"); + for (J = 0; J < EXA; J++) + { + SUM = 0; + for (I = 0; I < T; I++) + SUM += A[I][J]; + PRO = SUM / T; + + if (PRO > MPRO) + { + MPRO = PRO; + MAY = J; + } + printf("\nEl promedio del examen %d es: %f", J + 1, PRO); + } + printf("\n\nEl examen con mayor promedio es: %d \t Promedio: %.2f", MAY + 1, MPRO); +} diff --git a/6. Arreglos multidimensionales/Programas/Programa 6.6/Programa 6.6.c b/6. Arreglos multidimensionales/Programas/Programa 6.6/Programa 6.6.c new file mode 100644 index 0000000..f30c4e4 --- /dev/null +++ b/6. Arreglos multidimensionales/Programas/Programa 6.6/Programa 6.6.c @@ -0,0 +1,76 @@ +#include + +/* Intercambia. +El programa intercambia las columnas de un arreglo bidimensional. Los +➥elementos de la primera columna se intercambian con los de la última, +➥los de la segunda con los de la penúltima, y así sucesivamente. */ + +#define MAX 50 + +void Lectura(float[][MAX], int, int); +void Intercambia(float[][MAX], int, int); /* Prototipos de funciones. */ +void Imprime(float[][MAX], int, int); + +void main(void) +{ + int F, C; + float MAT[MAX][MAX]; + do + { + printf("Ingrese el numero de filas: "); + scanf("%d", &F); + + } while (F > MAX || F < 1); /* Se verifica que el número de filas sea correcto. */ + + do + { + printf("Ingrese el numero de columnas: "); + scanf("%d", &C); + + } while (C > MAX || C < 1); /* Se verifica que el número de columnas sea correcto. */ + + Lectura(MAT, F, C); + Intercambia(MAT, F, C); + Imprime(MAT, F, C); +} + +void Lectura(float A[][MAX], int F, int C) +/* La función Lectura se utiliza para leer un arreglo bidimensional de tipo +➥real de F filas y C columnas. */ +{ + int I, J; + for (I = 0; I < F; I++) + for (J = 0; J < C; J++) + { + printf("Ingrese el elemento %d %d: ", I + 1, J + 1); + scanf("%f", &A[I][J]); + } +} + +void Intercambia(float A[][MAX], int F, int C) +/* Esta función se utiliza para intercambiar las columnas del arreglo +bidimensional. Observa que el índice correspondiente a las columnas sólo se +mueve hasta la mitad del arreglo. */ +{ + int I, J; + float AUX; + /* Observa que en esta función el índice I se utiliza para las columnas, y el + índice J para las filas. */ + for (I = 0; I < (C / 2); I++) + for (J = 0; J < F; J++) + { + AUX = A[J][I]; + A[J][I] = A[J][C - I - 1]; + A[J][C - I - 1] = AUX; + } +} + +void Imprime(float A[][MAX], int F, int C) +/* La función Imprime se utiliza para escribir un arreglo bidimensional de tipo +➥real de F filas y C columnas. */ +{ + int I, J; + for (I = 0; I < F; I++) + for (J = 0; J < C; J++) + printf("\nElemento %d %d: %.2f", I + 1, J + 1, A[I][J]); +} diff --git a/6. Arreglos multidimensionales/Programas/Programa 6.7/Programa 6.7.c b/6. Arreglos multidimensionales/Programas/Programa 6.7/Programa 6.7.c new file mode 100644 index 0000000..5c6e9e0 --- /dev/null +++ b/6. Arreglos multidimensionales/Programas/Programa 6.7/Programa 6.7.c @@ -0,0 +1,95 @@ +#include + +/* Fábrica de lácteos. +El programa, al recibir como datos las ventas mensuales de diferentes +➥productos, obtiene información estadística valiosa para la empresa. */ + +void Lectura1(int[15][12]); +void Lectura2(float, int); +void Funcion1(int[][12], int, int, float*, float*); /* Prototipos defunciones. */ +void Funcion2(float*, int); +void Funcion3(float*, int); + +void main(void) +{ + int FAB[15][12] = { 0 }; /* Inicialización en 0 del arreglo FAB. */ + float COS[15], VEN[15]; + + Lectura1(FAB); + Lectura2(COS, 15); + Funcion1(FAB, 15, 12, COS, VEN); + Funcion2(VEN, 15); + Funcion3(VEN, 15); +} + +void Lectura1(int A[][12]) +/* Esta función se utiliza para almacenar en el arreglo bidimensional las +➥diferentes transacciones que representan las ventas de los diferentes +➥productos. El fin de datos está dado por –1. */ +{ + int MES, PRO, CAN; + printf("\nIngrese mes, tipo de producto y cantidad vendida: "); + scanf("%d %d %d", &MES, &PRO, &CAN); + + while (MES != -1 && PRO != -1 && CAN != -1) + { + A[MES - 1][PRO - 1] += CAN; + printf("Ingrese mes, tipo de producto y cantidad vendida: "); + scanf("%d %d %d", & MES, & PRO, & CAN); + } +} + +void Lectura2(float A[], int N) +/* Esta función se utiliza para leer los precios de venta de los diferentes +➥productos. */ +{ + int I; + for (I = 0; I < N; I++) + { + printf("Ingrese costo del producto %d: ", I + 1); + scanf("%f", &A[I]); + } +} + +void Funcion1(int A[][12], int F, int C, float V1[], float V2[]) +/* Esta función se utiliza para calcular el monto de venta anual de cada uno +➥de los productos. Observa que el resultado se almacena en un arreglo +➥unidimensional que se utilizará posteriormente. */ +{ + int I, J, SUM; + printf("\n"); + + for (I = 0; I < F; I++) + { + SUM = 0; + for (J = 0; J < C; J++) + SUM += A[I][J]; + V2[I] = V1[I] * SUM; + printf("\nTotal de ventas del producto %d: %.2f", I + 1, V2[I]); + } +} + +void Funcion2(float A[], int C) +/* Esta función se utiliza para calcular el monto total de ventas de la fábrica. */ +{ + int I; + float SUM = 0.0; + for (I = 0; I < C; I++) + SUM += A[I]; + printf("\n\nTotal de ventas de la fabrica: %.2f", SUM); +} + +void Funcion3(float A[], int C) +/* Esta función se utiliza para obtener el tipo de producto que más se ha vendido +➥y el monto de las ventas de dicho producto. */ +{ + int I, TPR = 0; + float VEN = A[0]; + for (I = 1; I < C; I++) + if (VEN < A[I]) + { + TPR = I; + VEN = A[I]; + } + printf("\n\nTipo de Producto mas vendido: %d \t Ventas: %.2f", TPR + 1, VEN); +} diff --git a/6. Arreglos multidimensionales/Programas/Programa 6.8/Programa 6.8.c b/6. Arreglos multidimensionales/Programas/Programa 6.8/Programa 6.8.c new file mode 100644 index 0000000..c4c4602 --- /dev/null +++ b/6. Arreglos multidimensionales/Programas/Programa 6.8/Programa 6.8.c @@ -0,0 +1,65 @@ +#include + +/* Traspuesta. +El programa calcula la traspuesta de una matriz. */ + +#define MAX 50 + +void Lectura(int[][MAX], int, int); +void Traspuesta(int[][MAX], int[][MAX], int, int); /* Prototipos de funciones. */ +void Imprime(int[][MAX], int, int); + +void main(void) +{ + int MAT[MAX][MAX], TRA[MAX][MAX]; + int FIL, COL; + do + { + printf("Ingrese el numero de filas de la matriz: "); + scanf("%d", &FIL); + } while (FIL > MAX || FIL < 1); + /* Se verifica que el número de filas sea correcto. */ + + do + { + printf("Ingrese el numero de columnas de la matriz: "); + scanf("%d", &COL); + } while (COL > MAX || COL < 1); + /* Se verifica que el número de columnas sea correcto. */ + + Lectura(MAT, FIL, COL); + Traspuesta(MAT, TRA, FIL, COL); + Imprime(TRA, COL, FIL); +} + +void Lectura(int A[][MAX], int F, int C) +/* Esta función se utiliza para una matriz de tipo entero de F filas y C +➥columnas. */ +{ + int I, J; + for (I = 0; I < F; I++) + for (J = 0; J < C; J++) + { + printf("Ingrese el elemento %d %d: ", I + 1, J + 1); + scanf("%d", &A[I][J]); + } +} + +void Traspuesta(int M1[][MAX], int M2[][MAX], int F, int C) +/* Esta función se utiliza para calcular la traspuesta. */ +{ + int I, J; + for (I = 0; I < F; I++) + for (J = 0; J < C; J++) + M2[J][I] = M1[I][J]; +} + +void Imprime(int A[][MAX], int F, int C) +/* Esta función se utiliza para escribir una matriz de tipo entero de F filas +➥y C columnas —en este caso la traspuesta. */ +{ + int I, J; + for (I = 0; I < F; I++) + for (J = 0; J < C; J++) + printf("\nElemento %d %d: %d", I + 1, J + 1, A[I][J]); +} diff --git a/6. Arreglos multidimensionales/Programas/Programa 6.9/Programa 6.9.c b/6. Arreglos multidimensionales/Programas/Programa 6.9/Programa 6.9.c new file mode 100644 index 0000000..454211b --- /dev/null +++ b/6. Arreglos multidimensionales/Programas/Programa 6.9/Programa 6.9.c @@ -0,0 +1,98 @@ +#include + +/* Asigna. +El programa, al recibir un arreglo bidimensional cuadrado, asigna elementos en +➥función del módulo (residuo) a un arreglo unidimensional. */ + +void Lectura(int[][10], int); +void Calcula(int[][10], float[], int); +void Imprime(float[10], int); +float Mod0(int[][10], int, int); +float Mod1(int[][10], int); /* Prototipos de funciones. */ +float Mod2(int[][10], int, int); + +void main(void) +{ + int MAT[10][10], TAM; + float VEC[10]; + + do + { + printf("Ingrese el tamaño de la matriz: "); + scanf("%d", &TAM); + } while (TAM > 10 || TAM < 1); + + Lectura(MAT, TAM); Calcula(MAT, VEC, TAM); + Imprime(VEC, TAM); +} +void Lectura(int A[][10], int N) +/* La función Lectura se utiliza para leer un arreglo bidimensional cuadrado +➥de tipo entero. */ +{ + int I, J; + for (I = 0; I < N; I++) + for (J = 0; J < N; J++) + { + printf("Ingrese el elemento %d %d: ", I + 1, J + 1); + scanf("%d", &A[I][J]); + } +} + +void Calcula(int A[][10], float B[], int N) +/* Esta función se utiliza tanto para calcular el módulo entre el índice del +➥arreglo unidimensional y 3, como para llamar a las funciones +➥correspondientes para resolver el problema. */ +{ + int I; + for (I = 0; I < N; I++) + switch (I % 3) + { + case 1: B[I] = Mod1(A, I); + break; + case 2: B[I] = Mod2(A, I, N); + break; + default: B[I] = Mod0(A, I, N); + break; + } +} + +float Mod0(int A[][10], int K, int M) +/* Esta función calcula el cociente entre una productoria y una sumatoria. */ +{ + int I; + float PRO = 1.0, SUM = 0.0; + for (I = 0; I < M; I++) + { + PRO *= A[I][K]; + SUM += A[I][K]; + } + return (PRO / SUM); +} + +float Mod1(int A[][10], int N) +/* Esta función obtiene el resultado de una sumatoria. */ +{ + int I; + float SUM = 0.0; + for (I = 0; I <= N; I++) + SUM += A[N][I]; + return (SUM); +} + +float Mod2(int A[][10], int N, int M) +/* Esta función obtiene el resultado de la productoria. */ +{ + int I; + float PRO = 1.0; + for (I = N; I < M; I++) + PRO *= A[I][N]; + return (PRO); +} + +void Imprime(float B[], int N) +/* Esta función se utiliza para escribir un arreglo unidimensional de tipo real de N elementos. */ +{ + int I; + for (I = 0; I < N; I++) + printf("\nElemento %d: %.2f", I, B[I]); +}