Programación Estructurada

Unidad 5

Alumno:

Juan Ángel Hernández de León

No. De Control:
22050521

Docente:

Humberto Moreno Posada

Saltillo, Coahuila 22 de noviembre del 2023

Hacer un programa para llenar un arreglo con 20 datos enteros.

int[] meses;
meses = new int[20];

for (int i = 0; i < 20; i++)

{
Console.WriteLine("Ingresa el valor " + i);
meses[i] = Convert.ToInt32(Console.ReadLine());
}

Console.Clear();

for (int i = 0; i < 20; i++)

{
Console.WriteLine(meses[i]);
}

Resumen:
En este programa se pide en consola que se ingresen 20 valores, los cuales se
guardan en un arreglo, y posteriormente son mostrados los valores registrados.

Conclusión:
Para llenar un arreglo de una dimensión, se hace uso de un ciclo for, de manera
que este ciclo vaya recorriendo cada una de las localidades del arreglo, hasta que
se llenen todos los datos requeridos.
Hacer un programa para generar dos arreglos (A, B) de 10 elementos c/u
para almacenar enteros positivos. Una vez llenos los arreglos, generar las 4
operaciones básicas entre arreglos, y los resultados presentarlos en el
arreglo C, D E Y F.

double[] a = new double[10];

double[] b = new double[10];
double[] suma = new double[10];
double[] resta = new double[10];
double[] multiplicacion = new double[10];
double[] division = new double[10];

int numero;

for (int i = 0; i < 10; i++)

{
do
{
Console.Clear();
Console.WriteLine("Valor nº: " + (i + 1));
Console.WriteLine("Arreglo A");
Console.WriteLine("Introduzca un número positivo");
numero = Convert.ToInt32(Console.ReadLine());
if (numero < 1)
{
Console.WriteLine("Valor no válido");
Console.WriteLine("Presione una tecla para avanzar");
Console.ReadKey();
}
else
{
Console.WriteLine("Valor ingreasdo correctamente");
}
}
while (numero < 1);

a[i] = numero;
}

for (int i = 0; i < 10; i++)

{
do
{
Console.Clear();
Console.WriteLine("Valor nº: " + (i + 1));
Console.WriteLine("Arreglo B");
Console.WriteLine("Introduzca un número positivo");
numero = Convert.ToInt32(Console.ReadLine());
if (numero < 1)
{
Console.WriteLine("Valor no válido");
Console.WriteLine("Presione una tecla para avanzar");
Console.ReadKey();
}
 else
{
Console.WriteLine("Valor ingreasdo correctamente");
}
}
while (numero < 1);

b[i] = numero;
}

for (int i = 0; i < 10; i++)

{
Console.Clear();
suma[i] = a[i] + b[i];
resta[i] = a[i] - b[i];
multiplicacion[i] = a[i] * b[i];
division[i] = a[i] / b[i];
Console.WriteLine("A = " + a[i] + "\tB = " + b[i] + "\nSuma: " + suma[i] +
"\nResta: " + resta[i] + "\nMultiplicacion: " + multiplicacion[i] +
"\nDivision: " + division[i]);
Console.WriteLine("Presione una tecla para avanzar");
Console.ReadKey();
}

Resumen:
Se piden 20 elementos en total para llenar dos arreglos deferentes. Una vez llenos
los arreglos, se hacen las 4 operaciones básicas entre los dos arreglos, guardando
los resultados en otros 4 arreglos.

Conclusión:
Se puede hacer uso de múltiples arreglos para guardar valores que después van a
ser utilizados en el programa. Sirven sobre todo para ordenar y almacenar datos
de un mismo tipo en un solo espacio, permitiendo manejar más fácilmente un gran
número de datos.
Hacer un programa que guarde en un arreglo 10 elementos enteros
positivos, que obtenga el mayor, el menor y el promedio de dichos
elementos.

int mayor = 0, menor = 999999, suma = 0, numero, i;

double promedio;

int[] a = new int[10];

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

