EJERCICIOS CON MATRICES

1) Piden crear una matriz de 4×4 de números enteros que inicialmente esta vacía, nos piden hacer un menú
con estas opciones:

 Rellenar TODA la matriz de números, debes pedírselo al usuario.

 Suma de una fila que se pedirá al usuario (controlar que elija una correcta)
 Suma de una columna que se pedirá al usuario (controlar que elija una correcta)
 Sumar la diagonal principal (ver ejemplo)
 Sumar la diagonal inversa (ver ejemplo)
 La media de todos los valores de la matriz
IMPORTANTE: hasta que no se haga la primera opción, el resto de opciones no se deberán de ejecutar,
simplemente mostrar un mensaje donde diga que debes rellenar la matriz.

import java.util.Scanner;
public class ejercicio1 {
public static void main(String[] args) {
Matriz matriz = new Matriz(4, 4);
Scanner scanner = new Scanner(System.in);
int opcion = -1;
while (opcion != 0) {
Menu.mostrarMenu();
System.out.print("Ingrese una opción: ");
opcion = scanner.nextInt();
switch (opcion) {
case 1:
matriz.rellenarMatriz(scanner);
break;
case 2:
matriz.sumarFila(scanner);
break;
case 3:
matriz.sumarColumna(scanner);
break;
case 4:
 matriz.sumarDiagonalPrincipal();
break;
case 5:
matriz.sumarDiagonalInversa();
break;
case 6:
matriz.calcularMedia();
break;
case 0:
System.out.println("Adiós");
break;
default:
System.out.println("Opción inválida");
break;
}
}
}
}
class Matriz {
private int[][] matriz;
private boolean matrizLlena;

public Matriz(int filas, int columnas) {

matriz = new int[filas][columnas];
matrizLlena = false;
}
public void rellenarMatriz(Scanner scanner) {
System.out.println("Ingrese los elementos:");
for (int i = 0; i < matriz.length; i++) {
for (int j = 0; j < matriz[0].length; j++) {
System.out.print("Ingrese el elemento en la posición [" + i + "][" + j + "]: ");
matriz[i][j] = scanner.nextInt();
}
}
matrizLlena = true;
System.out.println("Matriz llenada exitosamente");
}
public void sumarFila(Scanner scanner) {
if (matrizLlena) {
System.out.print("Ingrese el número de fila (del 0 al " + (matriz.length - 1) + "): ");
int filaSuma = scanner.nextInt();
if (filaSuma >= 0 && filaSuma < matriz.length) {
int sumaFila = 0;
for (int j = 0; j < matriz[0].length; j++) {
sumaFila += matriz[filaSuma][j];
}
System.out.println("La suma de la fila " + filaSuma + " es: " + sumaFila);
} else {
System.out.println("Fila inválida");
}
} else {
System.out.println("No se ha rellenado la matriz");
}
}
public void sumarColumna(Scanner scanner) {
if (matrizLlena) {
System.out.print("Ingrese el número de columna (del 0 al " + (matriz[0].length - 1) + "): ");
int columnaSuma = scanner.nextInt();
if (columnaSuma >= 0 && columnaSuma < matriz[0].length) {
int sumaColumna = 0;
for (int i = 0; i < matriz.length; i++) {
sumaColumna += matriz[i][columnaSuma];
}
System.out.println("La suma de la columna " + columnaSuma + " es: " + sumaColumna);
} else {
System.out.println("Columna inválida");
}
} else {
System.out.println("No se ha rellenado la matriz");
}
}
public void sumarDiagonalPrincipal() {
if (matrizLlena) {
int sumaDiagonalPrincipal = 0;
for (int i = 0; i < matriz.length; i++) {
sumaDiagonalPrincipal += matriz[i][i];
}
System.out.println("La suma de la diagonal principal es: " + sumaDiagonalPrincipal);
} else {
System.out.println("No se ha rellenado la matriz");
}
}
public void sumarDiagonalInversa() {
if (matrizLlena) {
int sumaDiagonalInversa = 0;
for (int i = 0; i < matriz.length; i++) {
sumaDiagonalInversa += matriz[i][matriz[0].length - 1 - i];
}
System.out.println("La suma de la diagonal inversa es: " + sumaDiagonalInversa);
} else {
System.out.println("No se ha rellenado la matriz");
}
}
public void calcularMedia() {
if (matrizLlena) {
int sumaTotal = 0;
for (int i = 0; i < matriz.length; i++) {
for (int j = 0; j < matriz[0].length; j++) {
sumaTotal += matriz[i][j];
}
}
double media = (double) sumaTotal / (matriz.length * matriz[0].length);
System.out.println("La media de los valores es: " + media);
} else {
System.out.println("No se ha rellenado la matriz");
}
 }
}
class Menu {
public static void mostrarMenu() {
System.out.println("-------- MENU --------");
System.out.println("1. Rellenar matriz");
System.out.println("2. Suma de fila");
System.out.println("3. Suma de columna");
System.out.println("4. Sumar la diagonal principal");
System.out.println("5. Sumar la diagonal inversa");
System.out.println("6. La media de los valores");
System.out.println("0. Salir");
}
}

