Ejercicios propuestos y resueltos matrices de Java

public class Ejercicio_1 {

    public static void main(String[] args) {
        
        int matriz[][]=new int[3][3];
        
        //i = filas y j = columnas
        for(int i=0;i<matriz.length;i++){
            for(int j=0;j<matriz[0].length;j++){
                matriz[i][j]=(i*matriz.length)+(j+1);
                System.out.print(matriz[i][j]+" ");
                
            }
            System.out.println("");
        }
        
    }
    
}

import java.util.Scanner;

public class Ejercicio_2 {

   
    public static void main(String[] args) {
        
        Scanner sn=new Scanner(System.in);
        
        System.out.println("Escriba un numero de columnas");
        int columnas=sn.nextInt();
        
        int matriz[][]=new int[5][columnas];
        
        for(int i=0;i<matriz.length;i++){
            for(int j=0;j<matriz[0].length;j++){
                matriz[i][j]=generaNumAleatorio(0,9);
                System.out.print(matriz[i][j]+" ");
            }
            System.out.println("");
            
        }
        
    }
    
    public static int generaNumAleatorio(int minimo,int maximo){
        
        return (int)Math.floor(Math.random()*(minimo-(maximo+1))+(maximo+1));
        
    }
    
}

import java.util.Scanner;

public class Ejercicio_3 {

    public static void main(String[] args) {
        
        Scanner sn=new Scanner(System.in);
        
        System.out.println("Escribe un tamaño");
        int tamanio=sn.nextInt();
        
        int matriz1[][]=new int[tamanio][tamanio];
        int matriz2[][]=new int[tamanio][tamanio];
        
        int resultado[][]=new int[tamanio][tamanio];
        
        for(int i=0;i<matriz1.length;i++){
            for(int j=0;j<matriz1[0].length;j++){
                
                System.out.println("Escriba el valor para la fila "+i+" y columna "+j+" de la matriz 1");
                matriz1[i][j]=sn.nextInt();
                System.out.println("Escriba el valor para la fila "+i+" y columna "+j+" de la matriz 2");
                matriz2[i][j]=sn.nextInt();
                
                resultado[i][j]=matriz1[i][j]+matriz2[i][j];
            }
        }
        
        System.out.println("Matriz 1");
        muestraMatriz(matriz1);
        
        System.out.println("Matriz 2");
        muestraMatriz(matriz2);
        
        System.out.println("Matriz resultante");
        muestraMatriz(resultado);
                
    }
    
    public static void muestraMatriz(int[][] matriz){
    
        for(int i=0;i<matriz.length;i++){
            for(int j=0;j<matriz[0].length;j++){
                System.out.print(matriz[i][j]+" ");
            }
            System.out.println("");
        }
        
    }
    
}

import java.util.Scanner;

/**
 * Ejercicio 4 de matrices
 *
 * @author Discoduroderoer
 */
public class Ejercicio_matrices_DDR_04 {

    public static void main(String[] args) {

        Scanner sn = new Scanner(System.in);

        //Matriz cuadrada de 4x4
        int matriz[][] = new int[4][4];

        //Variables utilizadas
        boolean salir = false;
        int opcion, fila, columna;

        //Utilizado para indicar si hemos entrado en la 1ª opcion
        boolean rellenado = false;

        //Menu
        do {

            //Mensajes del menu
            System.out.println("Menu");
            System.out.println("1. Rellenar Matriz");
            System.out.println("2. Sumar fila");
            System.out.println("3. Sumar columna");
            System.out.println("4. Suma diagonal principal");
            System.out.println("5. Suma diagonal inversa");
            System.out.println("6. Media elementos");
            System.out.println("7. Salir");
            System.out.println("Elije una opcion");
            opcion = sn.nextInt();

            switch (opcion) {
                case 1:

                    rellenarMatriz(sn, matriz);

                    //Ahora si podemos acceder al resto de opciones
                    rellenado = true;

                    break;
                case 2:

                    if (rellenado) {

                        //Validamos la fila
                        do {

                            System.out.println("Elige una fila");
                            fila = sn.nextInt();

                        } while (!(fila >= 0 && fila < matriz.length));

                        System.out.println("La suma de los valores de la fila " + fila
                                + " es: " + sumaFila(matriz, fila));

                    } else {
                        System.out.println("Debes rellenar la matriz primero");
                    }

                    break;
                case 3:

                    if (rellenado) {

                        //Validamos la colunma
                        do {

                            System.out.println("Elige una fila");
                            columna = sn.nextInt();

                        } while (!(columna >= 0 && columna < matriz.length));

                        System.out.println("La suma de los valores de la columna " + columna
                                + " es: " + sumaColumna(matriz, columna));

                    } else {
                        System.out.println("Debes rellenar la matriz primero");
                    }

                    break;
                case 4:

                    if (rellenado) {

                        System.out.println("La suma de la diagonal principal es: " + sumaDiagonalPrinc(matriz));

                    } else {
                        System.out.println("Debes rellenar la matriz primero");
                    }

                    break;
                case 5:

                    if (rellenado) {

                        System.out.println("La suma de la diagonal inversa es: " + sumaDiagonalInversa(matriz));

                    } else {
                        System.out.println("Debes rellenar la matriz primero");
                    }

                    break;
                case 6:

                    if (rellenado) {

                        System.out.println("La media de los valores de la "
                                + "matriz es de " + media(matriz));

                    } else {
                        System.out.println("Debes rellenar la matriz primero");
                    }

                    break;
                case 7:
                    salir = true;
                    break;
                default:
                    System.out.println("Tienes que meter un valor entre 1 y 7");

            }

        } while (!salir);

        System.out.println("FIN");

    }

    /**
     * Rellena la matriz con valores insertados por el usuario
     *
     * @param sn
     * @param matriz
     */
    public static void rellenarMatriz(Scanner sn, int[][] matriz) {

        for (int i = 0; i < matriz.length; i++) {
            for (int j = 0; j < matriz[0].length; j++) {

                System.out.println("Escribe un numero en la posicion " + i + " " + j);
                matriz[i][j] = sn.nextInt();

            }
        }

    }

    /**
     * Suma los valores de una determinada fila
     *
     * @param matriz
     * @param fila
     * @return
     */
    public static int sumaFila(int[][] matriz, int fila) {

        int suma = 0;

        for (int j = 0; j < matriz.length; j++) {
            suma += matriz[fila][j];
        }

        return suma;

    }

