EJERCICIOS RESUELTOS (MATRICES CON MTODOS EN JAVA)

Dadas dos matrices A y B intercambiar los minimos de A con los maximos de B

import java.util.Scanner;
public class JavaMatrizMetod1 {

Scanner Leer = new Scanner(System.in);

public static void llenar (int M [] [], int f, int c)

{
Scanner Leer = new Scanner(System.in);
for (int i = 1 ; i <= f ; i++)
{
for (int j = 1 ; j <= c ; j++)
{
System.out.print ("Inserte pos[" + i + "][" + j + "]: ");
M [i] [j] = Leer.nextInt();
}
}
}
public static void mostrar (int M [] [], int f, int c)
{
for (int i = 1 ; i <= f ; i++)
{
System.out.println ();
for (int j = 1 ; j <= c ; j++)
{
System.out.print ("[" + M [i] [j] + "]");
}
}
}
public static int menor (int M [] [], int f, int c)
{
int men = M [1] [1];
for (int i = 1 ; i <= f ; i++)
{
for (int j = 1 ; j <= c ; j++)
{
if (M [i] [j] < men)
men = M [i] [j];
}
}
return (men);
}
public static int maximo (int M [] [], int f, int c)
{
int max = M [1] [1];
for (int i = 1 ; i <= f ; i++)
{
for (int j = 1 ; j <= c ; j++)
{
if (M [i] [j] < max)
max = M [i] [j];
}
}
return (max);
}
public static void intercambiar (int A [] [], int fa, int ca, int B [] [], int fb, int cb)
{
int min_a = menor (A, fa, ca);
int max_b = maximo (B, fb, cb);
//para cambiar los minimos de A con los maximos de B
for (int i = 1 ; i <= fa ; i++)
{
for (int j = 1 ; j <= ca ; j++)
{
if (A [i] [j] == min_a)
A [i] [j] = max_b;
}
}
//para intercambiar los maximos de con los minimos de A
for (int i = 1 ; i <= fb ; i++)
{
for (int j = 1 ; j <= cb ; j++)
{
if (B [i] [j] == max_b)
B [i] [j] = min_a;
}
}
}
public static void main (String args [])
{
Scanner Leer = new Scanner(System.in);
 int A [] [] = new int [20] [20];
int B [] [] = new int [20] [20];
System.out.print ("Insert filas de A: ");
int fa = Leer.nextInt();
System.out.print ("Insert columnas de A: ");
int ca = Leer.nextInt();
System.out.print ("Insert filas de B: ");
int fb = Leer.nextInt();
System.out.print ("Insert columnas de B: ");
int cb = Leer.nextInt();
//lectura de matrices
System.out.println ("nINSERTANDO DATOS EN MATRIZ A: n");
llenar (A, fa, ca);
System.out.println ("nINSERTANDO DATOS EN MATRIZ B: n");
llenar (B, fb, cb);
System.out.println ("nMATRICES ORIGINALMENTE INSERTADAS: ");
mostrar (A, fa, ca);
System.out.println ();
mostrar (B, fb, cb);
System.out.println ();
//intercambiando elementos
intercambiar (A, fa, ca, B, fb, cb);
System.out.println ("nMATRICES DESPUES DEL INTERCAMBIO:");
mostrar (A, fa, ca);
System.out.println ();
mostrar (B, fb, cb);
}
}

Dada una matriz cuadrada invertir su diagonal principal

