PRACTICA_VECTORES_Y_MATRICES

1)
int I, J;
int[] A = new int[11]; // Array A con 10 elementos (1..10)

// Inicialización de I y J
I = 1;
J = 2;

// Ejecución de las instrucciones

A[I] = J; // A[1] = 2
A[J] = I; // A[2] = 1
A[J + I] = I + J; // A[3] = 3
I = A[I] + A[J]; // I = A[1] + A[2] = 2 + 1 = 3
A[3] = 5; // A[3] = 5
J = A[I] - A[J]; // J = A[3] - A[2] = 5 - 1 = 4

// Imprimir los resultados

[Link]("Valor de I: " + I); // I = 3
[Link]("Valor de J: " + J); // J = 4

2)// Pedir al usuario que ingrese la cantidad de elementos

[Link]("Ingrese la cantidad de elementos en la tabla: ");
int n = [Link]([Link]());

// Crear el array con la cantidad de elementos especificada

int[] tabla = new int[n];

// Pedir al usuario que ingrese los elementos del array

[Link]("Ingrese los elementos de la tabla:");

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

{
[Link]($"Elemento {i + 1}: ");
tabla[i] = [Link]([Link]());
}

// Variable para contar los elementos positivos

int contadorPositivos = 0;

// Recorrer el array y contar los elementos positivos

foreach (int numero in tabla)
{
if (numero > 0) // Si el número es positivo
{
contadorPositivos++;
 }
}

// Mostrar el resultado
[Link]("El número de elementos positivos es: " + contadorPositivos);

3) int[,] matriz = new int[4, 4];

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

{
for (int j = 0; j < 4; j++)
{
if (i == j)
{
matriz[i, j] = 1;
}
else
{
matriz[i, j] = 0;
}
}
}

[Link]("Matriz Identidad 4x4:");

for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
[Link](matriz[i, j] + " ");
}
[Link]();
}

4) int[,] matriz = new int[3, 3];

int[] sumaFilas = new int[3];

int[] sumaColumnas = new int[3];

[Link]("Ingrese los elementos de la matriz 3x3:");

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

{
for (int j = 0; j < 3; j++)
{
[Link]($"Elemento [{i + 1}, {j + 1}]: ");
 matriz[i, j] = [Link]([Link]());
}
}

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

{
sumaColumnas[j] = 0;
}

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

{
sumaFilas[i] = 0;
for (int j = 0; j < 3; j++)
{
sumaFilas[i] += matriz[i, j];
sumaColumnas[j] += matriz[i, j];
}
}

[Link]("\nSuma de las filas:");

for (int i = 0; i < 3; i++)
{
[Link]($"Suma de la fila {i + 1}: {sumaFilas[i]}");
}

[Link]("\nSuma de las columnas:");

for (int j = 0; j < 3; j++)
{
[Link]($"Suma de la columna {j + 1}: {sumaColumnas[j]}");
}

5) [Link]("Ingrese la cantidad de elementos en el vector: ");

int n = [Link]([Link]());

int[] vector = new int[n];

[Link]("Ingrese los elementos del vector:");

for (int i = 0; i < n; i++)
{
[Link]($"Elemento {i + 1}: ");
vector[i] = [Link]([Link]());
}

int suma = 0;
for (int i = 0; i < n; i++)
{
suma += vector[i];
 }

double media = (double)suma / n;

[Link]($"\nLa suma de los elementos del vector es: {suma}");

[Link]($"La media aritmética es: {media}");

6) int[] vector = new int[60];

int negativos = 0, ceros = 0, positivos = 0;

[Link]("Ingrese los 60 elementos del vector:");

for (int i = 0; i < 60; i++)
{
[Link]($"Elemento {i + 1}: ");
vector[i] = [Link]([Link]());
}

foreach (int numero in vector)

{
if (numero < 0)
{
negativos++;
}
else if (numero == 0)
{
ceros++;
}
else
{
positivos++;
}
}

[Link]($"\nCantidad de números negativos: {negativos}");

[Link]($"Cantidad de ceros: {ceros}");
[Link]($"Cantidad de números positivos: {positivos}");

7)int[,] matriz = new int[4, 4];

[Link]("Ingrese los elementos de la matriz 4x4:");

for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
[Link]($"Elemento [{i + 1}, {j + 1}]: ");
 matriz[i, j] = [Link]([Link]());
}
}

int sumaDiagonal = 0;
for (int i = 0; i < 4; i++)
{
sumaDiagonal += matriz[i, i];
}

[Link]($"\nLa suma de los elementos de la diagonal principal es:

{sumaDiagonal}");

8) double[] T = new double[50];

double[] nuevaTabla = new double[50];

[Link]("Ingrese los 50 números reales distintos de cero:");

for (int i = 0; i < 50; i++)
{
[Link]($"Elemento {i + 1}: ");
T[i] = [Link]([Link]());

if (T[i] == 0)
{
[Link]("El número no puede ser cero. Inténtelo de nuevo.");
i--;
}
}