    /**
     * Suma los valores de una determinada columna
     *
     * @param matriz
     * @param columna
     * @return
     */
    public static int sumaColumna(int[][] matriz, int columna) {

        int suma = 0;

        for (int i = 0; i < matriz.length; i++) {
            suma += matriz[i][columna];
        }

        return suma;

    }

    /**
     * Suma los valores de la diagonal principal de la matriz
     *
     * @param matriz
     * @return
     */
    public static int sumaDiagonalPrinc(int[][] matriz) {

        int suma = 0;

        for (int i = 0, j = 0; i < matriz.length; i++, j++) {
            suma += matriz[i][j];
        }

        return suma;

    }

    /**
     * Suma los valores de la diagonal inversa de la matriz
     *
     * @param matriz
     * @return
     */
    public static int sumaDiagonalInversa(int[][] matriz) {

        int suma = 0;

        for (int i = 0, j = 3; i < matriz.length; i++, j--) {
            suma += matriz[i][j];
        }

        return suma;

    }

    /**
     * Media de todos los elementos de la matriz
     *
     * @param matriz
     * @return
     */
    public static double media(int[][] matriz) {

        double suma = 0, media;

        for (int i = 0; i < matriz.length; i++) {
            for (int j = 0; j < matriz[0].length; j++) {
                suma += matriz[i][j];
            }
        }
        media = suma / (matriz.length * matriz.length);
        return media;

    }

}

— Constantes.java

public class Constantes {
    
    /*Tipos actuales de pokemon*/
    public static String[] tiposPokemon = {
                                            "ACERO", 
                                            "AGUA", 
                                            "BICHO",
                                            "DRAGÓN",
                                            "ELÉCTRICO",
                                            "FANTASMA",
                                            "FUEGO",
                                            "HADA",
                                            "HIELO",
                                            "LUCHA",
                                            "NORMAL",
                                            "PLANTA",
                                            "PSÍQUICO",
                                            "ROCA",
                                            "SINIESTRO",
                                            "TIERRA",
                                            "VENENO",
                                            "VOLADOR"
                                          };
    
    /*Mensaje segun la eficacia*/
    public static String[] MENSAJES_EFICACIAS = {
                                                    "NO ES MUY EFICAZ", 
                                                    "NEUTRO", 
                                                    "ES MUY EFICAZ", 
                                                    "NO AFECTA",
                                                    "DOBLEMENTE EFICAZ", 
                                                    "DOBLEMENTE NO MUY EFICAZ"
                                                };
 
    /*INDICES de los mensaje anteriores
        Asi no debes recordar en que posicion esta cada uno
    */
    
    public static int INDICE_NME=0;
    public static int INDICE_NEUTRO=1;
    public static int INDICE_EME=2;
    public static int INDICE_NA=3;
    public static int INDICE_DE=4;
    public static int INDICE_DNE=5;
    
    /*Eficiacias*/
    
    public static double EFICACIA_DE=4; /*DOBLEMENTE EFICAZ*/
    public static double EFICACIA_EME=2; /*ES MUY EFICAZ*/
    public static double EFICACIA_NEUTRO=1;
    public static double EFICACIA_NME=0.5; /*NO ES MUY EFICAZ*/
    public static double EFICACIA_DNE=0.25; /*DOBLEMENTE NO ES EFICAZ*/
    public static double EFICACIA_NA=0;  /*NO AFECTA*/
    
    /*
        FILAS = Pokemon atacante
        COLUMNAS = Pokemon que recibe el ataque
        
        Significados de los números:
            - 0.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 pero diremos neutro)
            - 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)

    */
    public static double[][] efectividadesPokemon = {
        
        /*ACERO   AGUA   BICHO   DRAGON   ELÉC   FANT   FUEGO   HADA   HIELO   LUCHA   NORMAL   PLANTA   PSI   ROCA   SINIE  TIERRA   VENENO   VOLADOR   */
        
        { 0.5   , 0.5  ,   1   ,   1    , 0.5  ,  1   ,  0.5   ,  2  ,   2   ,   1   ,    1    ,   1   ,  1   ,  2  ,   1   ,   1   ,    1   ,   1},   //ACERO
        {  1    , 0.5  ,   1   ,  0.5   ,  1   ,  1   ,   2    ,  1  ,   1   ,   1   ,    1    ,  0.5  ,  1   ,  2  ,   1   ,   2   ,    1   ,   1},   //AGUA
        { 0.5   ,  1   ,   1   ,   1    ,  1   , 0.5  ,  0.5   , 0.5 ,   1   ,  0.5  ,    1    ,   2   ,  2   ,  1  ,   2   ,   1   ,   0.5  ,  0.5},  //BICHO
        { 0.5   ,  1   ,   1   ,   2    ,  1   ,  1   ,   1    ,  0  ,   1   ,   1   ,    1    ,   1   ,  1   ,  1  ,   1   ,   1   ,    1   ,   1},   // DRAGÓN
        {  1    ,  2   ,   1   ,  0.5   , 0.5  ,  1   ,   1    ,  1  ,   1   ,   1   ,    1    ,  0.5  ,  1   ,  1  ,   1   ,   0   ,    1   ,   2},   // ELÉCTRICO
        {  1    ,  1   ,   1   ,   1    ,  1   ,  2   ,   1    ,  1  ,   1   ,   1   ,    0    ,   1   ,  2   ,  1  ,  0.5  ,   1   ,    1   ,   1},   // FANTASMA
        {  2    , 0.5  ,   2   ,  0.5   ,  1   ,  1   ,  0.5   ,  1  ,   2   ,   1   ,    1    ,   2   ,  1   , 0.5 ,   1   ,   1   ,    1   ,   1},   // FUEGO
        { 0.5   ,  1   ,   1   ,   2    ,  1   ,  1   ,  0.5   ,  1  ,   1   ,   2   ,    1    ,   1   ,  1   ,  1  ,   2   ,   1   ,   0.5  ,   1},   // HADA
        { 0.5   , 0.5  ,   1   ,   2    ,  1   ,  1   ,  0.5   ,  1  ,  0.5  ,   1   ,    1    ,   2   ,  1   ,  1  ,   1   ,   2   ,    1   ,   2},   // HIELO
        {  2    ,  1   ,  0.5  ,   1    ,  1   ,  0   ,   1    , 0.5 ,   2   ,   1   ,    2    ,   1   , 0.5  ,  2  ,   2   ,   1   ,   0.5  ,  0.5},  // LUCHA
        { 0.5   ,  1   ,   1   ,   1    ,  1   ,  0   ,   1    ,  1  ,   1   ,   1   ,    1    ,   1   ,  1   , 0.5 ,   1   ,   1   ,    1   ,   1},   // NORMAL
        { 0.5   ,  2   ,  0.5  ,  0.5   ,  1   ,  1   ,  0.5   ,  1  ,   1   ,   1   ,    1    ,  0.5  ,  1   ,  2  ,   1   ,   2   ,   0.5  ,  0.5},  // PLANTA
        { 0.5   ,  1   ,   1   ,   1    ,  1   ,  1   ,   1    ,  1  ,   1   ,   2   ,    1    ,   1   , 0.5  ,  1  ,   0   ,   1   ,    2   ,   1},   // PSÍQUICO
        { 0.5   ,  1   ,   2   ,   1    ,  1   ,  1   ,   2    ,  1  ,   2   ,  0.5  ,    1    ,   1   ,  1   ,  1  ,   1   ,  0.5  ,    1   ,   2},   // ROCA
        {  1    ,  1   ,   1   ,   1    ,  1   ,  2   ,   1    , 0.5 ,   1   ,  0.5  ,    1    ,   1   ,  2   ,  1  ,  0.5  ,   1   ,    1   ,   1},   // SINIESTRO
        {  2    ,  1   ,  0.5  ,   1    ,  2   ,  1   ,   2    ,  1  ,   1   ,   1   ,    1    ,  0.5  ,  1   ,  2  ,   1   ,   1   ,    2   ,   0},   // TIERRA
        {  0    ,  1   ,   1   ,   1    ,  1   , 0.5  ,   1    ,  2  ,   1   ,   1   ,    1    ,   2   ,  1   , 0.5 ,   1   ,  0.5  ,   0.5  ,   1},   // VENENO
        { 0.5   ,  1   ,   2   ,   1    , 0.5  ,  1   ,   1    ,  1  ,   1   ,   2   ,    1    ,   2   ,  1   , 0.5 ,   1   ,   1   ,    1   ,   1}    // VOLADOR
    };
    
    
}