2) Nos piden que implementemos el software para una máquina expendedora de golosinas.
Cada golosina tiene un nombre y un precio para ahorrar tiempo, os paso los datos que tendrá a continuación
(copiar y pegar):
1
2 String[][] nombresGolosinas = {
3  
4             {"KitKat", "Chicles de fresa", "Lacasitos", "Palotes"},
5  
            {"Kinder Bueno", "Bolsa variada Haribo", "Chetoos", "Twix"},
6
 
7             {"Kinder Bueno", "M&M'S", "Papa Delta", "Chicles de menta"},
8  
9             {"Lacasitos", "Crunch", "Milkybar", "KitKat"}
10  
11  };
12  
13  
14  
15 double[][] precio = {
16  
  {1.1, 0.8, 1.5, 0.9},
17
18  
  {1.8, 1, 1.2, 1},
19
 
20   {1.8, 1.3, 1.2, 0.8},
21  
22   {1.5, 1.1, 1.1, 1.1}
23  
24 };
25
 

También tendrán una cantidad inicial, que en principio será de 5.

Tendremos un pequeño menú con las siguientes opciones:

 Pedir golosina: pedirá la posición de la golosina que quiera. Esta máquina tiene golosinas en cada
posición, identificados por su fila y columna, que será lo que introduzca el usuario al pedir una golosina,
por ejemplo si el usuario teclea 20 significa que está pidiendo la golosina que está en la fila 2 columna 0.
Cuando no haya más golosinas se le indicará al usuario. Solo puede pedir una golosina y supondremos
que el usuario siempre tiene dinero al elegir. Recuerda de disminuir la cantidad la pedir.
 Mostrar golosinas: mostrara todas las golosinas disponibles. Mostrará el código que debe introducir el
usuario, el nombre y el precio. La cantidad no se mostrará.
 Rellenar golosinas: esta es una función exclusiva de un técnico por lo que nos pedirá una contraseña, si
el usuario escribe “MaquinaExpendedora2017” le pedirá la posición de la golosina y la cantidad.
 Apagar maquina: sale del programa, antes de salir mostrara las ventas totales durante la ejecución del
programa.
El programa debe ser modularizado, es decir, todas las funciones que veas que sean necesarias debes crearlas, así
como todas aquellas acciones que veas que se repitan. Piensa que funciones pueden ser.

Las funciones deben ser lo más genéricas posibles.