[Link]("\nIngrese el índice K (entre 1 y 50): ");

int K = [Link]([Link]()) - 1;

if (K < 0 || K >= 50)

{
[Link]("Índice K fuera de rango. Debe estar entre 1 y 50.");
return;
}

double divisor = T[K];

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

{
nuevaTabla[i] = T[i] / divisor;
}

[Link]("\nLa nueva tabla es:");

for (int i = 0; i < 50; i++)
 {
[Link]($"Elemento {i + 1}: {nuevaTabla[i]:F2}");
}

9) [Link]("Ingrese el tamaño de la lista (N): ");

int N = [Link]([Link]());

int[] lista = new int[N + 1];

[Link]("Ingrese los elementos de la lista:");

for (int i = 0; i < N; i++)
{
[Link]($"Elemento {i + 1}: ");
lista[i] = [Link]([Link]());
}

[Link]("\nIngrese el valor a insertar (x): ");

int x = [Link]([Link]());

[Link]($"Ingrese la posición k (1 a {N + 1}) para insertar el valor: ");

int k = [Link]([Link]());

if (k < 1 || k > N + 1)
{
[Link]("La posición k está fuera del rango permitido.");
return;
}

k -= 1;

for (int i = N; i > k; i--)

{
lista[i] = lista[i - 1];
}

lista[k] = x;

[Link]("\nLa lista actualizada es:");

for (int i = 0; i < N + 1; i++)
{
[Link]($"Elemento {i + 1}: {lista[i]}");
}

10)const int totalPlazas = 300;

const int plazasFumadores = 100;
 bool[] plazas = new bool[totalPlazas];

while (true)
{
[Link]("\n--- Gestión de Reservas de Vuelo MADRID-CARACAS ---");
[Link]("1. Reservar plaza");
[Link]("2. Anular reserva");
[Link]("3. Mostrar estado de plazas");
[Link]("4. Salir (el avión está próximo a despegar)");
[Link]("Seleccione una opción: ");
int opcion = [Link]([Link]());

switch (opcion)
{
case 1:
ReservarPlaza(plazas, plazasFumadores);
break;
case 2:
AnularReserva(plazas);
break;
case 3:
MostrarEstadoPlazas(plazas, plazasFumadores);
break;
case 4:
[Link]("Cerrando las reservas. ¡Buen vuelo!");
return;
default:
[Link]("Opción inválida. Intente de nuevo.");
break;
}

if (TodasLasPlazasOcupadas(plazas))
{
[Link]("Todas las plazas están reservadas. Cerrando las reservas.");
return;
}
}
}

static void ReservarPlaza(bool[] plazas, int plazasFumadores)

{
[Link]("\n--- Reservar Plaza ---");
[Link]("1. Fumadores (1-100)");
[Link]("2. No fumadores (101-300)");
[Link]("Seleccione una opción: ");
int tipo = [Link]([Link]());

int inicio, fin;

 if (tipo == 1)
{
inicio = 0;
fin = plazasFumadores;
}
else if (tipo == 2)
{
inicio = plazasFumadores;
fin = [Link];
}
else
{
[Link]("Opción inválida.");
return;
}

for (int i = inicio; i < fin; i++)

{
if (!plazas[i])
{
plazas[i] = true;
[Link]($"Plaza {i + 1} reservada con éxito.");
return;
}
}

[Link]("No hay plazas disponibles en la categoría seleccionada.");

}

static void AnularReserva(bool[] plazas)