{
do
{
Console.Clear();
Console.WriteLine($"Ingrese el valor {i}: ");
numero = Convert.ToInt32(Console.ReadLine());
if (numero < 1)
{
Console.WriteLine("Número no válido. Por favor, ingrese únicamente
números positivos\nPresione cualquier tecla para continuar");
Console.ReadKey();
}
else
{
a[i] = numero;
}
}
while (numero < 1);

if (a[i] > mayor)

mayor = a[i];
else if (a[i] < menor)
menor = a[i];
suma = suma + a[i];
}

promedio = suma / i;
Console.Clear();
Console.WriteLine($"El mayor es: {mayor}\nEl menor es: {menor}\nEl promedio es:
{promedio}");
Thread.Sleep(1000);
Console.ReadKey();
Console.WriteLine("Fin del programa");

Resumen:
Se piden 10 elementos, para después ordenarlos de mayor a menor y el promedio
de los datos ingresados. Para recorrer el arreglo se hace uso de un ciclo for y se
hace uso de otras estructuras de control para determinar el mayor y el menor de
los datos ingresados.
Conclusión:
Los arreglos son útiles para almacenar datos que después van a ser utilizados en
el programa. En este caso, es necesario guardar los valores en un arreglo para
después mostrar los resultados en la consola.
Hacer un programa para llenar un arreglo con n números y acomodarlos de
mayor a menor en un segundo arreglo.

int[] a = new int[10];

int[] b = new int[10];
int numero = 0;
int mayor = 0;
int localidad = 0;

for (int i = 0; i < 10; i++)

{
do
{
Console.Clear();
Console.WriteLine($"Ingrese el valor {i}: ");
numero = Convert.ToInt32(Console.ReadLine());
if (numero < 1)
{
Console.WriteLine("Número no válido. Por favor, ingrese únicamente
números positivos\nPresione cualquier tecla para continuar");
Console.ReadKey();
}
else
{
a[i] = numero;
}
}
while (numero < 1);
}

for (int i = 0; i < 10; i++)

{
for (int j = 0; j < 10; j++)
{
if (a[j] > mayor)
{
mayor = a[j];
localidad = j;
}
}

b[i] = mayor;
a[localidad] = 0;
mayor = 0;
}

Console.Clear();
Console.WriteLine("Números ordenados de mayor a menor:");

foreach (int valor in b)

{
Console.WriteLine(valor);
}
Console.WriteLine("Pulse cualquier tecla para finalizar el programa");
Console.ReadKey();
Console.WriteLine("Fin del programa");
Thread.Sleep(200);

Resumen:
Se guardan los valores que se solicitan en un primer arreglo y se guardan en un
segundo arreglo. Se hace uso del ciclo for para recorrer el arreglo reiteradas
veces, de forma que podamos acomodar el mayor en cada iteración que
realicemos en su respectivo lugar.

Conclusión:
Hacer este mismo programa sin arreglos sería poco práctico y difícil, sin embargo,
el tener todos los elementos requeridos en un mismo espacio facilita la
manipulación de valores.
Hacer un arreglo de 2 dimensiones de 5 x 5 y llenarlo con datos enteros,
mostrar los datos del arreglo

int[,] a = new int[5, 5];

for (int i = 0; i < 5; i++)

{
for (int j = 0; j < 5; j++)
{
Console.Clear();
Console.WriteLine($"Ingresa el dato [{i + 1},{j + 1}]");
a[i,j] = Convert.ToInt32(Console.ReadLine());
}
}

Console.Clear();

for (int i = 0; i < 5; i++)

{
for (int j = 0; j < 5; j++)
{
Console.WriteLine($"Valor [{i + 1},{j + 1}] = {a[i,j]}");
}
}

Resumen:
Se llena un arreglo de 5 x 5 con datos positivos enteros, y después se muestra en
pantalla los valores registrados.

Conclusión:
Los arreglos pueden ser de múltiples dimensiones, dependiendo de las
necesidades del programa. Para llenar este arreglo, se hace uso de ciclos for
anidados, que vayan recorriendo cada renglón y columna del arreglo.
Hacer un programa para pedir n datos positivos enteros, guardarlos en dos
arreglos de 2 dimensiones y realizar las 4 operaciones básicas entre ellos,
guardando los resultados en otros 4 arreglos

double[,] a = new double[3, 3];

double[,] b = new double[3, 3];
double[,] c = new double[3, 3];
double[,] d = new double[3, 3];
double[,] e = new double[3, 3];
double[,] f = new double[3, 3];

for (int i = 0; i < 3; i++)

{
for (int j = 0; j < 3; j++)
{
Console.Clear();
Console.WriteLine($"Ingresa el dato a: [{i + 1},{j + 1}]");
a[i, j] = Convert.ToInt32(Console.ReadLine());
Console.WriteLine($"Ingresa el dato B: [{i + 1},{j + 1}]");
b[i, j] = Convert.ToInt32(Console.ReadLine());

c[i, j] = a[i, j] + b[i, j];

d[i, j] = a[i, j] - b[i, j];
e[i, j] = a[i, j] * b[i, j];
f[i, j] = a[i, j] / b[i, j];
}
}

Console.Clear();

for (int i = 0; i < 3; i++)

{
for (int j = 0; j < 3; j++)
{
Console.WriteLine($"Suma [{i + 1},{j + 1}] = {c[i, j]}");
Console.WriteLine($"Resta [{i + 1},{j + 1}] = {d[i, j]}");
Console.WriteLine($"Multiplicación [{i + 1},{j + 1}] = {e[i, j]}");
Console.WriteLine($"Division [{i + 1},{j + 1}] = {f[i, j]}");
Console.WriteLine();
}
}

Console.WriteLine("Presione una tecla para finalizar el programa");

Console.ReadKey();
Thread.Sleep(100);

double[,] a = new double[5, 6];

for (int i = 0; i < 5; i++)
{
Console.Clear();
Console.WriteLine($"Ingresa el dato a: {i + 1}");
a[i, 0] = Convert.ToInt32(Console.ReadLine());
Console.WriteLine($"Ingresa el dato b: {i + 1}");
a[i, 1] = Convert.ToInt32(Console.ReadLine());
 a[i, 2] = a[i, 0] + a[i, 1];
a[i, 3] = a[i, 0] - a[i, 1];
a[i, 4] = a[i, 0] * a[i, 1];
a[i, 5] = a[i, 0] / a[i, 1];
}

Console.Clear();

for (int j = 0; j < 5; j++)

{
Console.WriteLine($"Suma {j}: = {a[j, 2]}");
Console.WriteLine($"Resta {j}: = {a[j, 3]}");
Console.WriteLine($"Multiplicacion {j}: = {a[j, 4]}");
Console.WriteLine($"Division {j}: = {a[j, 5]}");
Console.WriteLine();
}

Resumen:
Al igual que cuando llenamos arreglos con las 4 operaciones básicas, se puede
hacer el mismo procedimiento para un arreglo de múltiples dimensiones.

Conclusión:
Si bien, en este ejemplo se realizaron operaciones en múltiples arreglos, se puede
hacer uso de un arreglo de múltiples dimensiones, de manera que cada renglón,
fila o columna represente un dato, característica o valor a considerar, de manera
que en un solo arreglo se puedan trabajar con múltiples valores.
Hacer un diagrama de flujo para generar las tablas de multiplicar

int dimension = 0;
int numero = 0;
byte continuar = 1;

do
{
do
{
Console.Clear();
Console.WriteLine("Ingrese el número de tablas de multiplicar");
numero = Convert.ToInt32(Console.ReadLine());
}
while (numero < 1);

dimension = numero + 1;
int[,] tablas = new int[dimension, dimension];

for ( int i = 1; i < dimension; i++)

{
tablas[0, i] = i;
tablas[i, 0] = i;
}

Console.Clear();
int tab = (dimension / 3);
for(int t = 0; t < tab; t++)
{
Console.Write("\t");
}
Console.WriteLine("Tablas de multiplicar");
Console.Write("------");

for (int i = 1; i < dimension; i++)

{
for (int j = 1; j < dimension; j++)
{
tablas[i, j] = tablas[0, j] * tablas[i, 0];

}
Console.Write("--------");
}

Console.WriteLine();

for (int i = 0; i < dimension; i++)

{
Console.Write(" ");
for (int j = 0; j < dimension; j++)
{
Console.ForegroundColor = (i == 0 || j == 0) ? ConsoleColor.Red :
ConsoleColor.White;
Console.Write(tablas[i, j] + " |\t ");
}
Console.WriteLine();
for (int a = 0; a < dimension; a++)
 {
Console.Write("--------");
}
Console.WriteLine();
}
Console.WriteLine("\n¿Desea generar una tabla diferente?\nPresione 1 para
continuar o presione cualquier otra tecla para salir");
continuar = Convert.ToByte(Console.ReadLine());
}
while (continuar == 1);

Resumen:
Se genera una tabla de multiplicar, llenando un arreglo bidimensional con los
valores de cada tabla.

Conclusión:
Los arreglos nos sirven para manipular una gran cantidad de datos, facilitando el
trabajo al considerar una gran cantidad de valores.