— Main

import java.util.Scanner;

/**
 * Ejercicio 5 de matrices, tabla de tipos para Folagor03
 *
 * @author DiscoDurodeRoer
 */
public class Ejercicio_matrices_DDR_05 {

    public static void main(String[] args) {

        Scanner sn = new Scanner(System.in);

        //Variables a utilizar
        boolean salir = false;
        int opcion = 0, tipo1, tipo2, tipo3, num_tipos;

        //Menu
        do {

            System.out.println("Programa para folagor03");
            System.out.println("1. Mostrar debilidades");
            System.out.println("2. Mostrar eficacias");
            System.out.println("3. Mostrar toda la informacion de un tipo");
            System.out.println("4. Eficacia de un tipo a otro");
            System.out.println("5. Salir");
            System.out.println("Elije una opción");
            opcion = sn.nextInt();

            switch (opcion) {

                case 1:

                    //Pedimos el numero de tipos y validamos, solo 1 o 2 tipos
                    do {

                        System.out.println("Elije el numero de tipos, solo 1 o 2");
                        num_tipos = sn.nextInt();

                        if (!(num_tipos == 1 || num_tipos == 2)) {
                            System.out.println("Tienes que introducir 1 o 2");
                        }

                    } while (!(num_tipos == 1 || num_tipos == 2));

                    //elegimos el primer tipo
                    System.out.println("Primer tipo del pokemon");
                    tipo1 = elegirTipo(sn);

                    if (num_tipos == 2) {

                        //Si elegimos 2 tipos, aqui elegimos el 2º tipo
                        //Validamos para que no se repita, no existe el tipo FUEGO FUEGO por ejemplo
                        do {

                            System.out.println("Segundo tipo del pokemon");
                            tipo2 = elegirTipo(sn);
                            if (tipo2 == tipo1) {
                                System.out.println("Los tipos no deben ser iguales");
                            }

                        } while (tipo2 == tipo1);

                        //Mostramos las debilidades de los dos tipos
                        mostrarDebilidades(tipo1, tipo2);

                    } else {

                        //Mostramos las debilidades de los tipos
                        mostrarDebilidades(tipo1);
                    }

                    break;
                case 2:

                    //elegimos el primer y único tipo
                    System.out.println("Tipo del pokemon atacante");
                    tipo1 = elegirTipo(sn);

                    //Mostramos las eficacias
                    mostrarEficaces(tipo1);

                    break;
                case 3:

                    //elegimos el primer y único tipo
                    System.out.println("Tipo del pokemon atacante");
                    tipo1 = elegirTipo(sn);

                    //Mostramos la información respecto al tipo
                    mostrarInfo(tipo1);

                    break;
                case 4:

                    //Pedimos si queremos uno o dos tipos y validamos
                    do {

                        System.out.println("Elije el numero de tipos del oponente, solo 1 o 2");
                        num_tipos = sn.nextInt();

                        if (!(num_tipos == 1 || num_tipos == 2)) {
                            System.out.println("Tienes que introducir 1 o 2");
                        }

                    } while (!(num_tipos == 1 || num_tipos == 2));

                    System.out.println("Pokemon atacante");
                    tipo1 = elegirTipo(sn);

                    System.out.println("Primer tipo del pokemon oponente");
                    tipo2 = elegirTipo(sn);

                    if (num_tipos == 2) {

                        do {

                            System.out.println("Segundo tipo del pokemon oponente");
                            tipo3 = elegirTipo(sn);
                            if (tipo3 == tipo2) {
                                System.out.println("Los tipos no deben ser iguales");
                            }

                        } while (tipo2 == tipo3);

                        mostrarEficaciaTipo(tipo1, tipo2, tipo3);
                    } else {
                        mostrarEficaciaTipo(tipo1, tipo2);
                    }
                    break;

                case 5:
                    salir = true;
                    break;
                default:

            }

        } while (!salir);

    }

    /**
     * Listamos los tipos de pokemon que hay
     */
    private static void listarTipos() {

        for (int i = 0; i < Constantes.tiposPokemon.length; i++) {
            System.out.println(i + ". " + Constantes.tiposPokemon[i]);
        }

    }

    /**
     * Elegimos el tipo de pokemon que queremos
     *
     * @param sn
     * @return indice del tipo de pokemon que usaremos
     */
    public static int elegirTipo(Scanner sn) {

        int eleccion;
        listarTipos();

        do {
            eleccion = sn.nextInt();

            if (!(eleccion >= 0 && eleccion < Constantes.tiposPokemon.length)) {
                System.out.println("Tiene que estar entre 0 y 17");
            }

        } while (!(eleccion >= 0 && eleccion < Constantes.tiposPokemon.length));

        return eleccion;

    }