import java.util.Scanner;
public class ejercicio2 {
static String[][] nombresGolosinas = {
{"KitKat", "Chicles de fresa", "Lacasitos", "Palotes"},
{"Kinder Bueno", "Bolsa variada Haribo", "Chetoos", "Twix"},
{"Kinder Bueno", "M&M'S", "Papa Delta", "Chicles de menta"},
 {"Lacasitos", "Crunch", "Milkybar", "KitKat"}
};
static double[][] precios = {
{1.1, 0.8, 1.5, 0.9},
{1.8, 1, 1.2, 1},
{1.8, 1.3, 1.2, 0.8},
{1.5, 1.1, 1.1, 1.1}
};
static int[][] cantidadGolosinas = new int[4][4];
static double ventasTotales = 0;
static Scanner scanner = new Scanner(System.in);
public static void main(String[] args) {
inicializarCantidadGolosinas(5);
mostrarMenu();
}
public static void inicializarCantidadGolosinas(int cantidadInicial) {
for (int i = 0; i < cantidadGolosinas.length; i++) {
for (int j = 0; j < cantidadGolosinas[i].length; j++) {
cantidadGolosinas[i][j] = cantidadInicial;
}
}
}
public static void mostrarMenu() {
boolean apagado = false;

while (!apagado) {
System.out.println("----- MÁQUINA EXPENDEDORA DE GOLOSINAS -----");
System.out.println("1. Pedir golosina");
System.out.println("2. Mostrar golosinas");
System.out.println("3. Rellenar golosinas");
System.out.println("4. Apagar máquina");
System.out.println("---------------------------------------------");
System.out.print("Ingrese una opción: ");
int opcion = scanner.nextInt();
System.out.println();

switch (opcion) {
case 1:
pedirGolosina();
break;
case 2:
mostrarGolosinas();
break;
case 3:
rellenarGolosinas();
break;
case 4:
apagarMaquina();
apagado = true;
break;
default:
System.out.println("Opción inválida. Intente nuevamente.");
break;
}
System.out.println();
}
}
 public static void pedirGolosina() {
System.out.print("Ingrese la posición de la golosina que desea (del 1 al 16): ");
int posicion = scanner.nextInt();

int fila = (posicion - 1) / 4;

int columna = (posicion - 1) % 4;

if (fila >= 0 && fila < nombresGolosinas.length && columna >= 0 && columna < nombresGolosinas[fila].length) {
if (cantidadGolosinas[fila][columna] > 0) {
double precio = precios[fila][columna];
System.out.println("¡Disfruta tu golosina " + nombresGolosinas[fila][columna] + " por $" + precio + "!");
ventasTotales += precio;
cantidadGolosinas[fila][columna]--;
} else {
System.out.println("Lo sentimos, no hay más golosinas disponibles en esa posición.");
}
} else {
System.out.println("Posición inválida. Intente nuevamente.");
}
}
public static void mostrarGolosinas() {
System.out.println("----- LISTA DE GOLOSINAS DISPONIBLES -----");
int posicion = 1;
for (int i = 0; i < nombresGolosinas.length; i++) {
for (int j = 0; j < nombresGolosinas[i].length; j++) {
System.out.println(posicion + ". Golosina: " + nombresGolosinas[i][j] + " | Precio: $" + precios[i][j]);
posicion++;
}
}
}
public static void rellenarGolosinas() {
System.out.print("Ingrese la contraseña: ");
String contraseña = scanner.next();

if (contraseña.equals("MaquinaExpendedora2017")) {
System.out.print("Ingrese la posición de la golosina a rellenar (del 1 al 16): ");
int posicion = scanner.nextInt();

int fila = (posicion - 1) / 4;

int columna = (posicion - 1) % 4;

if (fila >= 0 && fila < nombresGolosinas.length && columna >= 0 && columna < nombresGolosinas[fila].length)
{
System.out.print("Ingrese la cantidad de golosinas a rellenar: ");
int cantidad = scanner.nextInt();
cantidadGolosinas[fila][columna] += cantidad;
System.out.println("Golosinas rellenadas correctamente.");
} else {
System.out.println("Posición inválida. Intente nuevamente.");
}
} else {
System.out.println("Contraseña incorrecta. Acceso denegado.");
}
}
public static void apagarMaquina() {
System.out.println("----- APAGANDO MÁQUINA EXPENDEDORA -----");
System.out.printf("Ventas totales: $%.2f%n", ventasTotales);
 System.out.println("¡Hasta luego!");
}
}