import java.util.Scanner;
public class JavaMatrizMetod2 {

public static void llenar (int M [] [], int d)

{
Scanner Leer = new Scanner(System.in);
for (int i = 1 ; i <= d ; i++)
{
for (int j = 1 ; j <= d ; j++)
 {
System.out.print("Inserte pos[" + i + "][" + j + "]: ");
M [i] [j] = Leer.nextInt();
}
}
}
public static void mostrar (int M [] [], int d)
{
for (int i = 1 ; i <= d ; i++)
{
System.out.println ();
for (int j = 1 ; j <= d ; j++)
{
System.out.print("[" + M [i] [j] + "]");
}
}
}
public static void invierte (int M [] [], int d)
{
int fin = d;
for (int i = 1 ; i <= d / 2 ; i++)
{
int aux = M [i] [i];
M [i] [i] = M [d] [d];
M [d] [d] = aux;
fin--;
}
}
public static void main (String args [])
{
Scanner Leer = new Scanner(System.in);
int M [] [] = new int [20] [20];
System.out.print("Inserte dimen. de la matriz cuadrada: ");
int d = Leer.nextInt();
llenar (M, d);
System.out.print("nMATRIZ ORIGINAL: ");
mostrar (M, d);
System.out.print("nnMATRIZ CON LA DIAGONAL PRINCIPAL INVERTIDA: ");
invierte (M, d);
mostrar (M, d);
}
}

Dada una matriz cuadrada invertir su diagonal secundaria

import java.util.Scanner;
public class JavaMatrizMetod3 {

public static void llenar (int M [] [], int d)

{
Scanner Leer = new Scanner(System.in);
for (int i = 1 ; i <= d ; i++)
{
for (int j = 1 ; j <= d ; j++)
{
System.out.print ("Inserte pos[" + i + "][" + j + "]: ");
M [i] [j] = Leer.nextInt();
}
}
}
public static void mostrar (int M [] [], int d)
{
for (int i = 1 ; i <= d ; i++)
{
System.out.println ();
for (int j = 1 ; j <= d ; j++)
{
System.out.print ("[" + M [i] [j] + "]");
}
}
}
public static void invierte (int M [] [], int d)
{
int fin = d;
for (int i = 1 ; i <= d / 2 ; i++)
{
int aux = M [i] [d];
M [i] [d] = M [d] [i];
M [d] [i] = aux;
fin--;
}
}
public static void main (String args [])
{
Scanner Leer = new Scanner(System.in);
int M [] [] = new int [20] [20];
System.out.print ("Inserte dimen. de la matriz cuadrada: ");
int d = Leer.nextInt();
llenar (M, d);
System.out.print ("nMATRIZ ORIGINAL: ");
mostrar (M, d);
System.out.print ("nnMATRIZ CON LA DIAGONAL SECUNDARIA INVERTIDA: ");
invierte (M, d);
mostrar (M, d);
}
}

Dada dos matrices de diferentes tamaos R y S mostrar los elementos comunes de R

en S

import java.util.Scanner;

public class JavaMatrizMetod4 {

public static void llenar (int M [] [], int f, int c)

{
Scanner Leer = new Scanner(System.in);
for (int i = 1 ; i <= f ; i++)
{
for (int j = 1 ; j <= c ; j++)
{
System.out.print ("Inserte pos[" + i + "][" + j + "]: ");
M [i] [j] = Leer.nextInt();
}
}
}
public static void mostrar (int M [] [], int f, int c)
{
for (int i = 1 ; i <= f ; i++)
{
System.out.println ();
for (int j = 1 ; j <= c ; j++)
{
System.out.print ("[" + M [i] [j] + "]");
}
}
}
public static void comunes (int R [] [], int fr, int cr, int S [] [], int fs,
int cs)
{
System.out.print ("nnLos elementos comunes de R en S son: ");
for (int i = 1 ; i <= fr ; i++)
{
for (int j = 1 ; j <= cr ; j++)
{
for (int k = 1 ; k <= fs ; k++)
{
for (int l = 1 ; l <= cs ; l++)
{
if (R [i] [j] == S [k] [l])
System.out.print ("[" + R [i] [j] + "]");
}
}
}
}
 }
public static void main (String args [])
{
Scanner Leer = new Scanner(System.in);
int R [] [] = new int [20] [20];
int S [] [] = new int [20] [20];
System.out.print ("Inserte filas de R: ");
int fr = Leer.nextInt();
System.out.print ("Inserte columnas de R: ");
int cr = Leer.nextInt();
System.out.print ("Inserte filas de S: ");
int fs = Leer.nextInt();
System.out.print ("Inserte columnas de S: ");
int cs = Leer.nextInt();

System.out.print ("nLLENANDO MATRIZ R: n");

llenar (R, fr, cr);
System.out.print ("nLLENANDO MATRIZ S: n");
llenar (S, fs, cs);
System.out.print ("nLA MATRICES R : ");
mostrar (R, fr, cr);
System.out.print ("nLA MATRICES S : ");
mostrar (S, fs, cs);
comunes (R, fr, cr, S, fs, cs);
}
}