    /**
     * Muestra todas las debilidades del tipo pasado
     *
     * @param tipo
     */
    public static void mostrarDebilidades(int tipo) {

        for (int i = 0; i < Constantes.efectividadesPokemon.length; i++) {

            if (Constantes.efectividadesPokemon[i][tipo] == Constantes.EFICACIA_EME) {
                System.out.println("- " + Constantes.tiposPokemon[i]);
            }

        }

    }

    /**
     * Muestra todas las debilidades comunes de los tipos pasados
     *
     * @param tipo1
     * @param tipo2
     */
    public static void mostrarDebilidades(int tipo1, int tipo2) {

        double efectividadFinal = 0;

        for (int i = 0; i < Constantes.efectividadesPokemon.length; i++) {

            efectividadFinal = Constantes.efectividadesPokemon[i][tipo1] * Constantes.efectividadesPokemon[i][tipo2];

            if (efectividadFinal >= Constantes.EFICACIA_EME) {
                System.out.println("- " + Constantes.tiposPokemon[i] + ": x" + (int) efectividadFinal);
            }

        }

    }

    /**
     * Muestra las eficacias del tipo pasado
     *
     * @param tipo
     */
    public static void mostrarEficaces(int tipo) {

        for (int j = 0; j < Constantes.efectividadesPokemon.length; j++) {

            if (Constantes.efectividadesPokemon[tipo][j] == Constantes.EFICACIA_EME) {
                System.out.println("- " + Constantes.tiposPokemon[j]);
            }

        }

    }

    /**
     * Muestra la informacion del tipo pasado
     *
     * @param tipo
     */
    public static void mostrarInfo(int tipo) {

        for (int j = 0; j < Constantes.efectividadesPokemon.length; j++) {
            System.out.println("- " + Constantes.tiposPokemon[j] + " " + mostrarEficacia(Constantes.efectividadesPokemon[tipo][j]));
        }

    }

    /**
     * Muestra el mensaje asociado a la eficacia
     *
     * @param eficacia
     * @return
     */
    public static String mostrarEficacia(double eficacia) {

        String mensaje;

        if (eficacia == Constantes.EFICACIA_DE) {
            mensaje = Constantes.MENSAJES_EFICACIAS[Constantes.INDICE_DE];
        } else if (eficacia == Constantes.EFICACIA_EME) {
            mensaje = Constantes.MENSAJES_EFICACIAS[Constantes.INDICE_EME];
        } else if (eficacia == Constantes.EFICACIA_NEUTRO) {
            mensaje = Constantes.MENSAJES_EFICACIAS[Constantes.INDICE_NEUTRO];
        } else if (eficacia == Constantes.EFICACIA_NME) {
            mensaje = Constantes.MENSAJES_EFICACIAS[Constantes.INDICE_NME];
        } else if (eficacia == Constantes.EFICACIA_DNE) {
            mensaje = Constantes.MENSAJES_EFICACIAS[Constantes.INDICE_DNE];
        } else {
            mensaje = Constantes.MENSAJES_EFICACIAS[Constantes.INDICE_NA];
        }

        return mensaje;

    }

    /**
     * Muestra la eficacia (con palabras) de un tipo a otro tipo
     *
     * @param tipoAtacante
     * @param tipoOponente
     */
    public static void mostrarEficaciaTipo(int tipoAtacante, int tipoOponente) {
        System.out.println(mostrarEficacia(Constantes.efectividadesPokemon[tipoAtacante][tipoOponente]));
    }

    /**
     * Muestra la eficacia (con palabras) de un tipo a un pokemon con dos tipos
     *
     * @param tipoAtacante
     * @param tipo1Oponente
     * @param tipo2Oponente
     */
    public static void mostrarEficaciaTipo(int tipoAtacante, int tipo1Oponente, int tipo2Oponente) {
        //multiplico las efectivadades
        double efectividad = Constantes.efectividadesPokemon[tipoAtacante][tipo1Oponente] * Constantes.efectividadesPokemon[tipoAtacante][tipo2Oponente];
        System.out.println(mostrarEficacia(efectividad));
    }

}

import java.util.Arrays;

public class Ejercicio_matrices_DDR_06 {

   
    public static void main(String[] args) {
      
        int matriz[][]=new int [3][3];
        
        int[] numeros=generarNumerosAleatoriosSinRepetir(1, 9, matriz.length*matriz[0].length);
        
        for(int i=0;i<matriz.length;i++){
            for(int j=0;j<matriz[0].length;j++){
                matriz[i][j]=numeros[(matriz.length*i) + j ];
                System.out.print(matriz[i][j]+" ");
            }
            System.out.println("");
        }
        
        
        
    }
    
    
    //Funcion para generar numeroa aleatorios que no se repitan
    public static int[] generarNumerosAleatoriosSinRepetir(int minimo, int maximo, int longitud){
       
        //En caso de que uno sea mayotr que otro
        //Lo intercambiamos
        if(maximo<minimo){
            int aux=maximo;
            maximo=minimo;
            minimo=aux;
        }
        
        //Si caben los numeros del rango
        //Generamos el array
        if( (maximo-minimo) >= (longitud-1) ){
        
            int numero_elementos=0;
            int numeros[]=new int[longitud];
            //RECOMENDADO: rellena el arreglo con un numero que nunca se va a generar
            Arrays.fill(numeros, minimo-1);
            boolean encontrado;
            int aleatorio;
            
            //Hasta que el numero de elementos no sea como el de la longitud del array no salimos
            while(numero_elementos<longitud){
                
                aleatorio=generaNumeroAleatorio(minimo, maximo);
                encontrado=false;            

                //Buscamos si el numero existe
                for(int i=0;i<numeros.length && !encontrado;i++){
                    if(aleatorio==numeros[i]){
                        encontrado=true;
                    }
                }
                
                //Sino lo agregamos
                if(!encontrado){
                    numeros[numero_elementos++] = aleatorio;
                }
                
            }
            
            return numeros;
            
        }else{
            System.out.println("No se puede generar el arreglo, revusa los parametros");
            return null;
        }
        
        
    }
    
    //Genera un numero aleatorio entre el minimo y el maximo, includo el maximo y el minimo
    public static int generaNumeroAleatorio(int minimo,int maximo){
        
        int num=(int)Math.floor(Math.random()*(maximo-minimo+1)+(minimo));
        return num;
    }
    
    
}

import java.util.Arrays;

