Dada las matrices A y B con números enteros y positivos generados

Ejercicio 30:
Dada las matrices A y B con números enteros y positivos generados
Randomicamente, de igual números de filas y columnas. Hacer el diagrama y el
programa que permita crear e imprimir la suma de las dos matrices, y el resultado
almacenarlo en una nueva matriz llamada C. De esta manera estaríamos
simulando la suma de matrices de n filas x n columnas.
Solución:
Miremos primero como se efectúa la suma de matrices. Supongamos que se
tienen las siguientes matrices A y B, que se muestran a continuación, y
observemos el proceso de la suma.
Matriz A
1
8
9
3
10
7
5
15
8
Matriz B
6
20
0
+
15
2
6
12
3
7
13
4
8
Matriz C
1
5
9
=
16
10
15
15
13
14
18
19
16
7
25
9
La suma se efectúa de la siguiente manera:
C [1,1]=A [1,1]+B [1,1]=1+15= 16; C [1,2]=A [1,2]+B [1,2]=3+12= 15;
C [1,3]=A [1,3]+B [1,3]=5+13= 18; C [1,4]=A [1,4]+B [1,4]=6+1= 7;
Y así sucesivamente hasta terminar con las demás filas.
Variables de entrada de datos
f,c= Variables que identifican el numero de filas y de columnas de las matrices A y
B.
Variables de proceso
A[i,j]= Matriz que almacenara numeros enteros y positivos generados
aleatoriamente, numeros comprendidos en un rango de 0 a 99.
B[i,j]= Matriz que almacenara numeros enteros y positivos generados
aleatoriamente, numeros comprendidos en un rango de 0 a 99.
C[i,j]= Matriz que almacenara la suma de los numeros de las matrices A y B.
i, j = Variables subíndices de las matrices A,B,C.
num= Variable que almacena temporalmente el numero generado aleatoriamente.
Inicio
Random num= Random
f,c
A [f, c] =num (0, 99)
B [f, c] =num (0, 99)
A [f, c]
B [f, c]
i= 1, f
j= 1, c
C [i, j]=A [i, j]+B [i, j]
Matriz
C [i, j]
Fin
PRIMERA PARTE: Aplicación Consola
Nuevamente nos dirigimos al menú Archivo, Nuevo, Proyecto. Al hacerlo nos
muestra la pantalla de nuevo proyecto, escogemos Visual C#, Aplicación consola,
le damos el nombre al proyecto, en este caso “suma_matrices_consola”, luego
aceptar, tal y como se muestra en la siguiente pantalla.
Pantalla nuevo proyecto Visual csharp
Después de esto tendremos la pantalla en donde podremos digitar el código
correspondiente para el ejercicio que estamos trabajando. La pantalla es la
siguiente.
Pantalla proyecto suma_matrices_consola Visual csharp
Nos ubicamos dentro de las llaves que encierran al método static void Main(string[]
args) y digitamos el siguiente codigo.
int f,c;//Indican el numero de filas y columnas de las matrices
int i, j;//Variables de los subindices de la matriz
// Definimos las matrices
int[,] A = new int[100, 100];//Matriz A de cien posiciones
int[,] B = new int[100, 100];//Matriz B de cien posiciones
int[,] C = new int[100, 100];//Matriz C de cien posiciones
//Definimos la semilla para la generacion de los numeros aleatorios
Random num = new Random(DateTime.Now.Millisecond);
//Definimos el titulo del proyecto
Console.Title = "Suma de Matrices en CSharp";
Console.WriteLine("\n");
//Ingresamos el numero de filas de las matrices
Console.Write("Ingrese el numero de filas: ");
f = int.Parse(Console.ReadLine());
//Ingresamos el numero de columnas de las matrices
Console.Write("Ingrese el numero de columnas: ");
c = int.Parse(Console.ReadLine());
//Hacemos el llenado de la matriz A Randomicamente
for (i = 1; i <=f; i++)
{
for (j = 1; j <=c; j++)
{
A[i, j] = num.Next(0, 99);
}
}
//Hacemos el llenado de la matriz B Randomicamente
for (i = 1; i <= f; i++)
{
for (j = 1; j <= c; j++)
{
B[i, j] = num.Next(0, 99);
}
}
Console.WriteLine();
Console.WriteLine("Matriz A Generada Inicialmente");
Console.WriteLine("------------------------------");
//Imprimimos la matriz A
for (i = 1; i <=f; i++)
{
for (j = 1; j <=c; j++)
{
Console.Write(" {0 } ", A[i, j]);
}
Console.WriteLine();
}
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("Matriz B Generada Inicialmente");
Console.WriteLine("------------------------------");
//Imprimimos la matriz B
for (i = 1; i <= f; i++)
{
for (j = 1; j <= c; j++)
{
Console.Write(" {0 } ", B[i, j]);
}
Console.WriteLine();
}
Console.WriteLine();
//Efectuamos el recorrido de las matrices para hallar la suma
for (i = 1; i <=f; i++)
{
for (j = 1; j <=c; j++)
{
//Realizamos la suma de A + B en C
C[i,j] = A[i, j]+B[i, j];
}
}
Console.WriteLine();
//Imprimimos la matriz C
Console.WriteLine(
"Matriz C");
Console.WriteLine("------------------------------");
for (i = 1; i <= f; i++)
{
for (j = 1; j <= c; j++)
{
Console.Write(" {0 } ", C[i, j]);
}
Console.WriteLine();
}
Console.ReadLine();
Ahora le damos Depurar, Iniciar depuración o F5, el cual nos permite ir a la
pantalla en donde podremos digitar el numero de filas y de columnas de las
matrices A y B, para luego realizar las suma de estas dos y ser almacenada en la
matriz C, tal y como se muestra a continuación en la siguientes pantallas.
Pantalla proyecto suma_matrices_consola Visual csharp
Pantalla proyecto suma_matrices_consola Visual csharp
Ejercicio 31:
Con las mismas matrices del ejercicio anterior, desarrollaremos el proceso de
multiplicar dos matrices y su resultado sera almacenado en otra matriz.
Solucion:
Veamos primero como se dearrolla el proceso de multiplicacion de matrices. Si
bien es cierto que tiene algo de parecido a la suma, no es igual, el procedimiento
es diferente, ademas debe existir un requisito especial, el cual consiste en que el
numero de columnas de la matriz A debe ser igual al numero de filas de la matriz
B. Pasemos a ver como se veria esta situacion graficamente.
Fila i matriz A
.
.
.
.
.
.
Columna k matriz B
Matriz A (3x3)
Matriz B (3x4)
2
8
4
3
1
2
X
5
7
8
Es decir que para sacar el
debe hacer lo siguiente:
1
4
0
3
2 56 20
0
2
2
1
3 30 4
=
0
8
1
2
5 98 22
resultado de la primera posición de la
C [i, k]=0; j=1;
C [i, k] = C [i, k] + A [i, j] * B [j, k]
C [1, 1] = 0 + 2 * 1=2
J=2
C [i, k] = C [i, k] + A [i, j] * B [j, k]
C [1, 1] = 2 + 8 * 0=2
J=3
Matriz C (3x4)
22
14
38
matriz C [1,1] se
C [i, k] = C [i, k] + A [i, j] * B [j, k]
C [1, 1] = 2 + 4 * 0=2
De esta manera se obtiene el primer termino de la matriz C [1,1].
Para obtener el termino de la posición C [1,2], se hace exactamente igual solo que
la operación se hace entra la misma fila de la matriz A con la segunda columna de
la matriz B y así sucesivamente, hasta terminar de llenar la matriz C.
Variables de entrada de datos
fa= Variable que identifican el numero de filas de la matriz A.
ca= Variable que identifican el numero de filas de la matriz A.
fb= Variable que identifican el numero de filas de la matriz B.
cb= Variable que identifican el numero de filas de la matriz B.
Variables de proceso
A[i,j]= Matriz que almacenara numeros enteros y positivos generados
aleatoriamente, numeros comprendidos en un rango de 0 a 99.
B[i,j]= Matriz que almacenara numeros enteros y positivos generados
aleatoriamente, numeros comprendidos en un rango de 0 a 99.
C[i,k]= Matriz que almacenara el resultado de la multiplicacion de la matriz A por
la matriz B.
i, j, k = Variables subíndices de las matrices A, B, C.
num= Variable que almacena temporalmente el numero generado aleatoriamente.
Inicio
Random num= Random
fa, ca, fb, cb
A [fa, ca] =num (0, 99)
B [fb, cb] =num (0, 99)
A [fa, ca]
B [fb, cb]
i= 1, fa
k= 1, cb
C [i, k]=0
j= 1, ca
C [i, k] =C [i, k] + A [i, j]*B [j, k]
Matriz
C [i, j]
Fin
PRIMERA PARTE: Aplicación Consola
Nuevamente nos dirigimos al menú Archivo, Nuevo, Proyecto. Al hacerlo nos
muestra la pantalla de nuevo proyecto, escogemos Visual C#, Aplicación consola,
le damos el nombre al proyecto, en este caso “producto_matrices_consola”,
luego aceptar, tal y como se muestra en la siguiente pantalla.
Pantalla nuevo proyecto Visual csharp
Después de esto tendremos la pantalla en donde podremos digitar el código
correspondiente para el ejercicio que estamos trabajando. La pantalla es la
siguiente.
Pantalla proyecto producto_matrices_consola Visual csharp
Nos ubicamos dentro de las llaves que encierran al método static void Main(string[]
args) y digitamos el siguiente codigo.
int fa, fb, ca, cb;//Indican el numero de filas y columnas de las matrices A y B
int i, j, k;//Variables de los subindices de la matrices
// Definimos las matrices
int[,] A = new int[100, 100];//Matriz A de cien posiciones
int[,] B = new int[100, 100];//Matriz B de cien posiciones
int[,] C = new int[100, 100];//Matriz C de cien posiciones
//Definimos la semilla para la generacion de los numeros aleatorios
Random num = new Random(DateTime.Now.Millisecond);
//Definimos el titulo del proyecto
Console.Title = "Multiplicacion de Matrices en CSharp";
Console.WriteLine("\n");
//Ingresamos el numero de filas de la matriz A
Console.Write("Ingrese el numero de filas de la matriz A: ");
fa = int.Parse(Console.ReadLine());
//Ingresamos el numero de columnas de la matriz A
Console.Write("Ingrese el numero de columnas de la matriz A: ");
ca = int.Parse(Console.ReadLine());
//Ingresamos el numero de filas de la matriz B
Console.Write("Ingrese el numero de filas de la matriz B: ");
fb = int.Parse(Console.ReadLine());
//Ingresamos el numero de columnas de la matriz B
Console.Write("Ingrese el numero de columnas de la matriz B: ");
cb = int.Parse(Console.ReadLine());
//Hacemos el llenado de la matriz A Randomicamente
for (i = 1; i <= fa; i++)
{
for (j = 1; j <= ca; j++)
{
A[i, j] = num.Next(0, 99);
}
}
//Hacemos el llenado de la matriz B Randomicamente
for (i = 1; i <= fb; i++)
{
for (j = 1; j <= cb; j++)
{
B[i, j] = num.Next(0, 99);
}
}
Console.WriteLine();
Console.WriteLine("Matriz A Generada Inicialmente");
Console.WriteLine("------------------------------");
//Imprimimos la matriz A
for (i = 1; i <= fa; i++)
{
for (j = 1; j <= ca; j++)
{
Console.Write(" {0 } ", A[i, j]);
}
Console.WriteLine();
}
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("Matriz B Generada Inicialmente");
Console.WriteLine("------------------------------");
//Imprimimos la matriz B
for (i = 1; i <= fb; i++)
{
for (j = 1; j <= cb; j++)
{
Console.Write(" {0 } ", B[i, j]);
}
Console.WriteLine();
}
Console.WriteLine();
//Efectuamos el recorrido de las matrices para hallar la multiplicacion
for (i = 1; i <= fa; i++)//Ciclo que reccorre las filas de la matriz A
{
for (k = 1; k <= cb; k++)//Ciclo que reccorre las columnas de la matriz B
{
//Incializamos la matriz C en cero
C[i, k] = 0;
for (j = 1; j <= ca; j++)//Ciclo que reccorre las columnas de la matriz A
{
//Realizamos la suma de A + B en C
C[i, k] = C[i, k] + A[i, j] * B[j, k];
}
}
}
Console.WriteLine();
//Imprimimos la matriz C
Console.WriteLine("Matriz C");
Console.WriteLine("------------------------------");
for (i = 1; i <= fb; i++)
{
for (k = 1; k <= cb; k++)
{
Console.Write(" {0 } ", C[i, k]);
}
Console.WriteLine();
}
Console.ReadLine();
Ahora le damos Depurar, Iniciar depuración o F5, el cual nos permite ir a la
pantalla en donde podremos digitar el numero de filas y de columnas de las
matrices A y B, para luego realizar las multiplicación de estas dos y el resultado
almacenarlo en la matriz C, tal y como se muestra a continuación en la siguientes
pantallas.
Pantalla proyecto producto_matrices_consola Visual csharp
Pantalla proyecto producto_matrices_consola Visual csharp
Ejercicio 32:
Hacer el diagrama y el programa, que permita leer una matriz A, de n filas por n
columnas. Los datos de la matriz A, serán números enteros y positivos los cuales
deberán ser ingresados por el teclado. Después de ingresar los datos en la matriz
A, se deberá crear una nueva matriz llamada transpuesta, la cual consiste en
convertir las filas en columnas y las columnas en filas de la matriz A. Pero mejor
veamos gráficamente como es una matriz transpuesta.
Matriz A (3x3)
2
3
5
8
1
7
4
2
8
Matriz Transpuesta (3x3)
2
8
4
3
1
2
5
7
8
Si observamos detenidamente la fila 1 (2, 8, 4), ahora es columna 1 (2, 8, 4), y la
columna 1(2, 3, 5), ahora es fila 1(2, 3, 5), y así sucesivamente con las demás
filas y columnas. Veamos ahora como quedaría nuestro diagrama de flujo.
Solución:
Variables de entrada de datos
n= Variable que identifican el orden de la matriz A.
Variables de proceso
A[i,j]= Matriz que almacenara numeros enteros y positivos digitados por el teclado.
transpuesta[i,j]= Matriz que almacenara el intercambio de filas por columnas y
columnas por filas de la matriz A.
i, j = Variables subíndices de las matrices A y transpuesta.
Inicio
n
A[n]
i= 1, n
j= 1, n
transpuesta [j, i]=A [i, j]
A [j, i]
transpuesta [j, i]
Fin
PRIMERA PARTE: Aplicación Consola
Nuevamente nos dirigimos al menú Archivo, Nuevo, Proyecto. Al hacerlo nos
muestra la pantalla de nuevo proyecto, escogemos Visual C#, Aplicación consola,
le damos el nombre al proyecto, en este caso “matriz_transpuesta_consola”,
luego aceptar, tal y como se muestra en la siguiente pantalla.
Pantalla nuevo proyecto Visual csharp
Después de esto tendremos la pantalla en donde podremos digitar el código
correspondiente para el ejercicio que estamos trabajando. La pantalla es la
siguiente.
Pantalla proyecto matriz_transpuesta_consola Visual csharp
Nos ubicamos dentro de las llaves que encierran al método static void Main(string[]
args) y digitamos el siguiente codigo.
int n;//Indican el orden de la matriz A
int i, j;//Variables de los subindices de la matrices
// Definimos las matrices
int[,] A = new int[100, 100];//Matriz A de cien posiciones
int[,] transpuesta = new int[100, 100];//Matriz transpuesta de cien posiciones
//Definimos el titulo del proyecto
Console.Title = "Matriz Transpuesta en CSharp";
Console.WriteLine("\n");
//Ingresamos el orden de la matriz A
Console.Write("Ingrese el orden de la matriz A: ");
n = int.Parse(Console.ReadLine());
//Leemos la matriz A desde el teclado
Console.WriteLine("Ingrese los valores de la matriz A ");
Console.WriteLine();
for (i = 1; i <= n; i++)
{
Console.WriteLine("\tFila {0}:", i);
for (j = 1; j <= n; j++)
{
Console.Write("\t\t Columna {0}:", j);
A[i, j] = int.Parse(Console.ReadLine());
}
}
Console.WriteLine();
//Efectuamos el recorrido de las matriz A para hallar la transpuesta
for (i = 1; i <= n; i++)//Ciclo que reccorre las filas de la matriz A
{
for (j = 1; j <= n; j++)//Ciclo que reccorre las columnas de la matriz A
{
//Efectuamos el cambio de filas por columnas y columnas por filas
transpuesta[j, i] = A[i,j];
}
}
Console.WriteLine();
//Imprimimos la matriz A
Console.WriteLine("Matriz A Leida Inicialmente");
Console.WriteLine("------------------------------");
for (i = 1; i <= n; i++)
{
for (j = 1; j <= n; j++)
{
Console.Write(" {0 } ", A[i, j]);
}
Console.WriteLine();
}
Console.WriteLine();
//Imprimimos la matriz Transpuesta de A
Console.WriteLine("Matriz Transpuesta");
Console.WriteLine("------------------------------");
for (j = 1; j <= n; j++)
{
for (i = 1; i <= n; i++)
{
Console.Write(" {0 } ", transpuesta[j, i]);
}
Console.WriteLine();
}
Console.ReadLine();
Ahora le damos Depurar, Iniciar depuración o F5, el cual nos permite ir a la
pantalla en donde podremos digitar el orden de la matriz A, para luego realizar el
cambio de filas por columnas y las columnas por filas “transpuesta de A”, tal y
como se muestra a continuación en la siguiente pantalla.
Pantalla proyecto matriz_transpuesta_consola Visual csharp
Matriz Espiral
Una matriz de n filas por n columnas, se puede llenar y recorrer de varias formas.
En los siguientes ejercicios se tratara los casos existentes para una matriz en este
caso la llamada espiral envolvente. Pero mejor veamos gráficamente como se
representa cada uno de los casos existentes.
|
|
2
3
--
1
<---5
--
8
<---4
^
^
|7
| 6
Matriz Espiral Envolvente caso 1
Para este caso el llenado se hace de la siguiente manera, tal y como se muestra
en la siguiente grafica.
1
20
19
18
17
16
2
21
32
31
30
15
3
22
33
36
29
14
4
23
34
35
28
13
5
24
25
26
27
12
6
7
8
9
10
11
6X6
Ahora veamos cual seria el código que permitiría el llenado de esta matriz de n
filas por n columnas. Le recuerdo amigo lector que este tipo de matriz el llenado
no se hace desde el teclado sino que se hace necesario que a través del software
se haga el llenado respectivo.
Console.Write("Digite el orden de la matriz:");
n = int.Parse(Console.ReadLine());
//Inicializamos las variables utilizadas en el llenado de la matriz
z = i = 1;
v = n * n;
f = n;
while (z < v)
{
for (x = i; x <= f - 1; x++)
{
espiral[i, x] = z;
z++;
}
for (x = i; x <= f - 1; x++)
{
espiral[x, f] = z;
z++;
}
for (x = f; x >= i + 1; x--)
{
espiral[f, x] = z;
z++;
}
for (x = f; x >= i + 1; x--)
{
espiral[x, i] = z;
z++;
}
//Incrementamos la variable i
i++;
//Disminuimos la variable f
f--;
}//Cerramos el cilco while
//Imprimimos la matriz espiral
Console.WriteLine("\n");
Console.WriteLine("\t\t CASO UNO");
Console.WriteLine("---------------------------------------------------------");
for (x = 1; x <= n; x++)
{
Console.Write("| "); // Se imprime un separador
for (y = 1; y <= n; y++)
{
Console.Write("\t {0} ",espiral[x,y]);
}
Console.WriteLine("\t| "); // Se imprime un separador
}
Console.WriteLine(“---------------------------------------------------------“);
Ahora miremos como seria la salida en pantalla del anterior código que genera
una matriz espiral envolvente de 6X6.
Si observamos detenidamente el anterior código, se ha utilizado un ciclo while, y
dentro de este ciclo encontramos cuatro ciclos for, que permite el llenado de la
matriz. Vemos que se utiliza una variable llamada z que controla la secuencia de
los números, en este caso por tratarse de 6x6, significa que la variable z deberá
llegar hasta el numero 36, con la cual se generan los números de 1 a 36 que son
los que se almacenan en la matriz. También vemos una variable f que es
inicializada con el mismo valor de n, el cual controla el alcance de los ciclos for.
Vemos que también que existe una variable llamada v, que es inicializada con la
multiplicación de nxn, para el caso de que n es igual a 6, entonces quiere decir
que v inicializaría su valor en 36, lo cual permite controlar el ciclo while, es decir
que mientras z que se inicializa en uno y se va incrementado mediante la
ejecución de los ciclos for sea menor a v en este caso 36, se ejecuta el ciclo
while. También observamos que la variable i que se arranca en uno se
incrementa al final de los ciclos for, y la variable f se disminuye. En general este el
procedimiento que se utiliza para los demás casos que veremos a continuación.
Bucle foreach
Existe esta sentencia de control de flujo, especialmente diseñada para este tipo de
estructuras, donde se manejan listas de elementos, todos del mismo tipo. Foreach
depende de la definición previa de un arreglo de elementos del mismo tipo, los
cuales puede recorrer individualmente sin conocer el tamaño, explícitamente
(como se requiere en otras instrucciones, por ejemplo en el for).
Usted amigo lector se preguntara por que estoy definiendo el bucle foreach
después de haber visto el tema de array y no cuando vimos todos los bucles
existentes. Pues la razón es muy sencilla, el bucle foreach es utilizado para
recorrer grandes grupos de información o mejor colecciones, por esta razón
considere que era mejor dejar este bucle para después de haber visto el concepto
de array, aunque no quiere decir con esto que no se pueda utilizar en otro tipo de
situación.
Veamos ahora la sintaxis general del bucle foreach.
foreach (<tipo> <variable> in <arreglo>) {
<instrucciones>
}
Donde:
<tipo> es el tipo básico de los elementos contenidos en el arreglo.
<arreglo> es el arreglo de elementos a revisar.
<variable> es un identificador de una variable local del foreach () que se
usará para ver un elemento del arreglo en cada iteración.
La colección que se recorre se especifica como una colección que en este caso,
es un array. Cabe anotar que la variable de iteración es de solo lectura en lo que
respecta al array. Por lo tanto, no se puede cambiar el contenido del array
asignando un nuevo valor a la variable de iteración.
Ahora veamos algunos ejemplos en donde se puede utilizar este bucle.
Ejercicio 34:
Se tiene un arreglo llamado enteros, que contiene números enteros previamente
definidos al momento de declarar el array. Se desea conocer cuantos de estos
números son pares y cuantos impares. Veamos el código para este ejercicio.
//Definimos las variables contador par e impar;
int par = 0, impar = 0;
//Definimos y el array enteros
int[] enteros = new int[] { 1, 2, 5, 7, 9, 12, 13, 15, 18, 20, 22, 25, 30 };
//Definimos el titulo al proyecto
Console.Title="Uso del Bucle foreach con Array";
//Efectuamos el recorrido del array mediante bucle foreach
foreach (int i in enteros)
{
if (i % 2 == 0)
par++;
else
impar++;
}
Console.WriteLine("\n");
Console.WriteLine("Array de enteros");
Console.WriteLine();
//Imprimimos el array enteros
foreach (int i in enteros)
{
Console.Write(" {0} ", i);
}
Console.WriteLine();
//Ahora imprimamos cuantos son pares y cuantos impares
Console.WriteLine("\n");
Console.WriteLine("Hay {0}pares y {1} impares.", par, impar);
Console.ReadLine();
Al ejecutar este codigo, se obtendra la siguiente salida en pantalla, la cual se
muestra a continuacion.
Ahora analicemos el anterior código. Vemos que para recorrer la colección de
números del array es mucho más sencillo que si lo hiciéramos utilizando el bucle
for, debido a que solo se necesita la variable, en este caso i y el array llamado
enteros, y no se necesita conocer cuantos elementos tiene la colección. También
se observa que al momento de imprimir el array es de gran utilidad este bucle,
hace más sencilla la instrucción.
Ejercicio 35:
Se tiene un vector de 240 posiciones, el cual contiene los nombres de los
pasajeros del avión de Avianca HK7000, que viaja de Bogota Colombia, con
destino Madrid España. Hacer el diagrama y el programa que permita conocer e
imprimir si cierto pasajero viaja en el avión y el número del asiento en el avión.
Solución:
El objetivo de este ejercicio es que mediante el bucle foreach y digitando el
nombre del pasajero, se verifique si en realidad viaja o no en el avión y en que
puesto esta ubicado.
Variables de entrada de datos
pasajeros[i]= Vector de 240 posiicones, que almacenara los nombres de las
personas que viajan en el avion HK7000.
nombre= Variable utilizada para leer el nombre del pasajero a buscar en el avion.
Variables de proceso
i, x = Variables subíndices del bucle for y foreach.
puesto= Variable que almacenara el numero del asiento del pasajero encontrado
en el avión.
viaja= Variable booleana, que tomara el valor de verdadero “true” o falso
“false” dependiendo si encontró o no el pasajero en el avión.
Inicio
i= 1, 240
Vector
pasajeros[i]
nombre
viaja =falso; puesto=0
x, in pasajeros
x=nombre
NO
SI
viaja=verdadero
puesto=puesto+1
viaja=verdadero
NO
SI
nombre, “No viaja en
el Avión.”
nombre, “Viaja y
esta ubicado en el
puesto:”, puesto
Fin
Si observamos detenidamente el diagrama, vemos que para conocer el numero
del puesto en donde se encuentra ubicado el pasajero encontrado en el vector, se
utilizo una variable tipo contador llamada puesto, ¿por que contador?, esto es
debido a que como el vector es tipo string, y el recorrido se hace con bucle
foreach, no hay posibilidades de definir una variable tipo entera y asociarla a la
posición del vector debido a que este es de tipo string, por ese motivo se define
como entera y a su vez como contador.
PRIMERA PARTE: Aplicación Consola
Nuevamente nos dirigimos al menú Archivo, Nuevo, Proyecto. Al hacerlo nos
muestra la pantalla de nuevo proyecto, escogemos Visual C#, Aplicación consola,
le damos el nombre al proyecto, en este caso “foreach_pasajeros_consola”,
luego aceptar, tal y como se muestra en la siguiente pantalla.
Pantalla nuevo proyecto Visual csharp
Después de esto tendremos la pantalla en donde podremos digitar el código
correspondiente para el ejercicio que estamos trabajando. La pantalla es la
siguiente.
Pantalla proyecto foreach_pasajeros_consola Visual csharp
Nos ubicamos dentro de las llaves que encierran al método static void Main(string[]
args) y digitamos el siguiente codigo.
//Definimos las variables a utilizar en el programa;
int i, puesto=0;
//Definimos y el array pasajeros
string[] pasajeros = new string[300];//Defunimos el array de 300 posiciones
//Definimos la variable string llamada nombre
string nombre;
//Definimos la variable viaja
bool viaja=false;
//Definimos el titulo al proyecto
Console.Title="Pasajeros Avion HK7000 de Avianca";
//Leemos cada uno de los nombres de los pasajeros y
//los almacenamos en el vector pasajeros
Console.WriteLine("\n");
Console.WriteLine("\t\tPasajeros del HK7000 de Avianca");
Console.WriteLine();
for(i=1; i<=240; i++)
{
Console.Write("Digite el nombre del pasajero Nº. [ " + i + "]:");
pasajeros[i]=Console.ReadLine();
}
Console.WriteLine();
//Ahora digitamos el nombre del pasajero a buscar en el vector
Console.Write("Digite el nombre del pasajero a buscar en el avion: ");
nombre=Console.ReadLine();
Console.WriteLine();
//Efectuamos el recorrido del array mediante bucle foreach
//para hallar el pasajero y su respectivo puesto en el avion
foreach (string x in pasajeros)
{
if (x ==nombre)
{
viaja=true;
break;//Fuerza a salir del bucle
}
//Incrementamos el contador para saber el puesto del pasajero
puesto++;
}
//Efectuamos la pregunta para saber si fue encontrado o no el pasajero
if (viaja ==true)
{
Console.WriteLine("{0} es ocupante del Avion y se encuentra ubicada en el
puesto Nº. {1}",nombre, puesto);
}
else
Console.WriteLine(" {0} No viaja en el Avion", nombre);
Console.ReadLine();
Ahora le damos Depurar, Iniciar depuración o F5, el cual nos permite ir a la
pantalla en donde podremos digitar los nombres de los pasajeros que viajan en el
avión y que son almacenados en el vector pasajeros, luego se digita el nombre del
pasajero a buscar dentro del avión o mejor dentro del vector, para hacer la prueba
del ejercicio se hará con veinte pasajeros, igual debe funcionar para 240 pasajeros
que es en realidad la capacidad que se tiene para el ejercicio. Las pantallas se
muestran a continuación.
Pantalla proyecto foreach_pasajeros_consola Visual csharp
Pantalla proyecto foreach_pasajeros_consola Visual csharp
Ejercicio 36:
Hacer el diagrama y el programa que permita crear una matriz de cinco filas por
cinco columnas, y hallar la suma de todos los elementos de la matriz. La matriz
deberá ser creada con números enteros tal y como se muestra a continuación en
la siguiente grafica. Aclaro que la matriz no se debe llenar por le teclado, ni
tampoco de forma Aleatoria (Randomicamente). Veamos la grafica de la matriz.
Columnas
Filas
1
2
3
4
5
2
4
6
8
10
3
6
9
12
15
4
8
12
16
20
5
10
15
20
25