Dada una matriz intercambiar los elementos de la primera columna con la ultima
columna

import java.util.Scanner;
public class JavaMatrizMetod5 {

public static void llenar (int M [] [], int f, int c)

{
Scanner Leer = new Scanner(System.in);
for (int i = 1 ; i <= f ; i++)
{
for (int j = 1 ; j <= c ; j++)
{
System.out.print ("Inserte pos[" + i + "][" + j + "]: ");
M [i] [j] = Leer.nextInt();
}
}
}
public static void mostrar (int M [] [], int f, int c)
{
for (int i = 1 ; i <= f ; i++)
{
System.out.println ();
for (int j = 1 ; j <= c ; j++)
{
System.out.print ("[" + M [i] [j] + "]");
 }
}
}
public static void intercambiar (int M [] [], int f, int c)
{
for (int i = 1 ; i <= f ; i++)
{
int aux = M [i] [1];
M [i] [1] = M [i] 1;
M [i] 1 = aux;
}
}
public static void main (String args [])
{
Scanner Leer = new Scanner(System.in);
int M [] [] = new int [20] [20];
System.out.print ("Inserte filas de la matriz: ");
int f = Leer.nextInt();
System.out.print ("Inserte columnas de la matriz: ");
int c = Leer.nextInt();
System.out.print ("nLLENANDO MATRIZ : n");
llenar (M, f, c);
System.out.print ("nLA MATRIZ ORIGINAL : ");
mostrar (M, f, c);
System.out.print ("nnLA MATRICES INTERCAMBIADA : ");
intercambiar (M, f, c);
mostrar (M, f, c);
}
}

Contar el numero de digitos de cada elemento de una matriz

import java.util.Scanner;
public class JavaMatrizMetod6 {

public static void llenar (int M [] [], int f, int c)

{
Scanner Leer = new Scanner(System.in);
for (int i = 1 ; i <= f ; i++)
{
for (int j = 1 ; j <= c ; j++)
{
System.out.print ("Inserte pos[" + i + "][" + j + "]: ");
M [i] [j] = Leer.nextInt();
}
}
}
public static void mostrar (int M [] [], int f, int c)
{
for (int i = 1 ; i <= f ; i++)
{
System.out.println ();
for (int j = 1 ; j <= c ; j++)
 {
System.out.print ("[" + M [i] [j] + "]");
}
}
}
public static void cuenta (int M [] [], int f, int c)
{
for (int i = 1 ; i <= f ; i++)
{
for (int j = 1 ; j <= c ; j++)
{
System.out.print("n[" + M [i] [j] + "] tiene: " + digitos (M [i] [j]) + " digito(s)");
}
}
}
public static int digitos (int n)
{
int contador = 0;
while (n != 0)
{
n = n / 10;
contador++;
}
return (contador);
}
public static void main (String args [])
{
Scanner Leer = new Scanner(System.in);
int M [] [] = new int [20] [20];
System.out.print ("Inserte filas de la matriz: ");
int f = Leer.nextInt();
System.out.print ("Inserte columnas de la matriz: ");
int c = Leer.nextInt();
System.out.print ("nLLENANDO MATRIZ M: n");
llenar (M, f, c);
System.out.print ("nLA MATRIZ: ");
mostrar (M, f, c);
System.out.print ("nnCONTEO DE DIGITOS: ");
cuenta (M, f, c);
}
}