3) Queremos realizar una encuesta a 10 personas, en esta encuesta indicaremos el sexo (1=masculino,
2=femenino), si trabaja (1=si trabaja, 2= no trabaja) y su sueldo (si tiene un trabajo, sino sera un cero)
estará entre 600 y 2000 (valor entero). Los valores pueden ser generados aleatoriamente. Calcula y
muestra lo siguiente:

 Porcentaje de hombres (tengan o no trabajo).

 Porcentaje de mujeres (tengan o no trabajo).
 Porcentaje de hombres que trabajan.
 Porcentaje de mujeres que trabajan.
 El sueldo promedio de las hombres que trabajan.
 EL sueldo promedio de las mujeres que trabajan.
Usa todos los métodos que veas necesarios, piensa que es aquello que se repite o que puede ser mejor tenerlo por
separado.
import java.util.Scanner;
public class ejercicio3 {
static final int CANTIDAD_PERSONAS = 10;
static final int SUELDO_MIN = 600;
static final int SUELDO_MAX = 2000;
static int[] sexos = new int[CANTIDAD_PERSONAS];
static int[] trabajos = new int[CANTIDAD_PERSONAS];
static int[] sueldos = new int[CANTIDAD_PERSONAS];
static Scanner scanner = new Scanner(System.in);
public static void main(String[] args) {
pedirEncuesta();
calcularPorcentajes();
calcularSueldoPromedio();
}
public static void pedirEncuesta() {
System.out.println("Ingrese los datos de los encuestados:");

for (int i = 0; i < CANTIDAD_PERSONAS; i++) {

System.out.println("Encuestado " + (i + 1) + ":");
System.out.print("Sexo (1 = masculino, 2 = femenino): ");
sexos[i] = scanner.nextInt();

System.out.print("Trabaja (1 = sí, 2 = no): ");

trabajos[i] = scanner.nextInt();

if (trabajos[i] == 1) {
System.out.print("Sueldo (" + SUELDO_MIN + " - " + SUELDO_MAX + "): ");
sueldos[i] = scanner.nextInt();
while (sueldos[i] < SUELDO_MIN || sueldos[i] > SUELDO_MAX) {
System.out.println("Sueldo fuera de rango. Intente nuevamente.");
System.out.print("Sueldo (" + SUELDO_MIN + " - " + SUELDO_MAX + "): ");
sueldos[i] = scanner.nextInt();
}
} else {
sueldos[i] = 0;
}

System.out.println();
}
}
public static void calcularPorcentajes() {
int totalHombres = 0;
int totalMujeres = 0;
int hombresTrabajan = 0;
int mujeresTrabajan = 0;

for (int i = 0; i < CANTIDAD_PERSONAS; i++) {

if (sexos[i] == 1) {
totalHombres++;
if (trabajos[i] == 1) {
hombresTrabajan++;
}
} else {
 totalMujeres++;
if (trabajos[i] == 1) {
mujeresTrabajan++;
}
}
}
double porcentajeHombres = calcularPorcentaje(totalHombres, CANTIDAD_PERSONAS);
double porcentajeMujeres = calcularPorcentaje(totalMujeres, CANTIDAD_PERSONAS);
double porcentajeHombresTrabajan = calcularPorcentaje(hombresTrabajan, totalHombres);
double porcentajeMujeresTrabajan = calcularPorcentaje(mujeresTrabajan, totalMujeres);
System.out.printf("Porcentaje de hombres: %.2f%%%n", porcentajeHombres);
System.out.printf("Porcentaje de mujeres: %.2f%%%n", porcentajeMujeres);
System.out.printf("Porcentaje de hombres que trabajan: %.2f%%%n", porcentajeHombresTrabajan);
System.out.printf("Porcentaje de mujeres que trabajan: %.2f%%%n", porcentajeMujeresTrabajan);
}
public static double calcularPorcentaje(int cantidad, int total) {
if (total > 0) {
return (double) cantidad / total * 100;
} else {
return 0;
}
}
public static void calcularSueldoPromedio() {
int totalHombresTrabajan = 0;
int totalMujeresTrabajan = 0;
int sumaSueldosHombres = 0;
int sumaSueldosMujeres = 0;

for (int i = 0; i < CANTIDAD_PERSONAS; i++) {

if (trabajos[i] == 1) {
if (sexos[i] == 1) {
totalHombresTrabajan++;
sumaSueldosHombres += sueldos[i];
} else {
totalMujeresTrabajan++;
sumaSueldosMujeres += sueldos[i];
}
}
}
double sueldoPromedioHombres = calcularSueldoPromedio(sumaSueldosHombres, totalHombresTrabajan);
double sueldoPromedioMujeres = calcularSueldoPromedio(sumaSueldosMujeres, totalMujeresTrabajan);
System.out.printf("Sueldo promedio de los hombres que trabajan: $%.2f%n", sueldoPromedioHombres);
System.out.printf("Sueldo promedio de las mujeres que trabajan: $%.2f%n", sueldoPromedioMujeres);
}
public static double calcularSueldoPromedio(int sumaSueldos, int cantidadPersonas) {
if (cantidadPersonas > 0) {
return (double) sumaSueldos / cantidadPersonas;
} else {
return 0;
}
}
}
 4) El youtuber Folagor03 contacta con nosotros para hacer un programa que nos muestre la tabla de tipos de