public class Ejercicio_matrices_DDR_07 {

    
    public static void main(String[] args) {
      
        int matriz[][]=new int [3][3];
        
        int[] numeros=generarNumerosAleatoriosSinRepetir(1, 9, matriz.length*matriz[0].length);
        
        //Generamos la matriz
        for(int i=0;i<matriz.length;i++){
            for(int j=0;j<matriz[0].length;j++){
                //Linea clave: recordar usar la columna no la fila
                matriz[i][j]=numeros[(matriz[0].length*i) + j ];
                System.out.print(matriz[i][j]+" ");
            }
            System.out.println("");
        }
        
        //Generamos si elegimos fila o columna
        int fila_columna=generaNumeroAleatorio(1,2);
        int fila_columna_indice;
        int suma=0;
        
        //Fila == 1
        //Columna == 2
        if(fila_columna==1){
            System.out.println("Se ha elegido Fila");
            //Generamos el indice de la fila
            fila_columna_indice=generaNumeroAleatorio(0,matriz.length-1);
            System.out.println("Se ha elefio el indice: "+fila_columna_indice);
            
            for(int i=0;i<matriz[0].length;i++){
                suma += matriz[fila_columna_indice][i];
            }
            
            
        }else{
            System.out.println("Se ha elegido Columna");
            //Generamos el indice de la fila
            fila_columna_indice=generaNumeroAleatorio(0,matriz[0].length-1);
            System.out.println("Se ha elefio el indice: "+fila_columna_indice);
            
            for(int i=0;i<matriz.length;i++){
                suma += matriz[i][fila_columna_indice];
            }
        
        }
        
        System.out.println("La suma es: "+suma);
        
    }
    
    
    //Funcion para generar numeroa aleatorios que no se repitan
    public static int[] generarNumerosAleatoriosSinRepetir(int minimo, int maximo, int longitud){
       
        //En caso de que uno sea mayotr que otro
        //Lo intercambiamos
        if(maximo<minimo){
            int aux=maximo;
            maximo=minimo;
            minimo=aux;
        }
        
        //Si caben los numeros del rango
        //Generamos el array
        if( (maximo-minimo) >= (longitud-1) ){
        
            int numero_elementos=0;
            int numeros[]=new int[longitud];
            //RECOMENDADO: rellena el arreglo con un numero que nunca se va a generar
            Arrays.fill(numeros, minimo-1);
            boolean encontrado;
            int aleatorio;
            
            //Hasta que el numero de elementos no sea como el de la longitud del array no salimos
            while(numero_elementos<longitud){
                
                aleatorio=generaNumeroAleatorio(minimo,maximo);
                encontrado=false;            

                //Buscamos si el numero existe
                for(int i=0;i<numeros.length && !encontrado;i++){
                    if(aleatorio==numeros[i]){
                        encontrado=true;
                    }
                }
                
                //Sino lo agregamos
                if(!encontrado){
                    numeros[numero_elementos++] = aleatorio;
                }
                
            }
            
            return numeros;
            
        }else{
            System.out.println("No se puede generar el arreglo, revusa los parametros");
            return null;
        }
        
        
    }
    
    //Genera un numero aleatorio entre el minimo y el maximo, includo el maximo y el minimo
    public static int generaNumeroAleatorio(int minimo,int maximo){
        
        int num=(int)Math.floor(Math.random()*(maximo-minimo+1)+(minimo));
        return num;
    }
    
}

import java.util.InputMismatchException;
import java.util.Scanner;

public class Ejercicio_matrices_DDR_08 {

    //Creamos un scanner estatico para
    static Scanner sn = new Scanner(System.in);

    public static void main(String[] args) {

        //Llamo al método menu
        menu();

    }

    /**
     * Muestra el menu, solicita la opcion y las ejecuta
     */
    public static void menu() {

        //Nombre de las golosinas
        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"}
        };

        //Precio de las golosinas
        double[][] precio = {
            {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}
        };

        int cantidad[][] = new int[4][4];

        //Relleno la matriz con 5
        rellenarMatriz(cantidad, 5);

        //Indica si salimos o no
        boolean salir = false;
        int opcion, fila, columna, cantidadNueva;
        String pos, password;
        double ventaTotales = 0;

        //Bucle para pedir las opciones hasta que elijamos salir
        while (!salir) {

            //opciones
            System.out.println("1. Pedir golosina");
            System.out.println("2. Mostrar golosinas");
            System.out.println("3. Rellenar golosinas");
            System.out.println("4. Apagar maquina");

            try {

                //Pide una opcion
                System.out.println("Introduce un numero: ");
                opcion = sn.nextInt();

                //Realiza una de las opciones
                switch (opcion) {
                    case 1:

                        //Pido la posicion
                        pos = pedirCadena("Introduce la posicion que quieras");

                        //Valido la posicion
                        if (validarPos(nombresGolosinas, pos)) {
                            
                            //Extraigo la fila y columna
                            fila = extraerNumero(pos, 0);
                            columna = extraerNumero(pos, 1);

                            //Indico si hay valores en la matriz
                            if (hayValorPosicion(cantidad, fila, columna)) {
                                //Muestro la golosina
                                System.out.println("Aqui tiene su golosiona: " + nombresGolosinas[fila][columna] + ". Gracias por su compra");

                                //Reduzco la cantidad en 1
                                reducirPosicion(cantidad, fila, columna, 1);

                                //aumento la cantidad
                                ventaTotales += precio[fila][columna];

                            } else {
                                System.out.println("No hay mas golosinas de este tipo, espere al técnico para que la rellene");
                            }

                        } else {
                            System.out.println("La posicion introducida no es valida");
                        }

                        break;
                    case 2:

                        //muestro las golosinas
                        mostrarGolosionas(nombresGolosinas, precio);

                        break;
                    case 3:

                        //pido el password
                        password = pedirCadena("Introduce la contraseña");

                        //Compruebo si es correcta la contraseña
                        if (cadenaIguales(password, "MaquinaExpendedora2017")) {

                            //Pido la posicion
                            pos = pedirCadena("Introduce la posicion que quieras");
                            
                            //Extraigo los numeros
                            fila = extraerNumero(pos, 0);
                            columna = extraerNumero(pos, 1);

                            //Validamos la posicion dada
                            if (validarPos(nombresGolosinas, pos)) {
                                //Introducimos la cantidad
                                cantidadNueva = pedirInteger("Introduce la cantidad");

                                //Aumentamos la cantidad en el valor dado
                                aumentarPosicion(cantidad, fila, columna, cantidadNueva);

                                System.out.println("Se ha incrementado la cantidad");

                            }else{
                                 System.out.println("La posicion introducida no es valida");
                            }

                        }else{
                            System.out.println("La contraseña incorrecta");
                        }

                        break;
                    case 4:
                        
                        //Muestro las ventas
                        System.out.println("Las ventas han sido de "+ventaTotales);
                        
                        salir = true;
                        break;
                    default:
                        System.out.println("Las opciones son entre 1 y 7");
                }

                //controla la excepcionn en caso de que se introduzca un valor no correcto
            } catch (InputMismatchException e) {
                System.out.println("Debes escribir un numero");
                sn.next();
            }

        }