Dada la matriz de m*n y el vector de tamao n, determinar que columna de la

matriz es igual al vector

import java.util.Scanner;
public class JavaMatrizVectorMetod1 {

public static void llenarMatriz (int M [] [], int f, int c)

{
Scanner Leer = new Scanner(System.in);
for (int i = 1 ; i <= f ; i++)
{
for (int j = 1 ; j <= c ; j++)
{
 System.out.print ("Inserte pos[" + i + "][" + j + "]: ");
M [i] [j] = Leer.nextInt();
}
}
}
public static void mostrarMatriz (int M [] [], int f, int c)
{
for (int i = 1 ; i <= f ; i++)
{
System.out.println ();
for (int j = 1 ; j <= c ; j++)
{
System.out.print ("[" + M [i] [j] + "]");
}
}
}
public static void llenarVector (int V [], int d)
{
Scanner Leer = new Scanner(System.in);
for (int i = 1 ; i <= d ; i++)
{
System.out.print ("Inserte pos.[" + i + "]: ");
V [i] = Leer.nextInt();
}
}
public static void mostrarVector (int V [], int d)
{
for (int i = 1 ; i <= d ; i++)
{
System.out.print ("[" + V [i] + "]");
}
}
public static void procedure (int M [] [], int f, int c, int V [], int d)
{
for (int i = 1 ; i <= f ; i++)
{
int sw = 1;
for (int j = 1 ; j <= c ; j++)
{
for (int k = 1 ; k <= d ; k++)
{
if (M [j] [i] != V [k])
sw = 0;
}
}
if (sw == 1)
System.out.println ("nnLa columna " + i + " es igual al vector");
}
}
public static void main (String args [])
{
Scanner Leer = new Scanner(System.in);
int M [] [] = new int [20] [20];
int V [] = new int [20];
System.out.print ("Inserte filas de la matriz: ");
int f = Leer.nextInt();
System.out.print ("Inserte dimension del vector: ");
 int d = Leer.nextInt();
System.out.print ("nLLENANDO MATRIZ: n");
llenarMatriz(M, f, d);
System.out.print ("nLLENANDO EL VECTOR: n");
llenarVector (V, d);
System.out.print ("nLA MATRIZ: ");
mostrarMatriz(M, f, d);
System.out.print ("nnEL VECTOR: n");
mostrarVector (V, d);
procedure (M, f, d, V, d);
}
}

Dada una matriz Z almacenar en un vector A la suma por sus columnas y en un

vector B la suma por sus filas

import java.util.Scanner;
public class JavaMatrizVectorMetod2 {

public static void llenarMatriz (int M [] [], int f, int c)

{
Scanner Leer = new Scanner(System.in);
for (int i = 1 ; i <= f ; i++)
{
for (int j = 1 ; j <= c ; j++)
{
System.out.print ("Inserte pos[" + i + "][" + j + "]: ");
M [i] [j] = Leer.nextInt();
}
}
}
public static void mostrarMatriz (int M [] [], int f, int c)
{
for (int i = 1 ; i <= f ; i++)
{
System.out.println ();
for (int j = 1 ; j <= c ; j++)
{
System.out.print ("[" + M [i] [j] + "]");
}
}
}
public static void mostrarVector (int V [], int d)
{
for (int i = 1 ; i <= d ; i++)
{
System.out.print ("[" + V [i] + "]");
}
}
public static void vectorA (int M [] [], int f, int c, int A [], int d)
{
for (int i = 1 ; i <= f ; i++)
{
int suma = 0;
 for (int j = 1 ; j <= c ; j++)
{
suma = suma + M [j] [i];
}
A [i] = suma;
}
}
public static void vectorB (int M [] [], int f, int c, int B [], int d)
{
for (int i = 1 ; i <= f ; i++)
{
int suma = 0;
for (int j = 1 ; j <= c ; j++)
{
suma = suma + M [i] [j];
}
B [i] = suma;
}
}
public static void main (String args [])
{
Scanner Leer = new Scanner(System.in);
int Z [] [] = new int [20] [20];
int A [] = new int [20];
int B [] = new int [20];
System.out.print("Inserte filas de la matriz: ");
int f = Leer.nextInt();
System.out.print("Inserte columnas de la matriz: ");
int c = Leer.nextInt();
System.out.print("nLLENANDO MATRIZ: n");
llenarMatriz(Z, f, c);
System.out.print("nLA MATRIZ Z: ");
mostrarMatriz(Z, f, c);
System.out.println("nnSUMA POR COLUMNAS DE LA MATRIZ (vector A): ");
vectorA(Z, f, c, A, c);
mostrarVector (A, c);
System.out.println("nnSUMA POR FILAS DE LA MATRIZ (vector B): ");
vectorB(Z, f, c, B, f);
mostrarVector (B, f);
}
}