Pokemon (tiene un problema serio con ello).
En la solución os dejo un fichero java con los datos necesarios: la tabla de tipos y los tipos de Pokemon. Es el
fichero llamado Constantes,java, copialo a tu Proyecto, si lo quieres hacer de cero.

Los datos que contiene la tabla de tipos es la siguiente:

  5: el atacante hace la mitad de daño al oponente (No es muy eficaz)
 1: el atacante hace un daño neutro al oponente (No se da información) (en la imagen representa al -)
 2: el atacante hace el doble de daño al oponente (Es muy eficaz)
 0: el atacante hace un daño nulo al oponente (No afecta)
Las filas de la matriz es el Pokemon que ataca.

Las columnas son el pokemon que recibe el ataque.

Por ejemplo, Fila 4 (Eléctrico) ataca a un pokemon de la Columna 1 (Agua), habrá un 2 por

Para mayor comodidad del usuario, al poner los tipos de pokemon, se los mostraremos de esta manera:

1. ACERO
2. AGUA
3. BICHO
….

Así hasta el final. Mirar el vector con los tipos.

Las opciones que le daremos a Folagor03 son:

 Mostrar debilidades: pedimos un tipo o dos (tenemos que preguntárselo al usuario) y nos mostrara todos
los tipos que hacen un daño eficaz (recordar un 2) a este tipo.
Por ejemplo, si Folagor03 elige DEBILIDADES de FUEGO, le deberían aparecer estos tipos:

 AGUA
 ROCA
 TIERRA
Si elige dos tipos de pokemon, por ejemplo FUEGO y TIERRA, habrá que ver esos dos tipos y multiplicar las
debilidades y mostrar el multiplicador de daño.

 AGUA : x4 (2 * 2 = 4, doblemente eficaz)

 TIERRA : x2 (2 * 1 = 2, la tierra es neutro con la tierra)
Fíjate que no aparece el tipo ROCA, ya que TIERRA tiene resistencia y hace que un ataque sea neutro (0.5 * 2 =
1)

 Mostrar todas los tipos eficaces: pedimos un solo tipo (un ataque al final solo es de un solo tipo) y
mostramos que tipos son débiles contra ellos.
Por ejemplo, si elegimos ACERO, los pokemon a los que hace un “Es muy eficaz” son:

 HADA
 HIELO
 ROCA
 

 Mostrar toda la información relativa de un tipo: pedimos un tipo y nos mostrara el daño de cada uno.
Según el valor poner los siguientes valores:
o 1 : NEUTRO

o 0 : NO AFECTA

o 2 : MUY EFICAZ

o 5 : NO MUY EFICAZ

Por ejemplo si elegimos AGUA, mostraría algo así:

 ACERO : NEUTRO
 AGUA: NO MUY EFICAZ
 BICHO: NEUTRO
Así con todos los tipos

 Mostrar eficacia de un tipo a otro: pedimos dos tipos de pokemon, el primero será el atacante y el
segundo será el oponente. Simplemente diremos si es eficaz o no, neutro o no le afecta el ataque.
Por ejemplo, si elijo el tipo TIERRA de atacante y VOLADOR de oponente este me deberá mostrar:
  NO AFECTA
