16/11/2022 ; 5:28 PM
This commit is contained in:
@@ -0,0 +1,44 @@
|
||||
#include <stdio.h>
|
||||
|
||||
/* 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]);
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
#include <stdio.h>
|
||||
|
||||
/* 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]);
|
||||
}
|
||||
@@ -0,0 +1,105 @@
|
||||
#include <stdio.h>
|
||||
|
||||
/* 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);
|
||||
}
|
||||
@@ -0,0 +1,109 @@
|
||||
#include <stdio.h>
|
||||
|
||||
/* 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);
|
||||
}
|
||||
@@ -0,0 +1,112 @@
|
||||
#include <stdio.h>
|
||||
|
||||
/* 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);
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
#include <stdio.h>
|
||||
|
||||
/* 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]);
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
#include <stdio.h>
|
||||
|
||||
/* 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);
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
#include <stdio.h>
|
||||
|
||||
/* 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);
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
#include <stdio.h>
|
||||
|
||||
/* 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);
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
#include <stdio.h>
|
||||
|
||||
/* 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]);
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
#include <stdio.h>
|
||||
|
||||
/* 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);
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
#include <stdio.h>
|
||||
|
||||
/* 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]);
|
||||
}
|
||||
@@ -0,0 +1,98 @@
|
||||
#include <stdio.h>
|
||||
|
||||
/* 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]);
|
||||
Reference in New Issue
Block a user