Programa que genera una matriz de dos dimensiones con letras del alfabeto,
mostrndola posteriormente en pantalla.

public static void main(String[] args) {

final int FILAS = 3;
final int COLUMNAS = 5;
char letras[][] = new char[FILAS][COLUMNAS];
char letraQueToca = 'A';

//Carga las letras en la matriz

for(int f=0; f<FILAS; f++) {
for(int c=0; c<COLUMNAS; c++) {
letras[f][c] = letraQueToca;
 letraQueToca++;
}
}

//Mostrar en pantalla la matriz

for(int f=0; f<FILAS; f++) {
for(int c=0; c<COLUMNAS; c++) {
System.out.print(letras[f][c]+" ");
}
System.out.println();
}
}
{/code}

Programa que genera una matriz representando un tringulo invertido alineado a la

derecha realizado con asteriscos, cuyo tamao ser especificado por el usuario. La
matriz ser mostrada en pantalla finalmente. Por ejemplo, si se indica el tamao 5
deber aparecer:

*****
****
***
**
*

{code}
public static void main(String[] args) {
final int TAM = 5;
char triangulo[][] = new char[TAM][TAM];

//Cargar matriz con el dibujo

for(int f=0; f<TAM; f++) {
//Bucle para mostrar espacios
for(int c=0; c<f; c++)
triangulo[f][c] = ' ';
//Bucle para mostrar asteriscos
for(int c=f; c<TAM; c++)
triangulo[f][c] = '*';
}

//Mostrar matriz en pantalla

for(int f=0; f<TAM; f++) {
for(int c=0; c<TAM; c++)
System.out.print(triangulo[f][c]);
System.out.println();
}
}
Programa que lee por teclado nmeros enteros y los guarda en una matriz de 5 filas y 4
columnas. A continuacin muestra los valores ledos, el mayor y el menor y las posiciones que
ocupan.

import java.util.*;

public class Bidimensional2 {

public static void main(String[] args) {

final int FILAS = 5, COLUMNAS = 4;
Scanner sc = new Scanner(System.in);
int i, j, mayor, menor;
int filaMayor, filaMenor, colMayor, colMenor;
int[][] A = new int[FILAS][COLUMNAS];
System.out.println("Lectura de elementos de la matriz: ");
for (i = 0; i < FILAS; i++) {
for (j = 0; j < COLUMNAS; j++) {
System.out.print("A[" + i + "][" + j + "]= ");
A[i][j] = sc.nextInt();
}
}
System.out.println("valores introducidos:");
for (i = 0; i < A.length; i++) {
for (j = 0; j < A[i].length; j++) {
System.out.print(A[i][j] + " ");
}
System.out.println();
}
mayor = menor = A[0][0];//se toma el primero como mayor y menor
filaMayor = filaMenor = colMayor = colMenor = 0;

for (i = 0; i < A.length; i++) { //

for (j = 0; j < A[i].length; j++) {
if (A[i][j] > mayor) {
mayor = A[i][j];
filaMayor = i;
colMayor = j;
} else if (A[i][j] < menor) {
menor = A[i][j];
filaMenor = i;
colMenor = j;
}
}
}
System.out.print("Elemento mayor: " + mayor);
System.out.println(" Fila: "+ filaMayor + " Columna: " + colMayor);
System.out.print("Elemento menor: " + menor);
System.out.println(" Fila: "+ filaMenor + " Columna: " + colMenor);
 }
}