        System.out.println("Fin del menu");

    }

    /**
     * Rellena la matriz con un numero
     * @param matriz
     * @param num 
     */
    public static void rellenarMatriz(int[][] matriz, int num) {

        for (int i = 0; i < matriz.length; i++) {
            for (int j = 0; j < matriz.length; j++) {
                matriz[i][j] = num;
            }
        }

    }

    /**
     * Pide una cadena
     * @param mensaje
     * @return 
     */
    public static String pedirCadena(String mensaje) {

        System.out.println(mensaje);
        String cadena = sn.next();

        return cadena;

    }

    /**
     * Pide un integer
     * @param mensaje
     * @return 
     */
    public static int pedirInteger(String mensaje) {

        System.out.println(mensaje);
        int numero = sn.nextInt();

        return numero;

    }

    /**
     * Valida si una posicion es correcta
     * @param matriz
     * @param pos
     * @return 
     */
    public static boolean validarPos(String[][] matriz, String pos) {

        if (pos.length() != 2) {
            return false;
        }

        if (!(esNumero(pos.substring(0, 1)) && esNumero(pos.substring(1, 2)))) {
            return false;
        }

        int fila = extraerNumero(pos, 0);
        int columna = extraerNumero(pos, 1);

        if (!((fila >= 0 && fila < matriz.length) && (columna >= 0 && columna < matriz[0].length))) {
            return false;
        }

        return true;

    }

    /**
     * Indico si un String es un numero
     * @param num
     * @return 
     */
    public static boolean esNumero(String num) {

        try {
            Integer.parseInt(num);
            return true;
        } catch (NumberFormatException e) {
            return false;
        }

    }

    /**
     * Extraigo el numero, -1 si ha habido un error
     * @param numero
     * @param pos
     * @return 
     */
    public static int extraerNumero(String numero, int pos) {

        int num = -1;
        if (esNumero(numero)) {
            num = Integer.parseInt(numero.substring(pos, pos + 1));
        }

        return num;

    }

    /**
     * Reduce la cantidad de una posicion en concreto
     * @param matriz
     * @param fila
     * @param columna
     * @param cantidad 
     */
    public static void reducirPosicion(int[][] matriz, int fila, int columna, int cantidad) {
        matriz[fila][columna] -= cantidad;
    }

    /**
     * Indica si en una posicion hay un valor mayor que 0
     * @param matriz
     * @param fila
     * @param columna
     * @return 
     */
    public static boolean hayValorPosicion(int[][] matriz, int fila, int columna) {
        if (matriz[fila][columna] > 0) {
            return true;
        }

        return false;
    }

    /**
     * Muestra las golosinas
     * @param nombres
     * @param precios 
     */
    public static void mostrarGolosionas(String[][] nombres, double[][] precios) {

        for (int i = 0; i < nombres.length; i++) {
            for (int j = 0; j < nombres[i].length; j++) {

                System.out.println(i + "" + j + " " + nombres[i][j] + " " + precios[i][j]);

            }
        }

    }

    /**
     * Indica si dos cadenas son iguales
     * @param cadena1
     * @param cadena2
     * @return 
     */
    public static boolean cadenaIguales(String cadena1, String cadena2) {

        if (cadena1.equals(cadena2)) {
            return true;
        } else {
            return false;
        }

    }

    /**
     * Aumenta la cantidad de una posicion
     * @param matriz
     * @param fila
     * @param columna
     * @param cantidad 
     */
    public static void aumentarPosicion(int[][] matriz, int fila, int columna, int cantidad) {
        matriz[fila][columna] += cantidad;
    }

}

import java.util.Scanner;

public class Ejercicio_matrices_DDR_09 {

    static Scanner teclado = new Scanner(System.in);

    public static void main(String[] args) {
        jugar();
    }

    /**
     * Metodo donde empezaremos a jugar
     */
    public static void jugar() {

        //Reprentaciones de los jugadores y del simbolo vacio
        char J1 = 'X';
        char J2 = 'O';
        char vacio = '-';

        //turno actual
        //true = J1, false = J2
        boolean turno = true;

        //tablero donde vamos a jugar
        char tablero[][] = new char[3][3];

        //rellenamos la matriz con los guiones
        rellenarMatriz(tablero, vacio);

        int fila, columna;
        boolean posValida, correcto;

        //No salimos hasta que uno gane o no haya mas posibilidades
        while (!finPartida(tablero, vacio)) {

            do {

                //mostramos el jugador al que le toca
                mostrarTurnoActual(turno);

                //muestro el tablero
                mostrarMatriz(tablero);

                correcto = false;
                fila = pedirInteger("Dame la fila");
                columna = pedirInteger("Dame la columna");

                //Validamos la posicion
                posValida = validarPosicion(tablero, fila, columna);

                //Si es valido, comprobamos que no haya ninguna marca
                if (posValida) {

                    //Si no hay marca, significa que es correcto
                    if (!hayValorPosicion(tablero, fila, columna, vacio)) {
                        correcto = true;
                    } else {
                        System.out.println("Ya hay una marca en esa posicion");
                    }
                } else {
                    System.out.println("La posicion no es valida");
                }

                //Mientras no sea correcto, no salgo
            } while (!correcto);

            //depende del turno, inserta un simbolo u otro
            if (turno) {
                insertarEn(tablero, fila, columna, J1);
            } else {
                insertarEn(tablero, fila, columna, J2);
            }

            //cambio de turno
            turno = !turno;
        }

        //Muestra el tablero
        mostrarMatriz(tablero);

        //Mostramos el ganador
        mostrarGanador(tablero, J1, J2, vacio);

    }

    /**
     *
     * @param matriz
     * @param J1
     * @param J2
     * @param simDef
     */
    public static void mostrarGanador(char[][] matriz, char J1, char J2, char simDef) {

        char simbolo = coincidenciaLinea(matriz, simDef);

        if (simbolo != simDef) {

            ganador(simbolo, J1, J2, 1);

            return;

        }

        simbolo = coincidenciaColumna(matriz, simDef);

        if (simbolo != simDef) {

            ganador(simbolo, J1, J2, 2);

            return;

        }

        simbolo = coincidenciaDiagonal(matriz, simDef);

        if (simbolo != simDef) {

            ganador(simbolo, J1, J2, 3);

            return;

        }

        System.out.println("Hay empate");

    }