{
[Link]("\n--- Anular Reserva ---\nIngrese el número de plaza a anular (1-300):
");
int numeroPlaza = [Link]([Link]());

if (numeroPlaza < 1 || numeroPlaza > [Link])

{
[Link]("Número de plaza inválido.");
return;
}

if (plazas[numeroPlaza - 1])
{
plazas[numeroPlaza - 1] = false;
[Link]($"Reserva de la plaza {numeroPlaza} anulada con éxito.");
}
else
{
 [Link]($"La plaza {numeroPlaza} no estaba reservada.");
}
}

static void MostrarEstadoPlazas(bool[] plazas, int plazasFumadores)

{
[Link]("\n--- Estado de las Plazas ---");
[Link]("Fumadores:");
for (int i = 0; i < plazasFumadores; i++)
{
[Link]($"Plaza {i + 1}: {(plazas[i] ? "Reservada" : "Libre")}");
}

[Link]("\nNo Fumadores:");
for (int i = plazasFumadores; i < [Link]; i++)
{
[Link]($"Plaza {i + 1}: {(plazas[i] ? "Reservada" : "Libre")}");
}
}

static bool TodasLasPlazasOcupadas(bool[] plazas)

{
foreach (bool plaza in plazas)
{
if (!plaza) return false;
}
return true;

11)const int numeroAlumnos = 5;

const int numeroAsignaturas = 8;

double[,] notas = new double[numeroAlumnos, numeroAsignaturas];

double[] coeficientes = new double[numeroAsignaturas];
double[] mediasAlumnos = new double[numeroAlumnos];
double[] mediasAsignaturas = new double[numeroAsignaturas];
int faltasTotales = 0;

[Link]("Ingrese los coeficientes para las 8 asignaturas:");

for (int j = 0; j < numeroAsignaturas; j++)
{
[Link]($"Coeficiente de la asignatura {j + 1}: ");
coeficientes[j] = [Link]([Link]());
}

[Link]("\nIngrese las notas de los alumnos (use -1 para indicar

ausencia):");
for (int i = 0; i < numeroAlumnos; i++)
{
[Link]($"\nAlumno {i + 1}:");
for (int j = 0; j < numeroAsignaturas; j++)
{
[Link]($"Nota en asignatura {j + 1}: ");
notas[i, j] = [Link]([Link]());
}
}

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

{
double sumaPonderada = 0;
double sumaCoeficientes = 0;
for (int j = 0; j < numeroAsignaturas; j++)
{
if (notas[i, j] != -1)
{
sumaPonderada += notas[i, j] * coeficientes[j];
sumaCoeficientes += coeficientes[j];
}
else
{
faltasTotales++;
}
}

mediasAlumnos[i] = sumaCoeficientes > 0 ? sumaPonderada / sumaCoeficientes : 0;

}

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

{
double sumaNotas = 0;
int conteoNotas = 0;

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

{
if (notas[i, j] != -1)
{
sumaNotas += notas[i, j];
conteoNotas++;
}
}

mediasAsignaturas[j] = conteoNotas > 0 ? sumaNotas / conteoNotas : 0;

}

double sumaMedias = 0;
foreach (double media in mediasAlumnos)
 {
sumaMedias += media;
}
double mediaGeneral = sumaMedias / numeroAlumnos;

double totalNotas = numeroAlumnos * numeroAsignaturas;

double porcentajeFaltas = (faltasTotales / totalNotas) * 100;

[Link]("\n--- Resultados ---");

[Link]("\nMedia de cada alumno:");

for (int i = 0; i < numeroAlumnos; i++)
{
[Link]($"Alumno {i + 1}: {mediasAlumnos[i]:F2}");
}

[Link]("\nMedia de la clase por asignatura:");

for (int j = 0; j < numeroAsignaturas; j++)
{
[Link]($"Asignatura {j + 1}: {mediasAsignaturas[j]:F2}");
}

[Link]($"\nMedia general de la clase: {mediaGeneral:F2}");

[Link]($"Porcentaje de faltas: {porcentajeFaltas:F2}%");

12) const int totalNumeros = 100;

int[] cuadrados = new int[totalNumeros];

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

{
cuadrados[i - 1] = i * i;
}

[Link]("\n--- Tabla de Cuadrados de los 100 Primeros Números Enteros

---");
[Link]("Número\tCuadrado");
[Link]("--------------------");

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

{
[Link]($"{i + 1}\t{cuadrados[i]}");
}

13) [Link]("Ingrese el número de temperaturas (N): ");

int n = [Link]([Link]());

double[] temperaturas = new double[n];

 [Link]("\nIngrese las temperaturas:");
for (int i = 0; i < n; i++)
{
[Link]($"Temperatura {i + 1}: ");
temperaturas[i] = [Link]([Link]());
}

double suma = 0;
foreach (double temp in temperaturas)
{
suma += temp;
}
double media = suma / n;

int conteo = 0;
foreach (double temp in temperaturas)
{
if (temp >= media)
{
conteo++;
}
}

[Link]($"\nMedia de las temperaturas: {media:F2}");

[Link]($"Número de temperaturas mayores o iguales a la media:
{conteo}");

14)const int dimension = 100;

double[] vector = new double[dimension];
Random random = new Random();

[Link]("Vector de 100 elementos:");

for (int i = 0; i < dimension; i++)
{
vector[i] = [Link](1, 101);
[Link](vector[i] + " ");
}
[Link]();

double suma = 0;
foreach (double elemento in vector)
{
suma += elemento;
}

double media = suma / dimension;

 [Link]($"\nSuma de todos los elementos: {suma:F2}");
[Link]($"Media aritmética: {media:F2}");

15) [Link]("Ingrese el número de elementos en la lista (N): ");

int n = [Link]([Link]());

int[] L = new int[n];

[Link]("\nIngrese los elementos de la lista:");

for (int i = 0; i < n; i++)
{
[Link]($"Elemento {i + 1}: ");
L[i] = [Link]([Link]());
}

int mayor = L[0];

for (int i = 1; i < n; i++)
{
if (L[i] > mayor)
{
mayor = L[i];
}
}

[Link]($"\nEl mayor valor en la lista es: {mayor}");