1. Calcular la media de una serie de nmeros que se leen por teclado.

Programa Java que lea por teclado 10 nmeros enteros y los guarde en un array. A
continuacin calcula y muestra por separado la media de los valores positivos y la de los
valores negativos.

/*
* Programa que lea por teclado 10 nmeros enteros
* y los guarde en un array.
* A continuacin calcula y muestra la media de los
* valores positivos y la de los valores negativos.
*/

import java.util.*;
public class Media1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int i;
int pos = 0, neg = 0; //contadores de los nmeros positivos y negativos
int[] numeros = new int[10]; //array que contendr los nmeros ledos por teclado
double sumaPos = 0, sumaNeg = 0; //acumuladores para las sumas de positivos y
negativos

//lectura de datos y llenar el array

System.out.println("Lectura de los elementos del array: ");
for (i = 0; i < 10; i++) {
System.out.print("numeros[" + i + "]= ");
numeros[i]=sc.nextInt();
}

//recorrer el array para sumar por separado los nmeros positivos

// y los negativos
for (i = 0; i < 10; i++) {
if (numeros[i] > 0){ //sumar positivos
sumaPos += numeros[i];
pos++;
} else if (numeros[i] < 0){ //sumar negativos
sumaNeg += numeros[i];
neg++;
}
}

//Calcular y mostrar las medias

if (pos != 0) {
 System.out.println("Media de los valores positivos: " + sumaPos / pos);
} else {
System.out.println("No ha introducido numeros positivos");
}
if (neg != 0) {
System.out.println("Media de los valores negativos: " + sumaNeg / neg);
} else {
System.out.println("No ha introducido numeros negativos");
}
}
}

2. Programa Java que lea 10 nmeros enteros por teclado y los guarde en un array. Calcula y
muestra la media de los nmeros que estn en las posiciones pares del array.

Considera la primera posicin del array (posicin 0) como par.

/*
* Programa que lea 10 nmeros enteros y los guarde en un array.
* Calcula y muestra la media de los que estn en las posiciones pares.
*/
import java.util.*;

public class Arrays1_2 {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

int i;
int[] numeros = new int[10];
double media = 0;

//lectura de datos y llenar el array

System.out.println("Lectura de los elementos del array: ");
for (i = 0; i < 10; i++) {
System.out.print("numeros[" + i + "]= ");
numeros[i] = sc.nextInt();
}

//Recorrer el array y calcular la media

for (i = 0; i < 10; i++) {
if (i % 2 == 0){ //si la posicin actual es par
media = media + numeros[i]; //se suma el valor de esa posicin
}
}
//Calcular y mostrar la media
System.out.println("Media de los valores que se encuentran en posiciones pares: "+
media/5);
}
}

Programa para:

- Llenar una matriz de forma automtica

- Calcular la suma de todos sus elementos
- " " " " " filas
- " " " " " columnas
- Calcular el mayor y menor elemento

package matrices1;

import java.io.*;