    /**
     * Funcion auxiliar de la anterior funcion
     * @param simbolo
     * @param J1
     * @param J2
     * @param tipo 
     */
    public static void ganador(char simbolo, char J1, char J2, int tipo) {

        switch (tipo) {
            case 1:
                if (simbolo == J1) {
                    System.out.println("Ha ganado el Jugador 1 por linea");
                } else {
                    System.out.println("Ha ganado el Jugador 2 por linea");
                }

                break;
            case 2:
                if (simbolo == J1) {
                    System.out.println("Ha ganado el Jugador 1 por columna");
                } else {
                    System.out.println("Ha ganado el Jugador 2 por columna");
                }
                break;
            case 3:
                if (simbolo == J1) {
                    System.out.println("Ha ganado el Jugador 1 por diagonal");
                } else {
                    System.out.println("Ha ganado el Jugador 2 por diagonal");
                }
                break;
        }

    }

    /**
     * Insertamos en una posicion de una matriz un simbolo en concreto
     *
     * @param matriz
     * @param fila
     * @param columna
     * @param simbolo
     */
    public static void insertarEn(char[][] matriz, int fila, int columna, char simbolo) {
        matriz[fila][columna] = simbolo;
    }

    /**
     * Mostramos el turno actual
     *
     * @param turno
     */
    public static void mostrarTurnoActual(boolean turno) {

        if (turno) {
            System.out.println("Le toca al jugador 1");
        } else {
            System.out.println("Le toca al jugador 2");
        }

    }

    /**
     * Pedimos un numero y lo devolvemos
     *
     * @param mensaje
     * @return
     */
    public static int pedirInteger(String mensaje) {

        System.out.println(mensaje);
        int numero = teclado.nextInt();

        return numero;

    }

    /**
     * Rellena la matriz con un simbolo
     *
     * @param matriz
     * @param simbolo
     */
    public static void rellenarMatriz(char[][] matriz, char simbolo) {

        for (int i = 0; i < matriz.length; i++) {
            for (int j = 0; j < matriz.length; j++) { matriz[i][j] = simbolo; } } } /** * Validamos la posicion que nos insertan * * @param tablero * @param fila * @param columna * @return */ public static boolean validarPosicion(char[][] tablero, int fila, int columna) { if (fila >= 0 && fila < tablero.length && columna >= 0 && columna < tablero.length) {
            return true;
        }
        return false;

    }

    /**
     * Indicamos si en una posicion hay una marca
     *
     * @param matriz
     * @param fila
     * @param columna
     * @param simboloDef
     * @return
     */
    public static boolean hayValorPosicion(char[][] matriz, int fila, int columna, char simboloDef) {
        if (matriz[fila][columna] != simboloDef) {
            return true;
        }

        return false;
    }

    /**
     * Muestra la matriz
     *
     * @param matriz
     */
    public static void mostrarMatriz(char[][] matriz) {

        for (int i = 0; i < matriz.length; i++) {
            for (int j = 0; j < matriz[0].length; j++) {
                System.out.print(matriz[i][j] + " ");
            }
            System.out.println("");
        }

    }

    /**
     * Indica si la matriz esta llena cuando el simbolo por defecto aparezca, no
     * esta llena
     *
     * @param matriz
     * @param simboloDef
     * @return
     */
    public static boolean matrizLlena(char[][] matriz, char simboloDef) {
        for (int i = 0; i < matriz.length; i++) {
            for (int j = 0; j < matriz[0].length; j++) {
                if (matriz[i][j] == simboloDef) {
                    return false;
                }
            }
        }

        return true;

    }

    /**
     * La partida acaba cuando la matriz esta llena o hay un ganador
     *
     * @param matriz
     * @param simboloDef
     * @return
     */
    public static boolean finPartida(char[][] matriz, char simboloDef) {

        if (matrizLlena(matriz, simboloDef)
                || coincidenciaLinea(matriz, simboloDef) != simboloDef
                || coincidenciaColumna(matriz, simboloDef) != simboloDef
                || coincidenciaDiagonal(matriz, simboloDef) != simboloDef) {
            return true;
        }

        return false;
    }

    /**
     * Indica si hay un ganador en una linea
     *
     * @param matriz
     * @param simboloDef
     * @return simbolo ganador, sino lo hay devuelve el de por defecto
     */
    public static char coincidenciaLinea(char[][] matriz, char simboloDef) {

        char simbolo;
        boolean coincidencia;

        for (int i = 0; i < matriz.length; i++) {

            //Reiniciamos la coincidencia
            coincidencia = true;
            //Cogemos el simbolo de la fila
            simbolo = matriz[i][0];
            if (simbolo != simboloDef) {
                for (int j = 1; j < matriz[0].length; j++) {
                    //sino coincide ya no habra ganadro en esta fila
                    if (simbolo != matriz[i][j]) {
                        coincidencia = false;
                    }
                }

                //Si no se mete en el if, devuelvo el simbolo ganador
                if (coincidencia) {
                    return simbolo;
                }

            }

        }

        //Si no hay ganador, devuelvo el simbolo por defecto
        return simboloDef;

    }

    public static char coincidenciaColumna(char[][] matriz, char simboloDef) {

        char simbolo;
        boolean coincidencia;

        for (int j = 0; j < matriz.length; j++) {

            //Reiniciamos la coincidencia
            coincidencia = true;
            //Cogemos el simbolo de la columna
            simbolo = matriz[0][j];
            if (simbolo != simboloDef) {
                for (int i = 1; i < matriz[0].length; i++) {
                    //sino coincide ya no habra ganadro en esta fila
                    if (simbolo != matriz[i][j]) {
                        coincidencia = false;
                    }
                }

                //Si no se mete en el if, devuelvo el simbolo ganador
                if (coincidencia) {
                    return simbolo;
                }

            }

        }

        //Si no hay ganador, devuelvo el simbolo por defecto
        return simboloDef;

    }

