Crear un matriz de 5 x 5
Llenar la matriz con números aleatorios.

Para obtener un número aleatorio en Java podemos hacer uso de la siguiente sentencia.
int numero = (int)(Math.random() * 100);

A partir de la matriz anteriormente creada.

Mostrar en consola el promedio de la matriz.
Mostrar en consola el número mayor y la cantidad de veces que este se repite.
Mostrar en consola todos los números primos.
Mostrar en consola todos los números pares.
Mostrar en consola la suma de las diagonales
Mostrar en consola la suma de la la última fila.
Mostrar en consola el mensaje "Cuadrado Mágico" si la matriz cataloga como un cuadrado mágico.

Módulo 1 | 12 clases

Introducción

Módulo 2 | 7 clases

Tipos de datos

Módulo 3 | 5 clases

Operadores

Módulo 4 | 7 clases

Strings

Módulo 5 | 15 clases

Ciclos y condicionales

Módulo 6 | 11 clases

Arreglos

Clase 1

Arreglos

Clase 2

Definir arreglos

Clase 3

Recorrer arreglos

Clase 4

Strings como Cadenas Java

Clase 5

Foreach

Clase 6

Insertar registros

Clase 7

Arreglos Bidimencionales

Clase 8

Recorrer matrices

Clase 9

Arreglos multidimensionales

Clase 10

Ejercicios Arreglos Java

Clase 11

Ejercicios Matriz Java

Módulo 7 | 21 clases

Clases y Objetos

Módulo 8 | 4 clases

Interfaces

Módulo 9 | 7 clases

Paquetes y APIs

Módulo 10 | 4 clases

Entrada de datos

Módulo 11.-
Examen del curso
- Examen
  
  Examen final del curso

11 comentario(s)

Imanol Valenzuela Eguez

24 Octubre 23

Hola! les comparto los ejercicios resueltos. Cualquier consulta , contactenme!
https://github.com/ImaaValenzuela/ProgramacionJavaCF/tree/main/src/codigofacilito/java/desarrollojava/arreglos/ejercicios

Edgar Vazquez

07 Octubre 21

Buen dia, Aqui dejo el ejercicio como anteriores ocasiones lo he subido a un repo de Github

github.com:/bytesx/EjerciciosMatrizJava.git

Tarde unos dias en terminarlo , ya que trate de terminarlo por mi cuenta , espero cumpla lo esperado

Reagards

Alex Cruz

05 Octubre 21

