Universidad Autónoma de Nuevo León

Facultad de Ingeniería Mecánica y Eléctrica

Aplicación Práctica de la Programación

Fase 4: ARREGLOS UNI & BIDIMENSIONALES

Grupo: 10

Karla Patricia Uribe Sierra

Damian Alejandro Galván Gamboa 2118241
 INSTRUCCIÓN: ARREGLO LISTA [100]

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
int i, n
int lista[100]

Procedimiento:

"Ingresa el tamaño
de elementos\n"
for(i=1;i<=n;i++)
{
printf("Ingresa el
elemento %d\n",i);
scanf("%d",&list[i]);
}
lista();
for(i=1;i<=n;i++)
{
printf("Elemento
[%d]:
%d\n",i,list[i]);
}

Impresión:

"Elemento [%d]:
%d\n",i,list[i]
 INSTRUCCIÓN: SUMATORIA DE LOS ELEMENTOS DEL ARREGLO.

ANALISIS ALGORITMO CODIFICACION

Datos de
entrada:
void captura();
void proceso();
void lista();
int suma();
int i, n, r;
int list[10];
Procedimiento:
captura();
"Ingresa el
tamaño de
elementos\n"
proceso();
"Ingresa el
elemento
%d\n",i
lista();
for(i=1;i<=n;i++)
{
printf("Elemento
[%d]:
%d\n",i,list[i]);
}
suma();
for(i=0;i<=n; i++)
{
r += list[i];
}
return r;
Impresión:
"La suma de los
elementos es:
%d\n",r
 INSTRUCCIÓN: ELEMENTO MAYOR DE ARREGLO.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
void captura();
void mayor();
void imprimir();
int i, n, m;
int lista[100];

Procedimiento:
"Cual sera el tamaño de la
lista?\n"
for(i=1;i<=n;i++)
{

printf("Ingresa el
elemento [%d]\n",i);

scanf("%d",&lista[i]);
}
mayor();
m = lista[i];
for(i=1;i<=n;i++)
{
if(lista[i]>m)
{

m=lista[i];
}
}
imprimir();
for(i=1;i<=n;i++)
 {

printf("Elemento
[%d]: %d\n",i,lista[i]);
}
printf("Elemento
mayor = %d",m);

Impresión:
"Elemento mayor = %d",m
 INSTRUCCIÓN: BUSQUEDA DEL ELEMENTO EN EL ARREGLO.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
void captura();
void proceso();
void lista();
void busqueda();
int buscado, encontrado, pos,
i, n;
int list[100];

Procedimiento:
"Ingresa el tamaño de
elementos\n"
proceso();
for(i=1;i<=n;i++)
{
printf("Ingresa
el elemento %d\n",i);

scanf("%d",&list[i]);
}
busqueda();
do
{
buscado=0;
printf("Ingresa
un numero a buscar:\n");

scanf("%d",&buscado);

if(buscado==list[i])
 {

encontrado=1;

continue;

if(encontrado==1)
{

printf("Elemento
buscado %d esta en la lista en
la posicion:
%d\n",encontrado,i);
}
}
else
{

printf("Elemento no
encontrado, Quieres seguir
buscando\n");
}
}while(buscado!=1);
lista();
for(i=1;i<=n;i++)
{
printf("Elemento [%d]:
%d\n",i,list[i]);
}
Impresión:
"Elemento [%d]: %d\n",i,list[i]
 INSTRUCCION: ENCONTRAR LOS 4 NUMEROS PERFECTOS, ALMACENARLOS E IMPRIMIRLOS.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
#define CANTIDAD_PERFECTOS 4
void encontrar_y_almacenar(int
arregloPerfectos[]);
void imprimir_perfectos(const int
arregloPerfectos[]);
int
perfectos[CANTIDAD_PERFECTOS];

Procedimiento:
encontrar_y_almacenar(perfectos);
imprimir_perfectos(perfectos);
void encontrar_y_almacenar(int
arregloPerfectos[]) {
int primos_p[] = {2, 3, 5, 7};
printf("Calculando los %d
numeros perfectos...\n",
CANTIDAD_PERFECTOS);
for (int k = 0; k <
CANTIDAD_PERFECTOS; k++) {
int p = primos_p[k];
long long mersenne_p = pow(2,
p) - 1;
long long perfecto_k = pow(2, p
- 1) * mersenne_p;
arregloPerfectos[k] =
(int)perfecto_k;
}
}
void imprimir_perfectos(const int
arregloPerfectos[]) {
printf("\n--- Resultados
Almacenados en el Arreglo ---\n");
for (int i = 0; i <
CANTIDAD_PERFECTOS; i++) {
printf("Perfecto #%d: %d\n", i +
1, arregloPerfectos[i]);
}
printf("---------------------------------
-----------\n");
}
Impresión:
"Perfecto #%d: %d\n", i + 1,
arregloPerfectos[i]
 INSTRUCCIÓN: CARGAR UNA MATRIZ CUADRADA.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
int i,j,n;
int matriz [10][10];
void captura();
void imprimir();

Procedimiento:
void captura()
{
printf("Ingresa el
tamaño del arreglo:\n");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
printf("Ingresa elemento
a la
matriz[%d,%d]\n",i,j);
scanf("%d",&matriz[i][j]);
}
}
imprimir();
}
void imprimir()
{
printf("----------------\n");
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
printf("%d\t",matriz[i][j]);
}
printf("\n");
}
}

Impresión:
("%d\t",matriz[i][j])
 INSTRUCCION: SUMA DE DIAGONAL PRINCIPAL DE UNA MATRIZ.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
int i, n, j, suma = 0;
int matriz[10][10];
void captura();
void imprimir();
void imprimirdi();
void
sumadiagonal();
Procedimiento:
void captura()
{
printf("Ingresa el
tamaño del
arreglo (maximo
10): ");
scanf("%d", &n);

if(n > 10 || n < 1)

{
printf("Error: El
tamaño debe
estar entre 1 y
10\n");
captura();
return;
}

for(i = 0; i < n;
i++)
{
 for(j = 0; j < n;
j++){printf("Ingresa
elemento a la
matriz[%d,%d]: ", i
+ 1, j + 1);
scanf("%d",
&matriz[i][j]);
}
}
imprimir();
}
void imprimir()
{
printf("\n---
MATRIZ
COMPLETA ---
\n");for(i = 0; i < n;
i++) {for(j = 0; j < n;
j++)
{printf("%d\t",
matriz[i][j]);}
printf("\n");
}
imprimirdi();
}
void imprimirdi()
{printf("\n---
DIAGONAL
PRINCIPAL ---\n");
for(i = 0; i < n;
i++)
{printf("Elemento
diagonal [%d,%d]:
%d\n", i + 1, i + 1,
matriz[i][i]);
}
sumadiagonal();
}
void
sumadiagonal()
{
printf("\n---
SUMA ---\n");
suma = 0;

for(i = 0; i < n;
i++)
{
suma = suma
+ matriz[i][i];
}
printf("La suma de
los elementos de
la diagonal
principal es:
%d\n", suma);
}

Impresión:
("La suma de los
elementos de la
diagonal principal
es: %d\n", suma)
 INSTRUCCIÓN: LEER UNA MATRIZ CUADRADA, QUE SUME LA DIAGONAL SECUNDARIA Y LA IMPRIMA.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
int i, n, j, suma = 0;
int matriz[10][10];
void captura();
void imprimir();
void
imprimirDiagonalSecundaria();
void
sumarDiagonalSecundaria();

Procedimiento:
void captura
"Ingresa el tamaño del arreglo
(maximo 10): "
if(n > 10 || n < 1)
"Error: El tamaño debe estar
entre 1 y 10\n"
captura();
return;
for(i = 0; i < n; i++)
for(j = 0; j < n; j++)
"Ingresa elemento a la
matriz[%d,%d]: ", i + 1, j + 1
void imprimir
for(i = 0; i < n; i++)
for(j = 0; j < n; j++)
"%d\t", matriz[i][j]
void
imprimirDiagonalSecundaria
for(i = 0; i < n; i++)
"Elemento diagonal
secundaria [%d,%d]: %d\n",i +
1, n - i, matriz[i][n - 1 - i]
void
sumarDiagonalSecundaria
suma = 0;
for(i = 0; i < n; i++)
suma = suma + matriz[i][n - 1 -
i];

Impresión:
"La suma de los elementos de
la diagonal secundaria es:
%d\n", suma
 INSTRUCCIÓN: CARGAR UNA MATRIZ DE DIFERENTE DIMENSION.Y SUME LOS ELEMENTOS.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
int matriz[10][10];
void
cargar_matriz(int
filas, int columnas);
void
imprimir_matriz(int
filas, int columnas);
long
sumar_elementos(int
filas, int columnas);
int filas, columnas;
long suma;

Procedimiento:
"Ingrese el numero
de filas: "
"Ingrese el numero
de columnas: "
void
cargar_matriz(int
filas, int columnas)
for (int i = 0; i < filas;
i++)
for (int j = 0; j <
columnas; j++)
"Ingrese el elemento
en [%d][%d]: ", i+1,
j+1
void
imprimir_matriz(int
filas, int columnas)
for (int i = 0; i < filas;
i++)
for (int j = 0; j <
columnas; j++)
"%d\t", matriz[i][j]
long
sumar_elementos(int
filas, int columnas)
for (int i = 0; i < filas;
i++)
for (int j = 0; j <
columnas; j++)
suma += matriz[i][j];
return suma;

Impresión:
"LA SUMA TOTAL DE
TODOS LOS
ELEMENTOS ES:
%ld\n", suma
 INSTRUCCIÓN: TABLA CALIFICACIONES PORCENTAJE.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
#define MAX_ALUMNOS 50
#define MAX_CALIFICACIONES 5
float calificaciones_matriz
[MAX_ALUMNOS][MAX_CALIFICACIO
NES];
void capturar_calificaciones(int*
n_alumnos, int* n_calificaciones);
void imprimir_tabla_porcentaje(int
n_alumnos, int n_calificaciones);
int n_alumnos = 0;
int n_calificaciones = 0;

Procedimiento:
void capturar_calificaciones(int*
n_alumnos, int* n_calificaciones)
"\nIngrese el numero de alumnos
(Max %d): ", MAX_ALUMNOS
"Ingrese el numero de calificaciones
por alumno (Max %d): ",
MAX_CALIFICACIONES)
if (*n_alumnos <= 0 || *n_alumnos >
MAX_ALUMNOS || *n_calificaciones
<= 0 || *n_calificaciones >
MAX_CALIFICACIONES)
"\n--- Ingrese las calificaciones (ej.
0.8 para 80%%) ---\n"
for (int i = 0; i < *n_alumnos; i++)
for (int j = 0; j < *n_calificaciones; j++)
"Alumno %d, Calificacion %d: ", i + 1,
j+1

Impresión:
for (int j = 0; j < n_calificaciones; j++)
"\tC%d", j + 1
for (int i = 0; i < n_alumnos; i++)
"A%d\t|", i + 1
for (int j = 0; j < n_calificaciones; j++)
"\t%.2f%%",
calificaciones_matriz[i][j] * 100.0
 INSTRUCCIÓN: Almacenar los números del 1 al 100 en un arreglo unidimensional e imprimirlos.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
void llenar_arreglo(int
arreglo[], int tamano);
void
imprimir_arreglo(const
int arreglo[], int
tamano);
int
numeros[tamanoa];

Procedimiento:
void llenar_arreglo(int
arreglo[], int tamano)
for (int i = 0; i <
tamano; i++)
arreglo[i] = i + 1
void
imprimir_arreglo(const
int arreglo[], int
tamano)
for (int i = 0; i <
tamano; i++)
"%d", arreglo[i]
if ((i + 1) % 10 == 0)
"\n"
else
", "

Impresión:
int arreglo[], int
tamano)
for (int i = 0; i <
tamano; i++)
"%d", arreglo[i]
if ((i + 1) % 10 == 0)
"\n"
else
", "
 INSTRUCCIÓN: Leer “N” números, almacenarlos en un arreglo y posteriormente imprimirlos.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
#define MAX_NUMEROS 100
void leer_numeros(int
arreglo[], int* n);
void imprimir_numeros(const
int arreglo[], int n);
intnumeros[MAX_NUMEROS];
int n = 0;

Procedimiento:
main()
"--- Leer N Numeros (Maximo
100), Almacenarlos e
Imprimirlos ---\n"
leer_numeros(numeros, &n);
if (n > 0)
imprimir_numeros(numeros,
n);
void leer_numeros(int
arreglo[], int* n)
"Ingrese cuantos numeros (N)
desea almacenar (Maximo
100): "
if (*n <= 0 || *n >
MAX_NUMEROS)
"Error: La cantidad debe ser
positiva y no exceder 100.\n"
*n = 0;
return;
"\n--- Ingrese los %d numeros
---\n", *n
for (int i = 0; i < *n; i++)
"Numero %d: ", i + 1
void imprimir_numeros(const
int arreglo[], int n)
for (int i = 0; i < n; i++)
"%d", arreglo[i]
if (i < n - 1)
", "

Impresión:
for (int i = 0; i < *n; i++)
"Numero %d: ", i + 1
void imprimir_numeros(const
int arreglo[], int n)
for (int i = 0; i < n; i++)
"%d", arreglo[i]
if (i < n - 1)
", "
 INSTRUCCIÓN: Leer “N” números, almacenarlos en un arreglo y posteriormente imprimirlos en forma inversa a como fueron leídos.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
void capturarNumeros(int
arreglo[], int* n);
void imprimirInverso(int
arreglo[], int n);
int numeros[100];
int cantidad = 0;

Procedimiento:
capturarNumeros(numeros,
&cantidad);
imprimirInverso(numeros,
cantidad);
void capturarNumeros(int
arreglo[], int* n)
"Ingrese la cantidad de
números (máximo 100): "
if (*n <= 0 || *n > 100)
"Cantidad inválida. Debe
estar entre 1 y 100.\n"
*n = 0;
return;
for (int i = 0; i < *n; i++)
"Número %d: ", i + 1
"%d", &arreglo[i]
void imprimirInverso(int
arreglo[], int n)
if (n == 0)
"No hay números para
mostrar.\n"
return;

Impresión:
"\n--- Números en orden
inverso ---\n"
for (int i = n - 1; i >= 0; i--)
"%d ", arreglo[i]
 INSTRUCCION: Leer “N” números e imprimir cual es el mayor y en que posición se encuentra.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
void leer_numeros(int
arreglo[], int *n_ptr);
void
encontrar_mayor(const int
arreglo[], int n);
int numeros[100];
int n = 0;

Procedimiento:
leer_numeros(numeros,
&n);
if (n > 0)
encontrar_mayor(numeros,
n);
void leer_numeros(int
arreglo[], int *n_ptr)
"Ingrese cuantos numeros
(N) desea almacenar
(Maximo 100): "
if (*n_ptr <= 0 || *n_ptr >
100)
"Error: La cantidad debe
ser positiva y no exceder
100.\n"
*n_ptr = 0;
return;
"\n--- Ingrese los %d
numeros ---\n", *n_ptr
for (int i = 0; i < *n_ptr; i++)
"Numero %d: ", i + 1
"%d", &arreglo[i]
void
encontrar_mayor(const int
arreglo[], int n)
int mayor = arreglo[0];
int posicion = 0;
for (int i = 1; i < n; i++)
if (arreglo[i] > mayor)
mayor = arreglo[i];
posicion = i;

Impresión:
"El numero MAYOR
ingresado es: %d\n", mayor
"Se encuentra en la
posicion (indice base 1):
%d\n", posicion + 1
 INSTRUCCIÓN: Leer “N” números primeramente y almacenarlos, después introducir un número cualquiera e imprimir si ya se había
capturado o no anteriormente.
ANALISIS ALGORITMO CODIFICACION
Datos de entrada:
void leer_numeros(int
arreglo[], int *n_ptr);
int buscar_numero(const int
arreglo[], int n, int
valor_buscado);
void
procesar_busqueda(const int
arreglo[], int n);
int numeros[100];
int n = 0;

Procedimiento:
leer_numeros(numeros, &n);
if (n > 0)
procesar_busqueda(numeros,
n)
voidleer_numeros(int
arreglo[], int *n_ptr)
"Ingrese cuantos numeros (N)
deseaalmacenar(Maximo100):
if (*n_ptr <= 0 || *n_ptr > 100)
"Error: La cantidad debe ser
positiva y no exceder 100.\n"
*n_ptr = 0;
return;
"\n--- Ingrese los %d numeros
---\n", *n_ptr
for (int i = 0; i < *n_ptr; i++)
"Numero %d: ", i + 1
"%d", &arreglo[i]
buscar_numero(const int
arreglo[], int n, int
valor_buscado)
for (int i = 0; i < n; i++)
if (arreglo[i] == valor_buscado)
return i;
return -1
voidprocesar_busqueda(const
int arreglo[], int n)
int numero_buscar;
int indice_encontrado;
"Ingrese el numero que desea
buscar en el arreglo: "
"%d", &numero_buscar
indice_encontrado =
buscar_numero(arreglo, n,
numero_buscar);
if (indice_encontrado != -1)

Impresión:
"El numero %d SI fue
capturado anteriormente.\n",
numero_buscar
"Se encuentra en la posicion
(indice base 1): %d\n",
indice_encontrado + 1
else
"El numero %d NO fue
capturado anteriormente.\n",
numero_buscar
 INSTRUCCIÓN: Leer “N” números, para posteriormente ordenarlos ascendentemente (método del apuntador) e imprimirlos ya
ordenados.
ANALISIS ALGORITMO CODIFICACION
Datos de entrada:
void leer_n_dimension(int
*n_ptr);
void leer_numeros(int
arreglo[], int n);
void ordenar_burbuja(int
arreglo[], int n);
void
imprimir_numeros(const int
arreglo[], int n);
int numeros[100];
int n = 0;

Procedimiento:
leer_n_dimension(&n);
if (n <= 0 || n > 100)
"Error: La cantidad debe ser
positiva y no exceder 100.\n"
return 1;
leer_numeros(numeros, n);
ordenar_burbuja(numeros,
n);
imprimir_numeros(numeros,
n);
void leer_n_dimension(int
*n_ptr)
"Ingrese cuantos numeros
(N) desea almacenar: "
"%d", n_ptr
void leer_numeros(int
arreglo[], int n)
"\n--- Ingrese los %d
numeros ---\n", n
for (int i = 0; i < n; i++)
"Numero %d: ", i + 1
"%d", &arreglo[i]
void ordenar_burbuja(int
arreglo[], int n)
int temp;
for (int i = 0; i < n - 1; i++)
for (int j = 0; j < n - i - 1; j++)
if (arreglo[j] > arreglo[j + 1])
temp = arreglo[j];
arreglo[j] = arreglo[j + 1];
arreglo[j + 1] = temp;
"\nArreglo ordenado
ascendentemente.\n"

Impresión:
void
imprimir_numeros(const int
arreglo[], int n)
"\n--- Numeros Ordenados -
--\n"
for (int i = 0; i < n; i++)
"%d", arreglo[i]
if (i < n - 1)
printf(", ");
 INSTRUCCION: Leer “N” números, calcular el promedio e imprimir lo siguiente: • Números mayores que el promedio. • Números
menores que el promedio. • Números mayores que el promedio y pares. • Números menores que el promedio y pares. • Números
mayores que el promedio e impares. • Números menores que el promedio e impares.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
void leer_n_dimension(int
*n_ptr);
void leer_numeros(int arreglo[],
int n);
float calcular_promedio(const
int arreglo[], int n);
void
clasificar_e_imprimir(const int
arreglo[], int n, float promedio);
int numeros[100];
int n = 0;
float promedio = 0.0f;

Procedimiento:
leer_n_dimension(&n)
if (n <= 0 || n > = 100)
"Error: La cantidad debe ser
positiva y no exceder 100.\n"
return 1;
leer_numeros(numeros, n);
promedio =
calcular_promedio(numeros,
n);
printf("\n--> El promedio
calculado es: %.2f\n",
promedio);
clasificar_e_imprimir(numeros,
n, promedio);
void leer_n_dimension(int
*n_ptr)
"Ingrese cuantos numeros (N)
desea almacenar: "
"%d", n_ptr
void leer_numeros(int arreglo[],
int n)
"\n--- Ingrese los %d numeros -
--\n", n
for (int i = 0; i < n; i++)
"Numero %d: ", i + 1
"%d", &arreglo[i]
float calcular_promedio(const
int arreglo[], int n)
long long suma = 0;
for (int i = 0; i < n; i++)
suma += arreglo[i];
return (float)suma / n;

Impresión:
void
clasificar_e_imprimir(const int
arreglo[], int n, float promedio)
"\n1. Numeros MAYORES que
el promedio (%.2f):\n",
promedio
for (int i = 0; i < n; i++)
if (arreglo[i] > promedio)
"%d ", arreglo[i]
"\n2. Numeros MENORES que
el promedio (%.2f):\n",
promedio
for (int i = 0; i < n; i++)
if (arreglo[i] < promedio)
"%d ", arreglo[i]
"\n3. Numeros MAYORES que
el promedio Y PARES:\n"
for (int i = 0; i < n; i++)
if (arreglo[i] > promedio &&
arreglo[i] % 2 == 0)
printf("%d ", arreglo[i])
"\n4. Numeros MENORES que
el promedio Y PARES:\n"
for (int i = 0; i < n; i++)
if (arreglo[i] < promedio &&
arreglo[i] % 2 == 0)
printf("%d ", arreglo[i]
"\n5. Numeros MAYORES que
el promedio E IMPARES:\n"
for (int i = 0; i < n; i++)
if (arreglo[i] > promedio &&
arreglo[i] % 2 != 0)
"%d ", arreglo[i]
"\n6. Numeros MENORES que
el promedio E IMPARES:\n"
for (int i = 0; i < n; i++)
if (arreglo[i] < promedio &&
arreglo[i] % 2 != 0)
"%d ", arreglo[i]
 INSTRUCCIÓN: Calcular e imprimir la desviación estándar de “N” números.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
void leer_n_dimension(int *n_ptr);
void leer_numeros(float arreglo[], int n);
float calcular_promedio(const float
arreglo[], int n);
float
calcular_desviacion_estandar(const
float arreglo[], int n, float promedio);
float numeros[100];
int n = 0;
float promedio = 0.0f;
float desviacion = 0.0f;

Procedimiento:
main()
leer_n_dimension(&n)
if (n < 2 || n > 100)
"Error: La cantidad debe ser mayor o
igual a 2 y no exceder 100.\n"
return 1;
leer_numeros(numeros, n);
promedio =
calcular_promedio(numeros, n);
"\n--> Promedio (prom) calculado:
%.4f\n", promedio
desviacion =
calcular_desviacion_estandar(numeros,
n, promedio);
return 0;
void leer_n_dimension(int *n_ptr)
"Ingrese la cantidad de numeros (N)
para el calculo: "
"%d", n_ptr
void leer_numeros(float arreglo[], int n)
"\n--- Ingrese los %d numeros ---\n", n
for (int i = 0; i < n; i++)
"Numero %d: ", i + 1
"%f", &arreglo[i]
float calcular_promedio(const float
arreglo[], int n)
double suma = 0.0;
for (int i = 0; i < n; i++)
suma += arreglo[i];
return (float)(suma / n);
float
calcular_desviacion_estandar(const
float arreglo[], int n, float promedio)
double suma_diferencias_cuadrado =
0.0;
float varianza;
for (int i = 0; i < n; i++)
float diferencia = arreglo[i] - promedio;
suma_diferencias_cuadrado +=
(diferencia * diferencia);
varianza =
(float)(suma_diferencias_cuadrado / (n -
1));
return sqrt(varianza);

Impresión:
"La DESVIACION ESTANDAR MUESTRAL
(Desv_est) es: %.4f\n", desviacion
 INSTRUCCIÓN: Almacenar los primeros 20 números primos en un vector e imprimirlos comenzando del último al primero.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
bool es_primo(int numero);
void buscar_y_almacenar(int
arreglo_primos[], int
cantidad);
void imprimir_inverso(const
int arreglo_primos[], int
cantidad);

Procedimiento:
main()
int primos[20];
buscar_y_almacenar(primos,
20);
imprimir_inverso(primos,
20);
return 0;
bool es_primo(int numero)
if (numero <= 1)
return false;
for (int i = 2; i * i <= numero;
i++)
if (numero % i == 0)
return false;
return true;
void buscar_y_almacenar(int
arreglo_primos[], int
cantidad)
int contador = 0;
int numero_actual = 2;
"\nBuscando los %d
numeros primos...\n",
cantidad
while (contador < cantidad)
if (es_primo(numero_actual))
arreglo_primos[contador] =
numero_actual;
contador++;
numero_actual++;

Impresión:
void imprimir_inverso(const
int arreglo_primos[], int
cantidad)
"\n--- Numeros Primos en
Orden INVERSO ---\n"
for (int i = cantidad - 1; i >= 0;
i--)
"%d", arreglo_primos[i]
if (i > 0)
", "
 INSTRUCCION: Encontrar los primeros 4 números perfectos y almacenarlos en un arreglo unidimensional e imprimirlos.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
int n=4;
void encontrar_y_almacenar(int
arregloPerfectos[]);
void imprimir_perfectos(const int
arregloPerfectos[]);

Procedimiento:
main()
int perfectos[n];
encontrar_y_almacenar(perfectos);
imprimir_perfectos(perfectos);
void encontrar_y_almacenar(int
arregloPerfectos[])
int primos_p[] = {2, 3, 5, 7};
for (int k = 0; k < n; k++)
int p = primos_p[k];
long long mersenne_p = pow(2, p) -
1;
long long perfecto_k = pow(2, p - 1)
* mersenne_p;
arregloPerfectos[k] =
(int)perfecto_k;
void imprimir_perfectos(const int
arregloPerfectos[])

Impresión:
for (int i = 0; i < n; i++)
"Perfecto #%d: %d\n", i + 1,
arregloPerfectos[i]
 INSTRUCCIÓN: Leer las calificaciones de “N” alumnos e imprimir cuantos alumnos obtuvieron las tres más altas calificaciones.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
void leer_n_dimension(int *n_ptr);
void leer_calificaciones(float
arreglo[], int n);
void ordenar_descendente(float
arreglo[], int n);
void contar_tres_altas(const float
arreglo[], int n);

Procedimiento:
main()
float calificaciones[100];
int n = 0;
leer_n_dimension(&n);
if (n <= 0 || n > 100)
"Error: La cantidad de alumnos debe
ser positiva y no exceder 100.\n"
return 1;
if (n < 3)
"Advertencia: Se necesitan al menos
3 alumnos para determinar las TRES
mas altas.\n"
leer_calificaciones(calificaciones, n);
ordenar_descendente(calificaciones,
n);
contar_tres_altas(calificaciones, n);
void leer_n_dimension(int *n_ptr)
"Ingrese el numero de alumnos: "
"%d", n_ptr
void leer_calificaciones(float
arreglo[], int n)
"\n--- Ingrese las calificaciones de
los %d alumnos ---\n", n
for (int i = 0; i < n; i++)
"Calificacion Alumno %d: ", i + 1
"%f", &arreglo[i]
void ordenar_descendente(float
arreglo[], int n)
float temp;
for (int i = 0; i < n - 1; i++)
for (int j = 0; j < n - i - 1; j++)
if (arreglo[j] < arreglo[j + 1])
temp = arreglo[j]
arreglo[j] = arreglo[j + 1]
arreglo[j + 1] = temp
void contar_tres_altas(const float
arreglo[], int n)
if (n == 0) return;
float primera_mejor = arreglo[0];
float segunda_mejor = (n > 1) ?
arreglo[1] : arreglo[0];
float tercera_mejor = (n > 2) ?
arreglo[2] : arreglo[0];
int contador = 0;
for (int i = 0; i < n; i++)
float calificacion_actual = arreglo[i];
if (calificacion_actual ==
primera_mejor || calificacion_actual
== segunda_mejor ||
calificacion_actual == tercera_mejor)
contador++;
Impresión:
"La TERCERA calificacion mas alta
es: %.2f\n", tercera_mejor
"La SEGUNDA calificacion mas alta
es: %.2f\n", segunda_mejor
"La MEJOR calificacion es: %.2f\n",
primera_mejor
"Total de alumnos que obtuvieron
una de las tres mejores: %d\n",
contador
 INSTRUCCIÓN: Almacenar “N” números en un arreglo unidimensional e imprimirlo, pero eliminando los elementos duplicados.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
void leer_n_dimension(int *n_ptr);
void leer_numeros(int arreglo[], int n);
int eliminar_duplicados(const int
original[], int n_original, int resultado[]);
void imprimir_numeros(const int
arreglo[], int n);

Procedimiento:
main()
int numeros_originales[100];
int numeros_unicos[100];
int n = 0;
int n_unicos;
leer_n_dimension(&n);
if (n <= 0 || n > 100)
"Error: La cantidad debe ser positiva y no
exceder 100.\n"
return 1;
leer_numeros(numeros_originales, n);
n_unicos =
eliminar_duplicados(numeros_originales,
n, numeros_unicos);
imprimir_numeros(numeros_unicos,
n_unicos);
return 0;
void leer_n_dimension(int *n_ptr)
"Ingrese cuantos numeros desea
almacenar: "
"%d", n_ptr
void leer_numeros(int arreglo[], int n)
"\n--- Ingrese los %d numeros ---\n", n
for (int i = 0; i < n; i++)
"Numero %d: ", i + 1
"%d", &arreglo[i]
int eliminar_duplicados(const int
original[], int n_original, int resultado[])
int n_unicos = 0;
int es_duplicado;
for (int i = 0; i < n_original; i++)
es_duplicado = 0;
for (int j = 0; j < n_unicos; j++)
if (original[i] == resultado[j])
es_duplicado = 1;
break;
if (es_duplicado == 0)
resultado[n_unicos] = original[i];
n_unicos++;
return n_unicos;

Impresión:
"\n--- Numeros Unicos (Sin Duplicados) -
--\n"
for (int i = 0; i < n; i++)
"%d", arreglo[i]
if (i < n - 1)
", "
 INSTRUCCION: Elaborar el procedimiento que obtenga la diferencia más grande entre dos elementos consecutivos.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
void leer_n_dimension(int *n_ptr);
void leer_numeros(int arreglo[], int n);
void
calcular_diferencia_maxima(const int
arreglo[], int n);

Procedimiento:
main()
int numeros[100];
int n = 0;
leer_n_dimension(&n);
if (n <= 1 || n > 100)
"Error: Se necesitan al menos 2
numeros y no exceder 100.\n"
leer_numeros(numeros, n);
calcular_diferencia_maxima(numeros,
n);
void leer_n_dimension(int *n_ptr)
"Ingrese cuantos numeros desea
almacenar: "
"%d", n_ptr
void leer_numeros(int arreglo[], int n)
"\n--- Ingrese los %d numeros ---\n", n
for (int i = 0; i < n; i++)
"Numero %d: ", i + 1
"%d", &arreglo[i]
void
calcular_diferencia_maxima(const int
arreglo[], int n)
int diferencia_maxima;
int diferencia_actual;
int indice_i = 0;
int indice_j = 1;
diferencia_maxima = abs(arreglo[1] -
arreglo[0]);
for (int i = 1; i < n - 1; i++)
diferencia_actual = abs(arreglo[i + 1] -
arreglo[i]);
if (diferencia_actual >
diferencia_maxima)
diferencia_maxima =
diferencia_actual;
indice_i = i;
indice_j = i + 1;

Impresión:
"La diferencia mas grande entre
elementos CONSECUTIVOS es: %d\n",
diferencia_maxima
"Se encontro entre los numeros: %d
(posicion %d) y %d (posicion %d)\n",
arreglo[indice_i], indice_i + 1,
arreglo[indice_j], indice_j + 1);
 INSTRUCCIÓN: Introducir un número entero e imprimir su equivalente en octal.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
int leer_entero();
long long convertir_a_octal(int n);
void imprimir_octal(int n_original,
long long octal);

Procedimiento:
main()
int numero_decimal;
long long numero_octal;
numero_decimal = leer_entero();
if (numero_decimal < 0)
"Error: Ingrese un numero entero
positivo.\n"
return 1;
numero_octal =
convertir_a_octal(numero_decimal);
imprimir_octal(numero_decimal,
numero_octal);
int leer_entero()
int n;
"Ingrese un numero entero
positivo:"
"%d", &n
return n;
long long convertir_a_octal(int n)
long long octal = 0;
int residuo;
int i = 1;
if (n == 0)
return 0;
while (n != 0)
residuo = n % 8;
n /= 8;
octal += residuo * i;
i *= 10;
return octal;

Impresión:
void imprimir_octal(int n_original,
long long octal)
"El numero decimal %d\n",
n_original
"Tiene como equivalente OCTAL
(base 8): %lld\n", octal
 INSTRUCCIÓN: Dado los valores estadísticos para un vector X compuesto de “N” elementos calcular la desviación media.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
void leer_n_dimension(int *n_ptr);
void leer_numeros(float arreglo[], int
n);
float calcular_promedio(const float
arreglo[], int n);
float
calcular_desviacion_media(const
float arreglo[], int n, float promedio);

Procedimiento:
main()
float numeros[100];
int n = 0;
float promedio = 0.0f;
float desviacion_media = 0.0f;
leer_n_dimension(&n);
if (n <= 0 || n > 100)
"Error: La cantidad debe ser positiva y
no exceder 100.\n"
leer_numeros(numeros, n);
promedio =
calcular_promedio(numeros, n);
desviacion_media =
calcular_desviacion_media(numeros,
n, promedio);
void leer_n_dimension(int *n_ptr)
"Ingrese la cantidad de numeros para
el calculo: "
"%d", n_ptr
void leer_numeros(float arreglo[], int
n)
"\n--- Ingrese los %d numeros ---\n", n
for (int i = 0; i < n; i++)
"Numero %d: ", i + 1
"%f", &arreglo[i]
float calcular_promedio(const float
arreglo[], int n)
double suma = 0.0;
for (int i = 0; i < n; i++)
suma += arreglo[i];
return (float)(suma / n);
float
calcular_desviacion_media(const
float arreglo[], int n, float promedio)
double suma_diferencias_absolutas
= 0.0;
for (int i = 0; i < n; i++)
float diferencia = arreglo[i] -
promedio;
suma_diferencias_absolutas +=
fabsf(diferencia);
return
(float)(suma_diferencias_absolutas /
n);

Impresión:
"\n--> Promedio (prom) calculado:
%.4f\n", promedio
"La DESVIACION MEDIA
(Desv_media) es: %.4f\n",
desviacion_media
 INSTRUCCIÓN: Dado los valores estadísticos para un vector X compuesto de “N” elementos calcular la raíz del valor cuadrático
medio.
ANALISIS ALGORITMO CODIFICACION
Datos de entrada:
int n, i;

Procedimiento:
"Introduce el numero de
elementos (N): "
"%d", &n
if (n <= 0)"El numero de
elementos debe ser
positivo.\n"float
X[n];"Introduce los %d
elementos del
vector:\n", n
for (i = 0; i < n; i++)
Elemento X[%d]: ", i
"%f", &X[i]
float suma_cuadrados =
0.0;
for (i = 0; i < n; i++)
suma_cuadrados += X[i]
* X[i];
float media_cuadrados
= suma_cuadrados /
(float)n;
float rms =
sqrt(media_cuadrados);

Impresión:
"La Raiz del Valor
Cuadratico Medio (RMS)
es: %.4f\n", rms
 INSTRUCCIÓN: Dado los valores estadísticos para un vector X compuesto de “N” elementos calcular el medio armónico.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
int n, i;

Procedimiento:
"Introduce el
numero de
elementos (N): "
"%d", &n
if (n <= 0)
"El numero de
elementos debe
ser positivo.\n"
float X[n];
"Introduce los %d
elementos del
vector (ninguno
puede ser 0):\n", n
for (i = 0; i < n; i++)
"Elemento X[%d]:
", i
"%f", &X[i]
if (X[i] == 0.0)
"\nError: El medio
armonico no esta
definido para
valores de
cero.\n"
"El programa
terminara.\n"
exit(1);
float
suma_reciprocos
= 0.0;
for (i = 0; i < n; i++)
suma_reciprocos
+= 1.0 / X[i];
float
medio_armonico
= (float)n /
suma_reciprocos;

Impresión:
"El Medio
Armonico es:
%.4f\n",
medio_armonico
 INSTRUCCIÓN: Leer una matriz en la cual el número de columnas sea igual al de filas y posteriormente imprimirla.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
int i,j, n;
int matriz[10][10];
void captura();
void imprimir();

Procedimiento:
main()
captura();
imprimir();
void captura()
"Ingrese el
tamano del
arreglo: "
"%d", &n
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
"Ingrese elemento
[%d][%d]: ", i, j
"%d", &matriz[i][j]

Impresión:
void imprimir()
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
"%d\t", matriz[i][j]
 INSTRUCCION: Leer una matriz en la cual el número de columnas sea igual al de filas, imprimir el elemento mayor y en que casilla
se ubica.
ANALISIS ALGORITMO CODIFICACION
Datos de
entrada:
int i,j, n;
int
matriz[10][10];
void captura();
void imprimir();
void
encontrarMax();

Procedimiento:
main()
captura();
imprimir();
encontrarMax();
void captura()
"Ingrese el
tamano del
arreglo: "
"%d", &n
for(i=1; i<=n;
i++)
for(j=1; j<=n;
j++)
"Ingrese
elemento
[%d][%d]: ", i, j
"%d",
&matriz[i][j]
void
encontrarMax()
int max =
matriz[1][1];
int fila_max = 1;
int col_max = 1;
for (i = 1; i <= n;
i++)
for (j = 1; j <= n;
j++)
if (matriz[i][j] >
max)
max =
matriz[i][j];
fila_max = i;
col_max = j;
void imprimir()
for(i=1; i<=n;
i++)
for(j=1; j<=n;
j++)
"%d\t",
matriz[i][j]

Impresión:
"El elemento
mayor es %d y
esta en la
casilla
[%d][%d].\n",
max, fila_max,
col_max
 INSTRUCCIÓN: Leer una matriz cuadrada, calcular e imprimir el promedio de los elementos.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
int i,j, n;
int matriz[10][10];
void captura();
void imprimir();
void promMat();

Procedimiento:
main()
captura();
imprimir();
promMat();
void captura()
"Ingrese el tamano
del arreglo: "
"%d", &n
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
"Ingrese elemento
[%d][%d]: ", i, j
"%d", &matriz[i][j]
void promMat()
float suma = 0;
int total_elementos
= n * n;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
suma += matriz[i][j];
float prom = suma /
total_elementos;
void imprimir()
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
"%d\t", matriz[i][j]

Impresión:
"El promedio es:
%.2f\n", prom
 INSTRUCCIÓN: Desarrollar el procedimiento el cual intercambie los valores de las diagonales de una matriz.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
int i,j, n;
int matriz[10][10];
void captura();
void imprimir();
void
intercambiarDiagonales();

Procedimiento:
main()
captura();
"--- Matriz Original ---\n"
imprimir();
intercambiarDiagonales();
"--- Matriz Modificada ---
\n"
imprimir();
void captura()
"Ingrese el tamano del
arreglo: "
"%d", &n
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
"Ingrese elemento
[%d][%d]: ", i, j
"%d", &matriz[i][j]
void
intercambiarDiagonales()
int j_sec;
int temp;
for (i = 1; i <= n; i++)
j_sec = (n + 1) - i;
temp = matriz[i][i];
matriz[i][i] =
matriz[i][j_sec];
matriz[i][j_sec] = temp;
void imprimir()
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
"%d\t", matriz[i][j]
"\n"

Impresión:
"--- Matriz Original ---\n"
imprimir();
intercambiarDiagonales();
"--- Matriz Modificada ---
\n"
imprimir();
 INSTRUCCIÓN: Desarrollar el procedimiento el cual acomode los elementos de las diagonales en un arreglo unidimensional sin
repetir ninguna casilla.
ANALISIS ALGORITMO CODIFICACION
Datos de entrada:
int i,j, n;
int matriz[10][10];
void captura();
void imprimir();
void
diagonalesEnArreglo();

Procedimiento:
main()
captura();
imprimir();
diagonalesEnArreglo();
void captura()
"Ingrese el tamano del
arreglo: "
"%d", &n
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
"Ingrese elemento
[%d][%d]: ", i, j
"%d", &matriz[i][j]
void
diagonalesEnArreglo()
int arr[20];
int k = 0;
int j_sec;
for (i = 1; i <= n; i++)
arr[k] = matriz[i][i];
k++;
for (i = 1; i <= n; i++)
j_sec = (n + 1) - i;
if (i != j_sec)
arr[k] = matriz[i][j_sec];
k++;
"Arreglo
unidimensional con las
diagonales:\n "

Impresión:
for(i = 0; i < k; i++)
"%d ", arr[i]
void imprimir()
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
"%d\t", matriz[i][j]
 INSTRUCCION: Desarrollar el procedimiento el cual sume los elementos de cada fila de una matriz cuadrada y posteriormente
imprima la suma de c/u.
ANALISIS ALGORITMO CODIFICACION
Datos de entrada:
int i,j, n;
int matriz[10][10];
void captura();
void imprimir();
void sumarFilas();

Procedimiento:
main()
captura();
imprimir();
sumarFilas();
void captura()
"Ingrese el tamano del
arreglo: "
"%d", &n
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
"Ingrese elemento [%d][%d]:
", i, j
"%d", &matriz[i][j]
void sumarFilas()
"-> Resultado: Suma por
filas:\n"
for (i = 1; i <= n; i++)
int sumaFila = 0;
for (j = 1; j <= n; j++)
sumaFila += matriz[i][j];
"Suma Fila %d: %d\n", i,
sumaFila
void imprimir()
for(i=1; i<=n; i++
for(j=1; j<=n; j++)
"%d\t", matriz[i][j]

Impresión:
"Suma Fila %d: %d\n", i,
sumaFila
 INSTRUCCIÓN: Desarrollar el procedimiento el cual sume los elementos de cada columna de una matriz cuadrada y posteriormente
imprima la suma de c/u.
ANALISIS ALGORITMO CODIFICACION
Datos de entrada:
int i,j, n;
int matriz[10][10];
void captura();
void imprimir();
void sumarColumnas();

Procedimiento:
main()
captura();
imprimir();
sumarColumnas();
void captura()
"Ingrese el tamano del
arreglo: "
"%d", &n
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
"Ingrese elemento [%d][%d]:
", i, j
"%d", &matriz[i][j]
void sumarColumnas()
"Suma por columnas:\n"
int sumaCol;
for (j = 1; j <= n; j++)
sumaCol = 0;
for (i = 1; i <= n; i++)
sumaCol += matriz[i][j];
void imprimir()
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
"%d\t", matriz[i][j]

Impresión:
"Suma Columna %d: %d\n",
j, sumaCol
 INSTRUCCIÓN: Desarrollar el procedimiento el cual sume e imprima los elementos de la periferia de una matriz cuadrada.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
int i,j, n;
int matriz[10][10];
void captura();
void imprimir();
void sumarPeriferia();

Procedimiento:
main()
captura()
imprimir()
sumaPeriferia()
void captura()
"Ingrese el tamano del
arreglo: "
"%d", &n
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
"Ingrese elemento
[%d][%d]: ", i, j
"%d", &matriz[i][j]
void sumarPeriferia()
int sumaPer = 0;
"Elementos de la
periferia: "
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (i == 1 || i == n || j == 1
|| j == n)
"%d ", matriz[i][j]
sumaPer += matriz[i][j];
void imprimir()
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
"%d\t", matriz[i][j]

Impresión:
"Suma de la Periferia:
%d\n", sumaPer
 INSTRUCCIÓN: Desarrollar el procedimiento el cual imprima los elementos de las esquinas de una matriz cuadrada.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
int i,j, n;
int matriz[10][10];
void captura();
void imprimir();
void
imprimirEsquinas();
Procedimiento:
main()
captura();
imprimir();
imprimirEsquinas();
void captura()
"Ingrese el tamano
del arreglo: "
"%d", &n
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
"Ingrese elemento
[%d][%d]: ", i, j
"%d", &matriz[i][j]
void
imprimirEsquinas()
if (n == 1)
" Esquina [1][1]:
%d\n", matriz[1][1]
Impresión:
void imprimir()
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
"%d\t", matriz[i][j]
 INSTRUCCIÓN: Desarrollar el procedimiento el cual sume e imprima los elementos que se encuentran por encima de la diagonal
principal de una matriz cuadrada.
ANALISIS ALGORITMO CODIFICACION
Datos de entrada:
int i,j, n;
int matriz[10][10];
void captura();
void imprimir();
void
sumarEncimaDiagPrin();

Procedimiento:
main()
captura();
imprimir();
sumarEncimaDiagPrin();
void captura()
"Ingrese el tamano del
arreglo: "
"%d", &n
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
"Ingrese elemento
[%d][%d]: ", i, j
"%d", &matriz[i][j]
void
sumarEncimaDiagPrin()
int suma = 0;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (j > i)
"%d ", matriz[i][j]
suma += matriz[i][j]

Impresión:
void imprimir()
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
"%d\t", matriz[i][j]
 INSTRUCCIÓN: Desarrollar el procedimiento el cual sume e imprima los elementos que se encuentran por debajo de la diagonal
principal de una matriz cuadrada.
ANALISIS ALGORITMO CODIFICACION
Datos de entrada:
int i,j, n;
int matriz[10][10];
void captura();
void imprimir();
void
sumarDebajoDiagPrin();
Procedimiento:
main()
captura();
sumarDebajoDiagPrin();
imprimir();
void captura()
"Ingrese el tamano del
arreglo: "
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
"Ingrese elemento
[%d][%d]: ", i, j
void
sumarDebajoDiagPrin()
int suma = 0;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (i > j)
"%d ", matriz[i][j]
suma += matriz[i][j]

Impresión:
"Suma de los elementos de
debajo: %d\n", suma
 INSTRUCCIÓN: Elaborar el procedimiento que sume los elementos de la columna y fila central de una matriz sin duplicar elementos.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:void
leer_matriz(intmatriz[10][10],
int n, char nombre);
void imprimir_matriz(int
matriz[10][10], int n, char
nombre);
void sumar_central(int
matriz[10][10], int n);
Procedimiento:
main()
int A[10][10];
int n;
"Ingrese la dimension N
(impar, max 10): "
if (n <= 0 || n > 10)
"Error: La dimension debe
ser positiva y no exceder
10.\n"
if (n % 2 == 0)
"Error: La dimension debe
ser IMPAR para tener una
unica fila/columna
central.\n"
leer_matriz(A, n, 'A');
imprimir_matriz(A, n, 'A');
sumar_central(A, n);
void leer_matriz(int
matriz[10][10], int n, char
nombre)
"\nIngrese los datos para la
Matriz %c:\n", nombre
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
" Elemento [%d][%d]: ", i, j
void sumar_central(int
matriz[10][10], int n)
int suma = 0;
int centro = n / 2;
"Fila central (indice %d): ",
centro
for (int j = 0; j < n; j++)
suma += matriz[centro][j]
"%d ", matriz[centro][j]
"\nColumna central (indice
%d): ", centro
for (int i = 0; i < n; i++)
suma += matriz[i][centro]
"%d ", matriz[i][centro]
int duplicado =
matriz[centro][centro]

Impresión:
"La suma total (sin duplicar)
es: %d\n", suma
 INSTRUCCIÓN: Desarrollar el procedimiento el cual efectué la suma de dos matrices de las mismas dimensiones y cuadradas e
imprimir la matriz resultante.
ANALISIS ALGORITMO CODIFICACION
Datos de entrada:
#define MAX 10
void leer_matriz(int
matriz[MAX][MAX],
int n, char
nombre);
void
sumar_matrices(int
A[MAX][MAX], int
B[MAX][MAX], int
C[MAX][MAX], int
n);
void
imprimir_matriz(int
matriz[MAX][MAX],
int n, char
nombre);
Procedimiento:
main()
int A[MAX][MAX];
int B[MAX][MAX];
int C[MAX][MAX];
int n;
if (n <= 0 || n > MAX)
"Error: La
dimension debe
ser positiva y no
exceder %d.\n",
MAX
leer_matriz(A, n,
'A');
leer_matriz(B, n,
'B');

sumar_matrices(A,
B, C, n);

imprimir_matriz(C,
n, 'C (Resultado
A+B)');
void leer_matriz(int
matriz[MAX][MAX],
int n, char nombre)
for (int i = 0; i < n;
i++)
for (int j = 0; j < n;
j++)
" Elemento
[%d][%d]: ", i, j
void
sumar_matrices(int
A[MAX][MAX], int
B[MAX][MAX], int
C[MAX][MAX], int n)
for (int i = 0; i < n;
i++)
for (int j = 0; j < n;
j++)
C[i][j] = A[i][j] +
B[i][j]
Impresión:
void
imprimir_matriz(int
matriz[MAX][MAX],
int n, char nombre)
"\n--- Matriz %c ---
\n", nombre
for (int i = 0; i < n;
i++)
for (int j = 0; j < n;
j++)
"%4d ", matriz[i][j]
 INSTRUCCIÓN: Desarrollar el procedimiento el cual efectué la resta de dos matrices de las mismas dimensiones y cuadradas e
imprimir la matriz resultante.
ANALISIS ALGORITMO CODIFICACION
Datos de entrada:
#define MAX 10
void leer_matriz(int
matriz[MAX][MAX],
int n, char nombre);
void
restar_matrices(int
A[MAX][MAX], int
B[MAX][MAX], int
C[MAX][MAX], int n);
void
imprimir_matriz(int
matriz[MAX][MAX],
int n, char nombre);
Procedimiento:
int A[MAX][MAX];
int B[MAX][MAX];
int C[MAX][MAX];
int n;
printf("--- Resta
de Matrices
Cuadradas (A - B) ---
\n");
printf("Ingrese la
dimension N (max
%d): ", MAX);
scanf("%d", &n);
if (n <= 0 || n >
MAX)
"Error: La
dimension debe ser
positiva y no
exceder %d.\n",
MAX
leer_matriz(A, n, 'A');
leer_matriz(B, n,
'B');

restar_matrices(A,
B, C, n);

imprimir_matriz(C,
n, 'C (Resultado A-
B)');
void leer_matriz(int
matriz[MAX][MAX],
int n, char nombre)
for (int i = 0; i < n;
i++)
for (int j = 0; j < n;
j++)
" Elemento
[%d][%d]: ", i, j
void
restar_matrices(int
A[MAX][MAX], int
B[MAX][MAX], int
C[MAX][MAX], int n)
for (int i = 0; i < n;
i++)
for (int j = 0; j < n;
j++)
C[i][j] = A[i][j] - B[i][j]

Impresión:
void
imprimir_matriz(int
matriz[MAX][MAX],
int n, char nombre)
"\n--- Matriz %c ---
\n", nombre
for (int i = 0; i < n;
i++)
for (int j = 0; j < n;
j++)
"%4d ", matriz[i][j]
 INSTRUCCIÓN: Desarrollar el procedimiento el cual efectué el producto de dos matrices de las mismas dimensiones y cuadradas e
imprimir la matriz resultante.
ANALISIS ALGORITMO CODIFICACION
Datos de entrada:
#define MAX 10
void leer_matriz(int
matriz[MAX][MAX], int
n, char nombre);
void
multiplicar_matrices(int
A[MAX][MAX], int
B[MAX][MAX], int
C[MAX][MAX], int n);
void imprimir_matriz(int
matriz[MAX][MAX], int
n, char nombre);
Procedimiento:
int A[MAX][MAX];
int B[MAX][MAX];
int C[MAX][MAX];
int n;
"Ingrese la dimension N
(max %d): ", MAX
if (n <= 0 || n > MAX)
"Error: La dimension
debe ser positiva y no
exceder %d.\n", MAX
leer_matriz(A, n, 'A');
leer_matriz(B, n, 'B');

multiplicar_matrices(A,
B, C, n);
 imprimir_matriz(C, n,
'C (Resultado A*B)');
void leer_matriz(int
matriz[MAX][MAX], int
n, char nombre)
"\nIngrese los datos
para la Matriz %c:\n",
nombre
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
" Elemento [%d][%d]: ",
i, j
void
multiplicar_matrices(int
A[MAX][MAX], int
B[MAX][MAX], int
C[MAX][MAX], int n)
int suma_producto;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
suma_producto = 0;
for (int k = 0; k < n;
k++)suma_producto +=
A[i][k] * B[k][j]
C[i][j] = suma_producto
Impresión: void
imprimir_matriz(int
matriz[MAX][MAX], int
n, char nombre)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
"%6d ", matriz[i][j]
 INSTRUCCIÓN: Desarrollar el procedimiento el cual genere la matriz transpuesta resultante en la misma matriz.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
#define MAX 10
void leer_matriz(int
matriz[MAX][MAX], int
n, char nombre);
void
imprimir_matriz(int
matriz[MAX][MAX], int
n, char nombre);
void
transponer_en_sitio(int
matriz[MAX][MAX], int
n);
Procedimiento:
int A[MAX][MAX];
int n;
"Ingrese la dimension
N (cuadrada, max %d):
", MAX
if (n <= 0 || n > MAX)
"Error: La dimension
debe ser positiva y no
exceder %d.\n", MAX
leer_matriz(A, n, 'A');
void leer_matriz(int
matriz[MAX][MAX], int
n, char nombre)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
" Elemento [%d][%d]:
", i, j
"%d", &matriz[i][j]
void
transponer_en_sitio(int
matriz[MAX][MAX], int
n)
int temporal;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n;
j++)
temporal = matriz[i][j];
matriz[i][j] = matriz[j][i];
matriz[j][i] = temporal;
void
imprimir_matriz(int
matriz[MAX][MAX], int
n, char nombre)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
"%4d ", matriz[i][j]
Impresión:
"\n--- Matriz Original ---
"imprimir_matriz(A, n,
'A');
transponer_en_sitio(A,
n); "\n--- Matriz
Transpuesta ---"
imprimir_matriz(A, n, 'A
(Transpuesta)');
 INSTRUCCIÓN: Procedimiento que sume los elementos de la o las columnas y la o las filas centrales de una matriz cuadrada sin
repetir la suma de los elementos ubicados en las casillas comunes.
ANALISIS ALGORITMO CODIFICACION
Datos de entrada:
void leer_matriz(int
matriz[MAX][MAX], int n,
char nombre);
void imprimir_matriz(int
matriz[MAX][MAX], int n,
char nombre);
void
sumar_centrales_general(int
matriz[MAX][MAX], int n);
Procedimiento:
main()
int A[MAX][MAX];
int n;
"Ingrese la dimension N
(cuadrada, max %d): ", MAX
if (n <= 0 || n > MAX)
"Error: La dimension debe
ser positiva y no exceder
%d.\n", MAX
if (n == 1)
"Error: Dimension 1 no tiene
filas/columnas centrales.\n"
leer_matriz(A, n, 'A');
imprimir_matriz(A, n, 'A');
sumar_centrales_general(A,
n);
void leer_matriz(int
matriz[MAX][MAX], int n,
char nombre)
"\nIngrese los datos para la
Matriz %c:\n", nombre
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
" Elemento [%d][%d]: ", i, j
void
sumar_centrales_general(int
matriz[MAX][MAX], int n)
long long suma = 0;
int c1, c2;
if (n % 2 == 1)
c1 = n / 2;
for (int k = 0; k < n; k++)
suma += matriz[c1][k];
suma += matriz[k][c1];
suma -= matriz[c1][c1];
else
c1 = n / 2 - 1;
c2 = n / 2;
"Matriz Par (Centros en
indices %d y %d)\n", c1, c2
for (int k = 0; k < n; k++)
suma += matriz[c1][k];
suma += matriz[c2][k];
suma += matriz[k][c1];
suma += matriz[k][c2];
suma -= matriz[c1][c1];
suma -= matriz[c1][c2];
suma -= matriz[c2][c1];
suma -= matriz[c2][c2];
Impresión:
"La suma total (sin duplicar)
es: %lld\n", suma
void imprimir_matriz(int
matriz[MAX][MAX], int n,
char nombre)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
"%4d ", matriz[i][j]
 INSTRUCCIÓN: Elaborar un programa el cual genere el cuadrado mágico, el cual debe sumar lo mismo por todos lados.

ANALISIS ALGORITMO CODIFICACION

Datos de entrada:
void
generar_cuadrado_magico(int
matriz[MAX][MAX], int n);
void imprimir_matriz(int
matriz[MAX][MAX], int n, char
nombre);
void inicializar_matriz_cero(int
matriz[MAX][MAX], int n);
Procedimiento:
int C[MAX][MAX];
int n;
"Ingrese la dimension N (SOLO
IMPAR, max %d): ", MAX
if (n <= 0 || n > MAX)
"Error: La dimension debe ser
positiva y no exceder %d.\n", MAX
if (n % 2 == 0)
"Error: Este algoritmo solo
funciona para dimensiones
IMPARES.\n"
inicializar_matriz_cero(C, n);
generar_cuadrado_magico(C, n);
imprimir_matriz(C, n, 'C');
int constante_magica = n * (n * n +
1) / 2;
void inicializar_matriz_cero(int
matriz[MAX][MAX], int n)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
matriz[i][j] = 0;
voidgenerar_cuadrado_magico(int
matriz[MAX][MAX], int n)
int i = 0;
int j = n / 2;
int max_num = n * n;
for (int num = 1; num <=
max_num; num++)
matriz[i][j] = num;
int sig_i = i - 1;
int sig_j = j + 1;
if (sig_i < 0)
sig_i = n - 1;
if (sig_j == n)
sig_j = 0;
if (matriz[sig_i][sig_j] != 0)
i = (i + 1) % n;
else
i = sig_i;
j = sig_j;
Impresión:
void imprimir_matriz(int
matriz[MAX][MAX], int n, char
nombre)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
"%4d ", matriz[i][j]