    public static char coincidenciaDiagonal(char[][] matriz, char simboloDef) {

        char simbolo;
        boolean coincidencia = true;

        //Diagonal principal
        simbolo = matriz[0][0];
        if (simbolo != simboloDef) {
            for (int i = 1; i < matriz.length; i++) {
                //sino coincide ya no habra ganadro en esta fila
                if (simbolo != matriz[i][i]) {
                    coincidencia = false;
                }
            }

            //Si no se mete en el if, devuelvo el simbolo ganador
            if (coincidencia) {
                return simbolo;
            }

        }

        //Diagonal inversa
        simbolo = matriz[0][2];
        if (simbolo != simboloDef) {
            for (int i = 1, j = 1; i < matriz.length; i++, j--) {
                //sino coincide ya no habra ganadro en esta fila
                if (simbolo != matriz[i][j]) {
                    coincidencia = false;
                }
            }

            //Si no se mete en el if, devuelvo el simbolo ganador
            if (coincidencia) {
                return simbolo;
            }
        }

        //Si no hay ganador, devuelvo el simbolo por defecto
        return simboloDef;

    }

}

public class SumaMatricesApp {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		//Creamos los arrays multidimensionales
		int tabla1[][]=new int [2][3];
		int tabla2[][]=new int [2][3];
		int sumamatrices[][]=new int [tabla1.length][tabla1[0].length];

		//Rellenamos los dos primeros arrays
		rellenarArrays(tabla1, 1, 200);
		rellenarArrays(tabla2, 1, 200);

		//Sumamos los arrays
		SumaMatrices(tabla1, tabla2, sumamatrices);

		//Mostramos los arrays
		System.out.println("Array1 ");
		imprimirTabla(tabla1);

		System.out.println("Array2");
		imprimirTabla(tabla2);

		System.out.println("La suma de matrices es ");
		imprimirTabla(sumamatrices);
	}
	public static void rellenarArrays(int tabla[][], int a, int b){
		for(int i=0;i<tabla.length;i++){
			for(int j=0;j<tabla[0].length;j++){
				tabla[i][j]=((int)Math.floor(Math.random()*(a-b)+b));
			}
		}
	}

	public static void imprimirTabla (int tabla[][]){
		for (int i=0;i<tabla.length;i++){
			for (int j=0;j<tabla[0].length;j++){
				System.out.print(tabla[i][j]+ " ");
			}
			System.out.println("");
		}
		System.out.println("");

	}
	public static int[][] SumaMatrices (int tabla1[][], int tabla2[][], int sumamatrices[][]){

		for (int i=0;i<sumamatrices.length;i++){
			for (int j=0;j<sumamatrices[0].length;j++){
				sumamatrices[i][j]=tabla1[i][j]+tabla2[i][j];
			}
			System.out.println("");
		}
		return sumamatrices;
	}

}

public class EncuestaApp {

	public static void main(String[] args) {

		final int ENCUESTADOS=10;

		//Creamos la tabla de la Encuesta, no importa si es de 3x20 o 20x3
		int lista[][]=new int [3][ENCUESTADOS];

		//Rellenamos la tabla
		rellenoSexo(lista);
		rellenoTrabajo(lista);
		rellenoSueldo(lista);

		//Mostramos la tabla, es opcional mostrarla
		imprimirArray(lista);

		//Mostramos los datos
		System.out.println("Hay un "+porcHombresMujeres(lista, 1)+" % de hombres");
		System.out.println("Hay un "+porcHombresMujeres(lista, 2)+" % de mujeres");

		System.out.println("Hay un "+porcHombresMujeresTrabajo(lista, 1, 1)+" % de hombres que trabajan");
		System.out.println("Hay un "+porcHombresMujeresTrabajo(lista, 2, 1)+" % de mujeres que trabajan");

		System.out.println("Hay un "+porcHombresMujeresTrabajo(lista, 1, 2)+" % de hombres que no tiene trabajo");
		System.out.println("Hay un "+porcHombresMujeresTrabajo(lista, 2, 2)+" % de mujeres que no tiene trabajo");

		System.out.println("El sueldo medio es de "+promedioSueldo(lista, 1, 1));
		System.out.println("El sueldo medio es de "+promedioSueldo(lista, 2, 1));

	}
	public static void rellenoSexo (int lista[][]){
		for (int i=0;i<lista[0].length;i++){
			int numero=(int)Math.floor(Math.random()*2+1);
			lista[0][i]=numero;
		}
	}
	public static void rellenoTrabajo (int lista[][]){
		for (int i=0;i<lista[1].length;i++){
			int numero=(int)Math.floor(Math.random()*2+1);
			lista[1][i]=numero;
		}
	}
	public static void rellenoSueldo (int lista[][]){
		for (int i=0;i<lista[1].length;i++){
			for (int j=0;j<lista[2].length;j++){
				if (lista[1][j]==2){
					lista[2][j]=0;
				}else{
					int numero=(int)Math.floor(Math.random()*1000+500);
					lista[2][j]=numero;
				}
			}

		}
	}

	public static void imprimirArray (int lista[][]){
		//Esto solo es cuestion de estetica
		String datoEncuesta[]={"Sexo", "Trabajo", "Sueldo"};
		for (int i=0;i<lista.length;i++){
			System.out.println(datoEncuesta[i]);
			for (int j=0;j<lista[i].length;j++){
				System.out.println("En la fila " +i+" y columna " +j+ " tiene " +lista[i][j]);
			}

		}
	}
	public static double porcHombresMujeres (int lista[][], int sexo){
		int contador=0;
		for(int i=0;i<lista[0].length;i++){
			if (lista[0][i]==sexo){
				contador+=1;
			}
		}
		double porcentaje=(contador*100)/lista[0].length;
		return porcentaje;
	}
	public static double porcHombresMujeresTrabajo (int lista[][], int sexo, int trabajo){
		int contador=0;
		double porcentaje_sexo=0;
		double porcentaje=0;
		for(int i=0;i<lista[0].length;i++){
				if (lista[0][i]==sexo && lista[1][i]==trabajo){
					contador+=1;
				}
		}
		if(sexo==1){
			porcentaje_sexo=porcHombresMujeres(lista, 1);
			porcentaje=(contador*100)/(porcentaje_sexo/10);
		}else{
			porcentaje_sexo=porcHombresMujeres(lista, 2);
			porcentaje=(contador*100)/(porcentaje_sexo/10);
		}

		return porcentaje;
	}
	public static double promedioSueldo(int lista[][], int sexo, int trabajo){
		int contador=0;
		double suma=0;
		double promedio=0;
		for(int i=0;i<lista[0].length;i++){
				if (lista[0][i]==sexo && lista[1][i]==trabajo && lista[2][i]!=0){
					suma+=lista[2][i];
					contador+=1;
				}
		}
		promedio=suma/contador;
		return promedio;
	}

}