public class matriz {
public static void main (String[] args) {
int [][] miMatriz = new int [5] [5];
int acumulador = 0;
double promedio = 0.0;

for (int i=0; i< 5;i++) {
for (int o=0; o< 5;o++) {
int nRandom = (int)(Math.random() * 100);
miMatriz[i][o] = nRandom;
}
}

int nMayor = miMatriz[0][0];

for (int i=0; i<5;i++) {
for (int j=0; j< 5;j++) {
if(miMatriz[i][j] > nMayor) {
nMayor = miMatriz[i][j];
}

}
}

for (int i=0; i<miMatriz.length;i++) {
for (int k=0; k<miMatriz[i].length;k++) {

if (miMatriz[i][k] == nMayor) {
acumulador++;
}

if (miMatriz[i][k] % 2 == 0) {
System.out.println(miMatriz[i][k]+" par");
} else {
System.out.println(miMatriz[i][k]+" primo");
}
promedio+=miMatriz[i][k];
}
}

int suma = 0, x = 0, y = 0;

while (x < miMatriz.length && y < miMatriz[0].length) {
suma += miMatriz[y][x];
y++;
x++;
}

int sumaFinal = 0;
for (int i=0; i < 5; i++) {
sumaFinal+=miMatriz[4][i];
}

double resultaPromedio = promedio / 25;

System.out.println("El promedio de la Matriz es: "+resultaPromedio);
System.out.println("El numero mayor de la Matriz es: "+nMayor+" y se repite: "+acumulador+" veces");
System.out.println("La suma diagonal de la Matriz es: "+suma);
System.out.println("La suma de los numero de la ultima fila es de: "+ sumaFinal);
}

Jaison Juárez Vargas

11 Enero 21

Aquí mi solución, humildemente:

package pack9;

public class EjerciciosMatriz {

public static void main(String[] args) {
// TODO Auto-generated method stub
//1. Crear un matriz de 5 x 5
int x[][] = new int[5][5];

/*x[0][0], x[0][1], x[0][2], x[0][3], x[0][4]
x[1][0], x[1][1], x[1][2], x[1][3], x[1][4]
x[2][0], x[2][1], x[2][2], x[2][3], x[2][4]
x[3][0], x[3][1], x[3][2], x[3][3], x[3][4]
x[4][0], x[4][1], x[4][2], x[4][3], x[4][4]*/

//2. Llenar la matriz con números aleatorios.
//Para obtener un número aleatorio en Java podemos hacer uso de la siguiente sentencia.
//int numero = (int)(Math.random() * 100);
int suma = 0, totmatriz = 0;
for(int i=0;i<x.length;i++) {
for(int j=0;j<x.length;j++) {
x[i][j]=(int)(Math.random()*100);
suma += x[i][j];
totmatriz +=1;
System.out.println("En el punto matriz: X["+i+"]["+j+"] = " + x[i][j]);
}
}

//3. Mostrar en consola el promedio de la matriz.
System.out.println("El promedio de la matriz es: "+(double)suma/totmatriz);

//4. Mostrar en consola el número mayor y la cantidad de veces que este se repite.
int ante = 0, mayor = 0, contaM = 1;
for(int j=0;j<x.length;j++) {
for(int k=0;k<x.length;k++) {
if ((j == 1) && (k == 1))
ante = x[j-1][k-1];

if (ante > x[j][k] )
mayor = ante;
else
ante = x[j][k];

//System.out.println("Se evalúa: " + x[j][k] + " y " + ante + " y " + mayor);
if((mayor == x[j][k]) && (ante == x[j][k])) {
if( mayor != ante )
contaM--;
contaM++;
}
}
}
System.out.println("El número mayor de la matriz es: " + mayor);
System.out.println("El número mayor de la matriz se repite: " + contaM + " vez(ces).");

//5. Mostrar en consola todos los números primos.
int conta = 0, numP = 0;

//RECORRIDO DE LA LONGITUD DEL ARREGLO MATRICIAL
for(int l=0;l<x.length;l++) {
int primo = 0;
for(int m=0;m<x[l].length;m++) {
for(int n=1;n<=x[m][l];n++) {
//System.out.println("se evalua: " + x[m][l]);
conta = x[m][l]%n;

if(conta == 0) {
primo++;
numP = x[m][l];
}
}
if (primo == 2)
System.out.println("El número actual del arreglo es primo: " + numP);
numP=0;
}
}

//6. Mostrar en consola todos los números pares.
for(int o=0;o<x.length;o++) {
for(int p=0;p<x[o].length;p++) {
if(x[p][o] % 2 == 0)
System.out.println("El número actual del arreglo: " + x[p][o] + " es PAR.");
}
}

//7. Mostrar en consola la suma de las diagonales
int sumaDI=0, sumaDD = 0;
for(int q=0;q<x.length;q++) {
for(int r=0;r<x[q].length;r++) {
//EVALUAMOS LA DIAGONAL DE LOS NUMEROS IGUALES
if(q==r)
sumaDI+=x[q][r];

if((q+r) == 4)
sumaDD+=x[q][r];

//System.out.println("Se evalua el número de X diagonal: " + x[q][r]);
}
}
System.out.println("La suma de la diagonal con indices iguales es: " + sumaDI);
System.out.println("La suma de la otra diagonal es: " + sumaDD);

//8. Mostrar en consola la suma de la la última fila.
int sumU = 0;
for(int s=0;s<x.length;s++) {
for(int t=0;t<x[s].length;t++) {
//EVALUAMOS LA DIAGONAL DE LOS NUMEROS IGUALES
if(s == 4)
sumU+=x[s][t];
}
}
System.out.println("La suma de la última fila es: " + sumU);

//9. Mostrar en consola el mensaje "Cuadrado Mágico" si la matriz cataloga como un cuadrado mágico.
int sumC1 = 0, sumC2 = 0, sumC3 = 0, sumC4 = 0, sumC5 = 0, columnas = 0;
int sumF1 = 0, sumF2 = 0, sumF3 = 0, sumF4 = 0, sumF5 = 0, filas = 0;
for(int u=0;u<x.length;u++) {
for(int v=0;v<x[u].length;v++) {
//EVALUAMOS LAS COLUMNAS
if(v == 0)
sumC1+=x[u][v];
if(v == 1)
sumC2+=x[u][v];
if(v == 2)
sumC3+=x[u][v];
if(v == 3)
sumC4+=x[u][v];
if(v == 4)
sumC5+=x[u][v];
if (sumC1==sumC2) {
if(sumC2==sumC3) {
if(sumC3==sumC4) {
if(sumC4==sumC5)
columnas=sumC1;
}
}
}
else
columnas = 0;

//EVALUAMOS LAS COLUMNAS
if(u == 0)
sumF1+=x[u][v];
if(u == 1)
sumF2+=x[u][v];
if(u == 2)
sumF3+=x[u][v];
if(u == 3)
sumF4+=x[u][v];
if(u == 4)
sumF5+=x[u][v];
if (sumF1==sumF2) {
if(sumF2==sumF3) {
if(sumF3==sumF4) {
if(sumF4==sumF5)
filas=sumF1;
}
}
}
else
filas = 1;
}
}
if (filas == columnas)
System.out.println("Cuadrado Mágico");
else
System.out.println("No existe cuadrado mágico");

int y[][] = new int[3][3];
y[0][0] = 1; y[0][1] = 3; y[0][2] = 6;
y[1][0] = 7; y[1][1] = 1; y[1][2] = 2;
y[2][0] = 2; y[2][1] = 6; y[2][2] = 2;

int sCY1 = 0, sCY2 = 0, sCY3 = 0, colY = 0, sFY1 = 0, sFY2 = 0, sFY3 = 0, filY = 0;
for(int w=0;w<y.length;w++) {
for(int z=0;z<y[w].length;z++) {
//EVALUAMOS LAS COLUMNAS
if(w == 0)
sCY1+=y[w][z];
if(w == 1)
sCY2+=y[w][z];
if(w == 2)
sCY3+=y[w][z];
if (sCY1==sCY2) {
if(sCY2==sCY3)
colY=sCY1;
}
else
colY = 0;

//EVALUAMOS LAS FILAS
if(z == 0)
sFY1+=y[w][z];
if(z == 1)
sFY2+=y[w][z];
if(z == 2)
sFY3+=y[w][z];
if (sFY1==sFY2) {
if(sFY2==sFY3)
filY=sFY1;
}
else
filY = 1;
}
}
if (filY == colY)
System.out.println("Cuadrado Mágico");
else
System.out.println("No existe cuadrado mágico");

}

}

@lesthermanuel6

29 Julio 20

package main;

public class EjerciciosMatrices {
public static void main(String[] args) {
// CÓDIGO
int matriz[][] = new int[5][5];
for(int i=0;i<matriz.length;i++) {
for(int j=0;j<matriz[i].length;j++) {
matriz[i][j] = (int)(Math.random()*15+1);
}
}

//MOSTRAR EN CONSOLA EL PROMEDIO DE LA MATRIZ
System.out.println("MATRIZ -> ");
int suma=0, promedio=0, nTotalDeDatos=0,mayor=0, veces_mayor=0, aux=0;
for(int fila[]:matriz) {
for(int dato:fila) {
System.out.print(dato + " ");
suma +=dato;
nTotalDeDatos++;
if(dato==mayor){veces_mayor++;}
if(dato>mayor) {mayor=dato; aux=mayor;veces_mayor=1;}
}
System.out.println();
}
promedio = (suma/nTotalDeDatos);
System.out.println("PROMEDIO -> " + (double)promedio);
System.out.println("MAYOR -> " + aux + " Y APARECE " + veces_mayor + " VECES");

int divisibles=0, n_numero=0, sum_diagonal=0, suma_ultima_fila=0;
String primos = " ", pares = " ";

for(int i=0; i<matriz.length;i++) {
divisibles=0;
sum_diagonal += matriz[i][i];
for(int j=0;j<matriz[i].length;j++) {
n_numero = matriz[i][j];
for(int k=1;k<=n_numero;k++) {if((n_numero%k)==0)divisibles++;}
if((divisibles==2)||(n_numero==2)) {primos = primos + (n_numero + " ");}
if((n_numero%2)==0) {pares += (n_numero + " ");}
}
suma_ultima_fila += matriz[4][i];
}

System.out.println("ALGUNOS PRIMOS -> " + primos); //NO SÉ, ME RENDÍ XD
System.out.println("LOS PARES -> " + pares);
System.out.println("DIAGONAL -> "+ sum_diagonal);
System.out.println("ULTIMA FILA -> "+ suma_ultima_fila);

}
}

@noeadrianleal

20 Junio 20

package main;

public class matriz {

public static void main(String[] args) {
// TODO Auto-generated method stub

int matriz[][]= new int[5][5];

for(int i=0;i<matriz.length;i++) {
for(int j=0; j<matriz.length;j++) {
matriz[i][j]=(int)(Math.random() * 100);
System.out.println(matriz[i][j]);

}

}
System.out.println("______________________________________");
int sum=0;
for(int y=0; y<matriz.length;y++) {
for(int x=0; x<matriz[y].length;x++) {
sum+=matriz[y][x];
}

}System.out.println("la pinche suma es " +sum);
int promedio = sum/25;
System.out.println("el pinche promedio es " + promedio);

System.out.println("---------------------------------------");

int mayor=0;
int repetido=0;
for(int x=0; x<matriz.length;x++) {
for(int y=0; y<matriz[x].length; y++) {
if(mayor<matriz[x][y]) {
mayor=matriz[x][y];

}
}
}System.out.println(mayor);
for(int posicion[]:matriz) {
for (int num :posicion) {
if(mayor==num) {repetido++;}
}
}System.out.println("el numero se repite" + repetido+
"veces");
System.out.println("-----------------------------------------");
int y=0;
int x;
boolean isPrime;
for( x=0;x<matriz.length;x++) {
for( y=0;y<matriz[x].length;y++) {
if(matriz[x][y]%2==0) {System.out.println(matriz[x][y]+ " es par" );}

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

for(int w=2;w<matriz[i][j]/2;w++) {
if(matriz[i][j]%w==0) {
primo=false;
break; }
}
if(primo) { System.out.println(matriz[i][j]+ " this is prime"); }
}
}

Gabriel Servia

21 Abril 20

El ejercicio de los numeros primos esta complicado. Nadie lo pudo resolver? Profesor?

Ver respuestas (1)

Jorge Alejandro Quiroga Cruz

02 Octubre 19

package curso;

public class Ejercicios3 {
    public static void main(String[] args) {
        
        int numeros[][] = new int[5][5];        
        int numerosPrimos [] = new int [25],numerosPares[]= new int [25],numerosUltimaFila[]=new int [5];
        int aleatorio = 0, valorMaximo = 0,valorMinimo = 0,contadorValorMaximo = 0,contadorValorMinimo= 0;
        int diagonal1 = 0, diagonal2 = 0,fila1 = 0,fila2 = 0,fila3 = 0,fila4 = 0,fila5 = 0;
        int columna1 = 0,columna2 = 0,columna3 = 0,columna4 = 0,columna5 = 0;
        int contador = 0,contadorNumerosprimos = 0,contadorNumerosPar = 0,sumaUltimaFila = 0;
        float promedio = 0.00f,aleatorios = 0;
        
        // Para probar el cuadrado magico
        /*numeros[0][0] = 17; 
        numeros[0][1] = 24; 
        numeros[0][2] = 1; 
        numeros[0][3] = 8; 
        numeros[0][4] = 15; 
        
        numeros[1][0] = 23; 
        numeros[1][1] = 5; 
        numeros[1][2] = 7; 
        numeros[1][3] = 14; 
        numeros[1][4] = 16; 
        
        numeros[2][0] = 4; 
        numeros[2][1] = 6; 
        numeros[2][2] = 13; 
        numeros[2][3] = 20; 
        numeros[2][4] = 22; 
        
        numeros[3][0] = 10; 
        numeros[3][1] = 12; 
        numeros[3][2] = 19; 
        numeros[3][3] = 21; 
        numeros[3][4] = 3; 
        
        numeros[4][0] = 11; 
        numeros[4][1] = 18; 
        numeros[4][2] = 25; 
        numeros[4][3] = 2; 
        numeros[4][4] = 9;*/ 
        
        for(int i = 0; i < numeros.length; i++){
            sumaUltimaFila = 0;
            for(int j = 0; j < numeros[i].length; j++ ){
                aleatorio = (int)(Math.random()* 100);
                // Para probar el cuadrado magico
                //aleatorio = numeros[i][j];
                numeros[i][j] = aleatorio;
                
                numerosUltimaFila[j] = numeros[i][j]; 
                sumaUltimaFila = sumaUltimaFila + aleatorio;
                
                // Suma diagonales
                // Diagonal 1
                if(i==0 && j ==0){
                    diagonal1 = diagonal1 + aleatorio;
                }else if(i==1 && j ==1){
                    diagonal1 = diagonal1 + aleatorio;
                }else if(i==2 && j ==2){
                    diagonal1 = diagonal1 + aleatorio;
                }else if(i==3 && j ==3){
                    diagonal1 = diagonal1 + aleatorio;
                }else if(i==4 && j ==4){
                    diagonal1 = diagonal1 + aleatorio;
                }
                
                // Diagonal 2
                if(i==0 && j ==4){
                    diagonal2 = diagonal2 + aleatorio;
                }else if(i==1 && j ==3){
                    diagonal2 = diagonal2 + aleatorio;
                }else if(i==2 && j ==2){
                    diagonal2 = diagonal2 + aleatorio;
                }else if(i==3 && j ==1){
                    diagonal2 = diagonal2 + aleatorio;
                }else if(i==4 && j ==0){
                    diagonal2 = diagonal2 + aleatorio;
                }
                
                // Suma Filas
                if(i==0 && j ==0){
                    fila1 = fila1 + aleatorio;
                }else if(i==0 && j ==1){
                    fila1 = fila1 + aleatorio;
                }else if(i==0 && j ==2){
                    fila1 = fila1 + aleatorio;
                }else if(i==0 && j ==3){
                    fila1 = fila1 + aleatorio;
                }else if(i==0 && j ==4){
                    fila1 = fila1 + aleatorio;
                }
                
                if(i==1 && j ==0){
                    fila2 = fila2 + aleatorio;
                }else if(i==1 && j ==1){
                    fila2 = fila2 + aleatorio;
                }else if(i==1 && j ==2){
                    fila2 = fila2 + aleatorio;
                }else if(i==1 && j ==3){
                    fila2 = fila2 + aleatorio;
                }else if(i==1 && j ==4){
                    fila2 = fila2 + aleatorio;
                }
                
                if(i==2 && j ==0){
                    fila3 = fila3 + aleatorio;
                }else if(i==2 && j ==1){
                    fila3 = fila3 + aleatorio;
                }else if(i==2 && j ==2){
                    fila3 = fila3 + aleatorio;
                }else if(i==2 && j ==3){
                    fila3 = fila3 + aleatorio;
                }else if(i==2 && j ==4){
                    fila3 = fila3 + aleatorio;
                }
                
                if(i==3 && j ==0){
                    fila4 = fila4 + aleatorio;
                }else if(i==3 && j ==1){
                    fila4 = fila4 + aleatorio;
                }else if(i==3 && j ==2){
                    fila4 = fila4 + aleatorio;
                }else if(i==3 && j ==3){
                    fila4 = fila4 + aleatorio;
                }else if(i==3 && j ==4){
                    fila4 = fila4 + aleatorio;
                }
                
                if(i==4 && j ==0){
                    fila5 = fila5 + aleatorio;
                }else if(i==4 && j ==1){
                    fila5 = fila5 + aleatorio;
                }else if(i==4 && j ==2){
                    fila5 = fila5 + aleatorio;
                }else if(i==4 && j ==3){
                    fila5 = fila5 + aleatorio;
                }else if(i==4 && j ==4){
                    fila5 = fila5 + aleatorio;
                }
                
                // Suma Columnas
                if(i==0 && j ==0){
                    columna1 = columna1 + aleatorio;
                }else if(i==1 && j ==0){
                    columna1 = columna1 + aleatorio;
                }else if(i==2 && j ==0){
                    columna1 = columna1 + aleatorio;
                }else if(i==3 && j ==0){
                    columna1 = columna1 + aleatorio;
                }else if(i==4 && j ==0){
                    columna1 = columna1 + aleatorio;
                }
                
                if(i==0 && j ==1){
                    columna2 = columna2 + aleatorio;
                }else if(i==1 && j ==1){
                    columna2 = columna2 + aleatorio;
                }else if(i==2 && j ==1){
                    columna2 = columna2 + aleatorio;
                }else if(i==3 && j ==1){
                    columna2 = columna2 + aleatorio;
                }else if(i==4 && j ==1){
                    columna2 = columna2 + aleatorio;
                }
                
                if(i==0 && j ==2){
                    columna3 = columna3 + aleatorio;
                }else if(i==1 && j ==2){
                    columna3 = columna3 + aleatorio;
                }else if(i==2 && j ==2){
                    columna3 = columna3 + aleatorio;
                }else if(i==3 && j ==2){
                    columna3 = columna3 + aleatorio;
                }else if(i==4 && j ==2){
                    columna3 = columna3 + aleatorio;
                }
                
                if(i==0 && j ==3){
                    columna4 = columna4 + aleatorio;
                }else if(i==1 && j ==3){
                    columna4 = columna4 + aleatorio;
                }else if(i==2 && j ==3){
                    columna4 = columna4 + aleatorio;
                }else if(i==3 && j ==3){
                    columna4 = columna4 + aleatorio;
                }else if(i==4 && j ==3){
                    columna4 = columna4 + aleatorio;
                }
                
                if(i==0 && j ==4){
                    columna5 = columna5 + aleatorio;
                }else if(i==1 && j ==4){
                    columna5 = columna5 + aleatorio;
                }else if(i==2 && j ==4){
                    columna5 = columna5 + aleatorio;
                }else if(i==3 && j ==4){
                    columna5 = columna5 + aleatorio;
                }else if(i==4 && j ==4){
                    columna5 = columna5 + aleatorio;
                }
                
                // Calcula valor maximo
                if (aleatorio > valorMaximo){
                    valorMaximo = aleatorio;
                }
                
                // Calcula valor minimo
                if (i == 0){
                    valorMinimo = aleatorio;
                }
                
                if (aleatorio < valorMinimo){
                    valorMinimo = aleatorio;
                }
                
                if(aleatorio!=0){
                    // Calcula si es un número primo
                    contador = 0;
                    for(int x = 1; x <= aleatorio; x++){
                        if((aleatorio % x) == 0){
                            contador++;                     
                        }               
                    }
                    
                    if(contador <= 2){
                        numerosPrimos [contadorNumerosprimos] = aleatorio;
                        contadorNumerosprimos++;
                    }
                    
                    // Calcula si en número PAR
                    if((aleatorio % 2) == 0){                       
                        // Número PAR
                        numerosPares[contadorNumerosPar] = aleatorio;
                        contadorNumerosPar++;
                    }                                   
                } 
                
                // Calcula promedio             
                aleatorios = aleatorios + aleatorio;
            }
        }
        
        // Lee los numeros 
        System.out.println("");
        System.out.println("---------------------------");
        System.out.println("-----------Numeros---------");
        System.out.println("---------------------------");
        
        for(int numerofilas[]: numeros){
            for(int numetoscolumna : numerofilas){
                
                if(numetoscolumna == valorMaximo){
                    contadorValorMaximo++;
                }
                
                if(numetoscolumna == valorMinimo){
                    contadorValorMinimo++;
                }
                
                System.out.print(numetoscolumna + " ");             
            }
            System.out.println("");
        }
        
        System.out.println("Numero mayor: "+ valorMaximo + " Repeticiones: " + contadorValorMaximo);
        System.out.println("Numero menor: "+ valorMinimo + " Repeticiones: " + contadorValorMinimo);
        
        //Genera promedio
        System.out.println("");
        System.out.println("---------------------------");
        System.out.println("----------Promedio---------");
        System.out.println("---------------------------");      
        promedio = aleatorios/25;
        System.out.println(promedio);   
        //System.out.println(aleatorios);
        
        // Lee los numeros primos
        System.out.println("");
        System.out.println("---------------------------");
        System.out.println("------Numeros Primos-------");
        System.out.println("---------------------------");
        
        for(int numeroPrimo: numerosPrimos){
            if (numeroPrimo!=0){
                System.out.println(numeroPrimo);
            }
        }   
        
        // Lee los numeros pares
        System.out.println("");
        System.out.println("---------------------------");
        System.out.println("------Numeros Pares--------");
        System.out.println("---------------------------");
        
        for(int numeroPar: numerosPares){
            if (numeroPar!=0){
                System.out.println(numeroPar);
            }           
        }

        // Total diagonales
        System.out.println("");
        System.out.println("---------------------------");
        System.out.println("------Suma Diagonales------");
        System.out.println("---------------------------");
        System.out.println("Suma diagonal 1 :" + diagonal1);
        System.out.println("Suma diagonal 2 :" + diagonal2);
        
        // Total ultima fila
        System.out.println("");
        System.out.println("---------------------------");
        System.out.println("------Suma última fila-----");
        System.out.println("---------------------------");
        System.out.println(sumaUltimaFila);

        // Cuadrado Magico
        
        if(fila1 == fila2 && fila1 == fila3 && fila1 == fila4 && fila1 == fila5 &&
           fila1 == columna1 && fila1 == columna2 && fila1 == columna3 && fila1 == columna4 &&
           fila1 == columna5 && fila1 == diagonal1 && fila1 == diagonal2){
            System.out.println("");
            System.out.println("---------------------------");
            System.out.println("------Cuadrado Magico------");
            System.out.println("---------------------------");
            System.out.println("Cuadrado Magico");
            
        }
        
        /*System.out.println("Suma Fila 1: " + fila1);
        System.out.println("Suma Fila 2: " + fila2);
        System.out.println("Suma Fila 3: " + fila3);
        System.out.println("Suma Fila 4: " + fila4);
        System.out.println("Suma Fila 5: " + fila5);
        System.out.println("Suma Columna 1: " + columna1);
        System.out.println("Suma Columna 2: " + columna2);
        System.out.println("Suma Columna 3: " + columna3);
        System.out.println("Suma Columna 4: " + columna4);
        System.out.println("Suma Columna 5: " + columna5);
        System.out.println("Suma Diagonal 1: " + diagonal1);
        System.out.println("Suma Diagonal 2: " + diagonal2);*/
        // completar la validacion del cuadrado magico

    }

}

@oks

01 Agosto 19

 Ejercicio casi completo me falta el de númeos primos y el de "Cuadrado mágico" no esta del todo bien estructurado.
/* PARTE I
        Crear un matriz de 5 x 5
        Llenar la matriz con números aleatorios.*/
        
        int matriz1 [][] = new int [5][5];
        int matrizFinal [][] = new int [5][5];
        
        for (int c = 0; c < matriz1.length; c++) {//primero indicas la posicion
            for( int f = 0; f < matriz1.length; f++) {//luego el valor
                int numero = (int)(Math.random() * 100);
                matriz1[c][f] = numero;
                matrizFinal[c][f]= matriz1[c][f];
                System.out.print( matriz1[c][f]+"|");
            }
            System.out.println();
        }
        
        System.out.println("***************");
                    /* PARTE II
        Mostrar en consola el promedio de la matriz..*/
        double contador = 0;
        double promedio = 0;
        
        for (int []posicion:matrizFinal) {//primero indicas la posicion
            for( int celda: posicion) {//luego el valor
                contador++;
                promedio += celda;
                System.out.print(celda +"|");
                
            }
            System.out.println();
        }
        System.out.println("El promedio es de: " + promedio / contador);
        System.out.println("***************");
        
                    /* PARTE III
        Mostrar en consola el número mayor 
        y la cantidad de veces que este se repite.*/
        
        int numeroMayor = 0;
        int numRepetido = 0;
        for (int [] posicion : matrizFinal) {
            for (int celda : posicion) {
                if (numeroMayor < celda) {
                    numeroMayor = celda;
                }
            }
        }
        // ahora cuento el número repetido ya que ya se cúal es el num Mayor
        for (int [] posicion : matrizFinal) {
            for (int celda : posicion) {
                if (numeroMayor == celda)
                    numRepetido++;
            }
        }
        System.out.println("El mayor número de la matriz es: " + numeroMayor + " Y se repite: " + numRepetido);
        System.out.println("***************");
        
                    /* PARTE IV
        Mostrar en consola todos los números primos.*/
        
        
                    /* PARTE V
        Mostrar en consola todos los números pares.*/
        
        for (int c = 0; c < matrizFinal.length; c++) {
            System.out.print("Números pares em la fila:");
            for (int f = 0; f < matrizFinal.length; f++) {
                
                if  ((matrizFinal[c][f] % 2 == 0) && (matrizFinal[c][f] != 0)) {
                    System.out.print(matrizFinal[c][f]);
                }
            }
            System.out.println();
        }
        System.out.println("***************");
        
                    /* PARTE VI
        Mostrar en consola la suma de las diagonales*/
        
        boolean cajaMagicaD = false;
        int sumaColumnas = 0;
        int memoriaD = 0;
        int sumaFilas = 0;
        for (int c = 0; c < matrizFinal.length; c++) {
            
            for (int f = 0; f < matrizFinal.length; f++) {
                if (c == f) {// patron de filas es que son las posines iguales: 0,0|1,1|2,2|3,3|4,4
                    sumaFilas += matrizFinal[c][f];
                }
                if (c+f == 4) { //patron de columanas  es que suman 4 en cualquier posición: 0,4|1,3|2,2|3,1|4,0
                    sumaColumnas += matrizFinal[c][f];
                } 
            }
        }
        
        if (sumaFilas == sumaColumnas) {
            cajaMagicaD = true;
            memoriaD = sumaColumnas;
        }
        System.out.println("Suma de diagonal de filas "+sumaFilas);
        System.out.println("Suma de diagonal de columnas "+sumaColumnas);
        System.out.println("***************"); 
        
                    /* PARTE VII
        Mostrar en consola la suma de la la última fila.*/
        // patron es ¿cúando empezar a sumar? cuándo el valor de columnas es: columnas -1;
        
        int contarColumnas = 0;
        for (int c = 0; c < matrizFinal.length; c++) {
            for (int f = 0; f < matrizFinal.length; f++) {
            }
            contarColumnas++;
        }
        //System.out.println(contarFilas); contar filas == 5
        int sumaUltimaFila = 0;
        for (int c = 0; c < matrizFinal.length; c++) {
            for (int f = 0; f < matrizFinal.length; f++) {
                if (c == (contarColumnas-1)) {
                    sumaUltimaFila += matrizFinal[c][f]; 
                }
            }
            
        }
        System.out.println("Última fila suma: " + sumaUltimaFila);
        System.out.println("***************"); 
        
                    /* PARTE VIII
        Mostrar en consola el mensaje "Cuadrado Mágico"
         si la matriz cataloga como un cuadrado mágico.*/
        int sumFila = 0;
        int sumColum = 0;
        int memoriaF = 0;
        int memoriaC = 0;
        
        boolean cajaMagicaF = false;
        boolean cajaMagicaC = false;
        
        //sumo filas
        for (int c = 0; c < matrizFinal.length; c++) {
            memoriaF = sumFila;
            sumFila = 0;
            for (int f = 0; f < matrizFinal.length; f++) {
                sumFila +=  matrizFinal[c][f];
                System.out.print(matrizFinal[c][f]+"|");
            }
            System.out.print("="+sumFila);
             if (memoriaF == sumFila) {
                 cajaMagicaF = true;
             }
            System.out.println();
        }
        
        System.out.println("***************");
        //sumo columnas
        for (int f = 0; f < matrizFinal.length; f++) {
            memoriaC = sumColum;
            sumColum = 0;
            for (int c = 0; c < matrizFinal.length; c++) {
                sumColum +=  matrizFinal[c][f];
                System.out.print(matrizFinal[c][f]+"|");
            }
            System.out.print("="+sumColum);
            if (memoriaC == sumColum) {
                 cajaMagicaC = true;
             }
            System.out.println();
        }
        if((memoriaD == memoriaC)&&(memoriaF == memoriaC)&&(memoriaD == memoriaF)) {
            if ((cajaMagicaC == true) && (cajaMagicaF == true) && (cajaMagicaD == true) ) {
                System.out.println("Cuadrado Mágico");
            }
        }
        // última suma de columna.
        System.out.println(memoriaC+";"+memoriaF + ";"+ memoriaD);
        /*Es imposible que salga cuadrado magico. Lo he provado reduciendo el random 
         * y no funcciona, solo si lleno la matriz de 0 (reduciendo el random a 1)*/

Ver respuestas (3)

Alex Gregory Arcentales Bailon

28 Marzo 19

package main;

public class ejerciciosMatrizesJava {

    public static void main(String[] args) {
        //Crear un matriz de 5 x 5
        int matriz [][]= new int [5][5];
        //Llenar la matriz con números aleatorios.
        System.out.println("Los numeros aleatorios son:  ");
        for(int matrizes=0; matrizes<matriz.length;matrizes++) {
            for (int ma=0 ;ma<matriz[matrizes].length ;ma++) {
            matriz[matrizes][ma] = (int)(Math.random() * 100+1);
            }
        }
        for (int x[]:matriz) {
            
            for(int y: x) {
                System.out.print(y+" ");
            }
            System.out.println(" ");
        }
        //Mostrar en consola el promedio de la matriz.
        int suma=0, con=0, promedio=0;
        for(int contador=0; contador<matriz.length;contador++) {
            for (int contador2=0 ;contador2<matriz[contador].length ;contador2++) {
            suma+=matriz[contador][contador2];
            con++;
            }
        }
        promedio=suma/con;
        System.out.println("El promedio de la matriz es: "+promedio);
        //Mostrar en consola todos los números primos.
        System.out.print("Los numeros primos de la matriz son: ");
        for (int x[]:matriz) {
            for(int y: x) {
                int aux=0;
                    for(int i=1;i<=y;i++) {
                        if(y%i==0)
                        aux++;
                    }
                    if(aux==2)
                    System.out.print(y+",");
            }
        }
        System.out.println(" ");
        //Mostrar en consola el número mayor y la cantidad de veces que este se repite.
        System.out.print("El numero mayor es: ");
        int numayor=0, con2=0;
        for (int x[]:matriz) {
            for(int y: x) {
                if(y>numayor) {
                    numayor=y;
                    con2=0;
                }
                if(y==numayor)          
                    con2++;
                //System.out.print(y+" ");
            }
            
        }
        System.out.println(numayor+" "+"y se repite "+con2+ " veces.");
        //Mostrar en consola todos los números pares.
        System.out.print("Los numeros pares son: ");
        for (int x[]:matriz) {
            for(int y: x) {
                    if(y%2==0)
                    System.out.print(y+",");
            }
        }
        //Mostrar en consola la suma de las diagonales
        //diagonal izq a der
        int su=0, tot=0;
        for(int contador=0; contador<matriz.length;contador++) {
            int f=0;
            for (int contador2=0 ;contador2<matriz[contador].length ;contador2++) {
            su=matriz[contador][contador2];
            if(f==contador)
                break;
            else f++;
            }
            tot+=su;
        }
        //diagonal der a izq
        for(int contador=0; contador<matriz.length;contador++) {
            for (int contador2=0 ;contador2<matriz[contador].length-contador;contador2++) {
            su=matriz[contador][contador2];
            }
            tot+=su;
        }
        System.out.print("\nLas suma de las diagonales es: "+tot);
        //Mostrar en consola la suma de la la última fila.
        System.out.println(); int suma2=0;
        for (int x[]:matriz) {
            int j=0;
            for(int y: x) {
                j=y;
            }
            suma2+=j;
        }
        System.out.println("La suma total de la ultima fila es: "+suma2);
        //Mostrar en consola el mensaje "Cuadrado Mágico" si la matriz cataloga como un cuadrado mágico.
    
            
    }
}

Ver respuestas (2)

Ejercicios Matriz Java

Curso Profesional de JAVA