/**
*
* @author cesar
*/
public class Main {

public static void main(String[] args) throws IOException {

BufferedReader tcl= new BufferedReader(new InputStreamReader(System.in));

int M[][];
int n; // numero de filas
int m; // numero de columnas
int sumaTotal;
int sumaFilas[];
int sumaColumnas[];
int max;
int min;

System.out.println("Ingrese el numero de filas: ");

n = Integer.parseInt(tcl.readLine());

System.out.println("Ingrese el numero de columnas: ");

m = Integer.parseInt(tcl.readLine());
 sumaFilas = new int[n];
sumaColumnas = new int[m];
M = new int[n][m];
llenar(M, n, m);

sumaTotal = 0;
// suma total de elementos, y filas
// calcular mayor y menor elemento
max =-999999;
min = 999999;
for (int i=0; i<n; i++)
for (int k=0; k<m; k++){
sumaTotal = sumaTotal + M[i][k];
sumaFilas[i] = sumaFilas[i] + M[i][k];

if (M[i][k] > max) max = M[i][k];

if (M[i][k] < min) min = M[i][k];
}

// suma por columnas

// se intercambian los ciclos, la matriz es nxm
// aqui usamos como si fuese mxn
// sin embargo, usamos la matriz como normalmente
for (int k=0; k<m; k++)
for (int i=0; i<n; i++)
sumaColumnas[k] = sumaColumnas[k] + M[i][k];

// imprimir
for (int i=0; i<n; i++){
for (int k=0; k<m; k++)
System.out.print(" "+M[i][k]);
System.out.println(" = " + sumaFilas[i]);
}

for (int k=0; k<m; k++)

System.out.print(" "+ sumaColumnas[k]);
System.out.println();
System.out.println();

System.out.println("Mayor elemento: "+max);

System.out.println("Menor elemento: "+min);
}

public static void llenar(int M[][], int n, int m){

for (int i=0; i<n; i++)
for (int k=0; k<m; k++)
M[i][k] = (int)(Math.random()*10);
}

Programa para:
- Llenar una matriz de forma automtica
- Imprimir diagonal principal y secundaria
- Calcuar suma de elementos por encima y por
debajo de la diagonal principal

hay que tener en cuanta que para que una

matriz tenga diagonal principal y secundaria
debe ser de orden cuadrado, es decir, el
nmero de filas es igual al de las columnas...
por lo tanto, a la hora de solicitar datos al
usuario, slo pedimos uno: el de la dimensin, y
lo usamos tanto para filas como para
culumnas

package Matriz;
import java.io.*;
/**
*
* @author cdma86
*/
public class Main {

public static void main(String[] args) throws IOException {

BufferedReader tcl= new BufferedReader(new InputStreamReader(System.in));

int M[][];
int n;

System.out.println("Ingrese la dimensin de la Matriz: ");

n = Integer.parseInt(tcl.readLine());
M = new int[n][n]; // matriz de orden cuadrado nxn
llenarMatriz(M, n);
imprimir(M,n);

//Calcularemos la suma de los elementos

//por encima y por debajo de la diagonal principal
//Adems aprovecharemos para imprimir la diagonal principal
//y hacer todo en un solo proceso:
 int sumaArriba = 0;
int sumaAbajo = 0;

System.out.print("La diagonal principal es: [");

for (int i=0; i<n; i++)
for (int j=0; j<n; j++){
if (i == j)
System.out.print(M[i][j] +" ");
else if (i < j) sumaArriba += M[i][j];
else sumaAbajo += M[i][j];
}
System.out.println("]");

System.out.print("La diagonal secundaria es: [");

for (int i=n-1; i>=0; i--)
for (int j=0; j<n; j++)
if (n-1-i == j)
System.out.print(M[i][j] +" ");

System.out.println("]");
System.out.println("Suma por encima de la diagonal princial: "+ sumaArriba);
System.out.println("Suma por debajo de la diagonal princial: "+ sumaAbajo);
}

// llena una matriz de orden n*n con numeros aleatorios entre 0 y 9

public static void llenarMatriz(int M[][], int n){

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

for (int j=0; j<n; j++)
M[i][j] = (int) (Math.random()*10);

public static void imprimir(int M[][], int n){

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