También tiene que pedir si quiere que el tipo del oponente sea de uno o dos tipos.

import java.util.Scanner;
public class ejercicio4 {
private static final String[] TIPOS = {
"NORMAL", "LUCHA", "VOLADOR", "VENENO", "TIERRA",
"ROCA", "BICHO", "FANTASMA", "ACERO", "FUEGO",
"AGUA", "PLANTA", "ELÉCTRICO", "PSÍQUICO", "HIELO",
"DRAGÓN", "SINIESTRO", "HADA"
};
private static final double[][] TABLA_TIPOS = {
{1, 1, 1, 1, 1, 1, 1, 0, 0.5, 1, 1, 1, 1, 1, 1, 1, 1, 1}, // NORMAL
{2, 1, 0.5, 0.5, 1, 2, 0.5, 0, 2, 1, 1, 1, 1, 0.5, 2, 1, 2, 0.5}, // LUCHA
{1, 2, 1, 1, 1, 0.5, 2, 1, 0.5, 1, 1, 2, 0.5, 1, 1, 1, 1, 1}, // VOLADOR
{1, 1, 1, 0.5, 0.5, 1, 1, 0.5, 0, 1, 1, 2, 1, 1, 1, 1, 1, 2}, // VENENO
{1, 1, 0, 2, 1, 0.5, 1, 1, 2, 2, 1, 0.5, 2, 1, 1, 1, 1, 1}, // TIERRA
{1, 0.5, 2, 1, 2, 1, 0.5, 1, 0.5, 2, 1, 1, 1, 1, 2, 1, 1, 1}, // ROCA
{1, 0.5, 0.5, 0.5, 1, 2, 1, 0.5, 0.5, 0.5, 1, 2, 1, 2, 1, 1, 2, 0.5}, // BICHO
{0, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 0.5, 1}, // FANTASMA
{1, 1, 1, 1, 1, 2, 1, 1, 0.5, 0.5, 0.5, 1, 0.5, 1, 2, 1, 1, 2}, // ACERO
{1, 1, 1, 1, 1, 0.5, 2, 1, 2, 0.5, 0.5, 2, 1, 1, 2, 0.5, 1, 1}, // FUEGO
{1, 1, 1, 1, 2, 2, 1, 1, 1, 2, 0.5, 0.5, 1, 1, 1, 0.5, 1, 1}, // AGUA
{1, 1, 0.5, 0.5, 2, 2, 0.5, 1, 0.5, 0.5, 2, 0.5, 1, 1, 1, 0.5, 1, 1}, // PLANTA
{1, 1, 2, 1, 0.5, 1, 1, 1, 1, 1, 0.5, 2, 0.5, 1, 1, 0.5, 1, 1}, // ELÉCTRICO
{1, 2, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 0.5, 1, 1, 0, 1}, // PSÍQUICO
{1, 1, 2, 1, 2, 1, 1, 1, 0.5, 0.5, 0.5, 2, 1, 1, 0.5, 2, 1, 1}, // HIELO
{1, 2, 1, 1, 1, 1, 1, 1, 0.5, 1, 1, 1, 1, 1, 1, 2, 1, 0}, // DRAGÓN
{1, 0.5, 1, 1, 1, 1, 1, 0.5, 1, 2, 1, 1, 1, 2, 1, 1, 0.5, 0.5}, // SINIESTRO
{1, 2, 1, 0.5, 1, 1, 1, 1, 0.5, 1, 1, 1, 1, 1, 1, 2, 2, 1} // HADA
};
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int opcion;
do {
mostrarMenu();
opcion = scanner.nextInt();
switch (opcion) {
case 1:
mostrarDebilidades(scanner);
break;
case 2:
mostrarTiposEficaces(scanner);
break;
case 3:
mostrarInformacionTipo(scanner);
break;
case 4:
mostrarEficaciaMovimiento(scanner);
break;
case 5:
System.out.println("¡Hasta luego!");
 break;
default:
System.out.println("Opción inválida. Por favor, seleccione una opción válida.");
break;
}
System.out.println();
} while (opcion != 5);

scanner.close();
}
private static void mostrarMenu() {
System.out.println("***** Verificador de tipos de Pokemon *****");
System.out.println("1. Mostrar debilidades de un tipo de Pokemon");
System.out.println("2. Mostrar tipos eficaces contra un tipo de movimiento");
System.out.println("3. Mostrar información de un tipo de Pokemon");
System.out.println("4. Mostrar eficacia de un tipo de movimiento contra un tipo de Pokemon");
System.out.println("5. Salir");
System.out.println("********************************");
System.out.println("Ingrese el número de la opción deseada:");
}
private static void mostrarDebilidades(Scanner scanner) {
System.out.println("Ingrese el tipo de Pokemon para mostrar sus debilidades:");
String tipo = scanner.next().toUpperCase();

int indiceTipo = getIndiceTipo(tipo);

if (indiceTipo != -1) {
System.out.println("Las debilidades del tipo de Pokemon " + tipo + " son:");
for (int i = 0; i < TIPOS.length; i++) {
if (TABLA_TIPOS[i][indiceTipo] == 2) {
System.out.println(TIPOS[i]);
}
}
} else {
System.out.println("Tipo de Pokemon inválido. Por favor, ingrese un tipo válido.");
}
}
private static void mostrarTiposEficaces(Scanner scanner) {
System.out.println("Ingrese el tipo de movimiento para mostrar los tipos de Pokemon que son eficaces contra
él:");
String tipo = scanner.next().toUpperCase();

int indiceTipo = getIndiceTipo(tipo);

if (indiceTipo != -1) {
System.out.println("Los tipos de Pokemon que son eficaces contra " + tipo + " son:");
for (int i = 0; i < TIPOS.length; i++) {
if (TABLA_TIPOS[i][indiceTipo] == 2) {
System.out.println(TIPOS[i]);
}
}
} else {
System.out.println("Tipo de movimiento inválido. Por favor, ingrese un tipo válido.");
}
}
 private static void mostrarInformacionTipo(Scanner scanner) {
System.out.println("Ingrese el tipo de Pokemon para mostrar información sobre él:");
String tipo = scanner.next().toUpperCase();
int indiceTipo = getIndiceTipo(tipo);
if (indiceTipo != -1) {
System.out.println("Tipo: " + TIPOS[indiceTipo]);
System.out.println("Debilidades:");
for (int i = 0; i < TIPOS.length; i++) {
if (TABLA_TIPOS[indiceTipo][i] == 2) {
System.out.println(TIPOS[i]);
}
}
System.out.println("Resistencias:");
for (int i = 0; i < TIPOS.length; i++) {
if (TABLA_TIPOS[indiceTipo][i] == 0.5) {
System.out.println(TIPOS[i]);
}
}
System.out.println("Inmunidades:");
for (int i = 0; i < TIPOS.length; i++) {
if (TABLA_TIPOS[indiceTipo][i] == 0) {
System.out.println(TIPOS[i]);
}
}
} else {
System.out.println("Tipo de Pokemon inválido. Por favor, ingrese un tipo válido.");
}
}
private static void mostrarEficaciaMovimiento(Scanner scanner) {
System.out.println("Ingrese el tipo de movimiento:");
String tipoAtaque = scanner.next().toUpperCase();
System.out.println("Ingrese el tipo de Pokemon defensor:");
String tipoDefensor = scanner.next().toUpperCase();
int indiceTipoAtaque = getIndiceTipo(tipoAtaque);
int indiceTipoDefensor = getIndiceTipo(tipoDefensor);
if (indiceTipoAtaque != -1 && indiceTipoDefensor != -1) {
double eficacia = TABLA_TIPOS[indiceTipoDefensor][indiceTipoAtaque];
System.out.println("La eficacia del movimiento de tipo " + tipoAtaque + " contra un Pokemon de tipo " +
tipoDefensor + " es: " + eficacia);
} else {
System.out.println("Tipo de movimiento o tipo de Pokemon inválido. Por favor, ingrese tipos válidos.");
}
}
private static int getIndiceTipo(String tipo) {
for (int i = 0; i < TIPOS.length; i++) {
if (TIPOS[i].equals(tipo)) {
return i;
}
}
return -1;
}
}