JAVAMATRICESTOMOLXI

Autor: Luis Felipe Wanumen Silva 1

ENCICLOPEDIA CONOCIENDO

TOMO LXI

JAVA MATRICES

ELABORADO POR:

LUIS FELIPE WANUMEN SILVAINGENIERO DE SISTEMAS, CATÓLICO

Y AUTOR DE LA ENCICLOPEDIA CONOCIENDO

CONTIENECONCEPTOS DE MATRICES, EJEMPLOS, EJERCICIOS PROPUESTOS Y ALGO MÁS.

PRIMERA VERSIÓN AUN NO REVISADASANTAFE DE BOGOTA D.C.

SEPTIEMBRE DE 2003.

Enciclopedia Conociendo Java Matrices

Próximamente en Internet y en su librería más cercana



Incluye un CD con los ejemplos del libro


INTRODUCCIÓN

De antemano, quiero decir que mi deseo siempre habia sido el poder escribir un libro sobre java, pero a pesar de haber estudiado sobre este lenguaje y de haber desarrollado aplicaciones en dicho lenguaje, la verdad, nunca me quedo tiempo para organizar un material digno de poder presentar a la comunidad académica. Este manual inicialmente se empezó a realizar debido a mi vinculación como docente de hora cátedra en la Universidad Distrital de Bogota – Colombia, más exactamente en la Facultad Tecnológica de dicha Universidad, donde a pesar de tener este nombre, también se forman Ingenieros de Sistemas con énfasis en redes y no es por hacer propaganda, pero en esta parte de redes, me parece que los Ingenieros que salen de esta Alma Mater son muy buenos.

Tenía unos apuntes, desorganizados y solo los entendía yo, así que decidí poner todo mi empeño en el desarrollo de este material y espero que se siga mejorando este material, así como he mejorado otros materiales que desde hace mucho tiempo he venido publicando, como son los libros de Algoritmia y Programación, JavaScript, Bases de Datos con énfasis en SQL Server, ASP, etc.

Gracias al Ingeniero Miller por haber confiado en mí y haberme dado la oportunidad de dar la cátedra de “Lenguaje de Programación II”, en la cual, los estudiantes ven Java.

Espero que este material sea una muy buena herramienta para las personas que se introducen en el mundo de Java y para las personas experimentadas que ya tienen algún conocimiento de este excelente lenguaje de programación. De antemano, gracias a mis familiares por la paciencia que me tuvieron cada vez que me veían trabajando horas y horas en el computador y gracias a mi novia Esmeralda, por comprender que la elaboración de este material demanda tiempo y paciencia. Gracias a DIOS TODOPODEROSO por haberme dado salud, paciencia y licencia de culminar este material que hoy presento a cualquier persona que quiera iniciar, conocer, profundizar y afianzar sus conocimientos de Java.

Cualquier sugerencia que me quieran hacer sobre el presente material, será bien recibida y la pueden hacer en el correo [email protected] y mientras siga trabajando en la Universidad en el correo [email protected].


mailto:[email protected]

mailto:[email protected]


SOBRE EL AUTOR

Ingeniero de Sistemas egresado de la Universidad Distrital Francisco José de Caldas. Fue docente de la Universidad del Cauca en Popayán en materias como Ingenieria de Software I e Introducción a la Informática. A lo largo de su vida a escrito numerosos artículos, los cuales con el paso del tiempo ha ido recolectando en libros que él mismo a denominado Enciclopedia Conociendo. En dicha enciclopedia trata temas variados, es así como en ocasiones trata sobre las bases de datos, los ensayos psicológicos que son experiencias vividas por él; cómo ser un buen docente, donde trata experiencias puramente académicas; html, donde trata algunos aspectos de este lenguaje de marcado; guitarra, donde trata algunos aspectos de este instrumento y presenta un repertorio de canciones en su mayoría dictadas en el Colegio María Auxiliadora.

Luis Felipe es un Ingeniero que se ha caracterizado por ser un programador ante todo y esto lo demuestra con su participación en diversos proyectos, incluso desde su tesis en la que fue un investigador del grupo denominado “Biblioteca Virtual”, ha querido mostrar no sólo su carácter programador, sino escritor. Desde muy chico le ha gustado escribir y es así como incluso desde el colegio, ha escrito un mini manual de fórmulas matemáticas.

Es una persona muy católica, y esto lo ha demostrado con su participación en eucaristías en Popayán, en el cerro de Guadalupe en Bogotá, en la parroquia Cristo de la Paz en Santa Librada – Bogotá. Su gran pasión ha sido la guitarra, incluso ha participado en el festival de colcultura realizado en el año 1998, ha sido profesor de guitarra en Oscus del Barrio Bochica, ha sido docente de guitarra en el colegio María Auxiliadora, ha participado en el programa estampas juveniles, ha participado en la celebración de la novena de aguinaldos en la policía metropolitana, en buses amrillos y en muchas partes donde se ha podido vincular activamente a ésta celebración maravillosa de fin de año.



PROLOGO

Este material está enfocado principalmente a personas que no tienen conocimiento de java o personas que tienen unos conocimientos no muy profundos de java. La idea es con el paso del tiempo si DIOS me da vida, ir mejorando el material con el fin de lograr que cada día cubra más y mejores temas avanzados de este lenguaje.

La organización de este libro sigue una secuencia más o menos clásica, pues se comienza dando los fundamentos de cómo utilizar el compilador, las principales estructuras del lenguaje java, las matrices y programas cada vez más elaborados, juegos y al final se dedican esfuerzos por explicar swing y la conexión de java con bases de datos.

Este es un material que trata al máximo de colocar ejercicios resueltos con el fin de lograr que el aprendizaje sea rápido por parte del estudiante, pues mi experiencia me ha demostrado que el estudiante aprende mejor cuando se le dan ejemplos ya elaborados que le van mostrando como se aplican los diversos conceptos, casi se puede decir que siguiendo linealmente los ejercicios desarrollados en este libro, el estudiante está en capacidad de ir asimilando los conceptos sin necesidad de incluir mucha teoría. Obviamente la teoría se incluye en temas críticos como el inicio, en el cual hay necesidad de orientar al estudiante sobre la estructura, forma y alcances de la programación en java y en capítulos sobre matrices y vectores que son temas bastante trabajados en cursos de programación, pero en donde la mayoría de profesores carecen de ejercicios completos que muestren como se aplican dichos conceptos.



AGRADECIMIENTOS

En primera medida, gracias a DIOS TODOPODEROSO por haberme dado salud, licencia, paciencia y constancia para escribir este material, el cual a veces me hacía sufrir. De manera muy especial a mi hermana Gloria por haberme prestado su computador para trabajar en el documento, debido a que este equipo es más rápido que el que tengo yo. Gracias a todos mis queridos estudiantes, quienes con su entusiasmo me han dado ánimo para continuar este material y con su apoyo han hecho que este convencido que el desarrollo de este material no es cosa vana.



NORMAS PARA CLASE

1) Al final del semestre no se aceptan reclamos2) El profesor para realizar una verdadera labor docente no debe dar todo el material a

los estudiantes, por cuanto es bueno que el estudiante adquiera la habilidad necesaria para ser un investigador de conocimiento y en realidad el profesor es un guía a cerca de los temas a tratar y un bosquejo y/o propuesta de desarrollo de temas con algunos ejemplos que no son los definitivos y que pueden estar sujetos a cambios

3) No colocarle apodos al profesor4) El profesor puede hacer hasta 2 quices por clase y sin previo aviso5) Todo trabajo debe ser presentado por escrito y con copia en disquete.6) Los disquetes entregados se devuelven al finalizar el semestre, una vez ya se halla

entregado notas y no existan reclamos por parte de los estudiantes.7) El estudiante que falte a clase pierde la materia sin importar las notas que tenga.8) Estudiante que no entregue los trabajos completos, es decir, todos los talleres

propuestos en el presente material no pasa la materia, pues el 30% del total de la definitiva es la recopilación de todos los talleres y a parte de todo estudiante que no halla presentado trabajos no tiene derecho a presentar el programa final.

9) Los valores en porcentaje y peso de las notas son:15% parcial115% parcial215% talleres primera entrega15% talleres segunda entrega40% programa finalPor desorden en clase, faltas de respeto, groserías, mala presentación de trabajos se baja las notas de entrega de talleres en el porcentaje que estime conveniente el profesor.

10) El programa final,debe aplicar como mínimo conceptos de: arreglos, matrices, archivos, bases de datos y swing.

11) Las dudas extraclase se atienden solamente a personas que hallan leido el presente material o por lo menos los temas de este libro que tienen que ver con la duda del estudiante.

12) Después de mitad de semestre, el estudiante debe ir mostrando sus avances con respecto al programa final. Estudiante que no entregue avances previos al programa final está reservado el derecho del profesor a calificarlo o no.

13) Salvo ciertas circunstancias expuestas en clase por el mismo profesor, algunos normas pueden ser removidas, actualizadas o añadidas, en función del rendimiento y actitudes del curso.

14) A todos los estudiantes se les da la misma posibilidad de ser evaluados, tratados con equidad, respeto y de la misma manera se exige por parte del profesor la misma actidud de los estudiantes.

15) El presente material no puede ser utilizado por ningún otro docente, ni comercializado por persona alguna a menos que se tenga por escrito la autorización del autor: Luis Felipe Wanumen Silva y en ningún caso se transpasará, cederán,



venderán o regalarán propiedades de autoría por parte del autor de parte(s) o totalidad del material aquí expuesto.

16) Los estudiantes que hallan sido estudiantes del profesor Luis Felipe Wanumen tienen un permiso explícito concedido en esta parte para fotocopiar, reproducir, imprimir y utilizar este material únicamente con fines académicos para clase y para sí mismos y en ningún caso puede utilizar este material como ayuda didáctica para dictar una cátedra de programación y/o entregar copias a terceros a menos que tenga una autorización escrita del autor y no le cambie nada al material, como son encabezados, portadas citas, explicaciones y en ningún caso se ceden licencias comerciales o transferencias de propiedad de autoría a ninguna persona natural o jurídica.

17) El derecho a adquirir la versión mejorada del presente material por parte de ex -estudiantes del profesor y que sean graduados se tiene únicamente si se le avisa al autor que se desea la adquisición de dicha copia y es responsabilidad utilizar dicha copia y sacarle copias escritas o por otro medio únicamente para sí mismo y en ningún caso para publicación para ser vista por terceros; y aunque la copia sea para sí mismo en ningún caso se permite la alteración del contenido, de los encabezados de página, de los pies de página y páginas de presentación.

18) A ningún estudiante se le obliga a comprar el presente material al profesor en forma electrónica o escrita, el profesor vendería las fotocopias del mismo solamente a estudiantes que así lo hallan solicitado. Ningún estudiante puede vender fotocopias del presente material a personas que no sean estudiantes del profesor y el derecho a repartir copias electrónicas del presente material está reservado únicamente al profesor.

19) El profesor le regala a sus estudiantes el derecho a copiar este material en forma electónica únicamente para fines académicos y estrictamente relacionados con su crecimiento profesional en el curso y no para distribuir o fotocopiar este material para terceros. Para sí mismo cada estudiante puede sacarle cuantas copias desee de la manera que desee, pero nunca con el ánimo de lucro.

20) Si algún estudiante pretende publicar este material en un sitio web, lo puede hacer siempre y cuando cuente con la aprobación del profesor, deje intacto el material,no le quite ni le añada, no lo utilice con fines lucrativos indirecta o directamente y haga una referencia al autor siempre que se refiera a este material.

21) El profesor no se hace responsable por el uso que sus estudiantes hagan del presente material, ni mucho menos por las consecuencias ocasionadas en los equipos de cómputo, estaciones de trabajo o afines por la utilización, aplicación de conceptos y demás cuestiones expuestas en el presente material.

22) Bajo ninguna circunstancia un estudiante puede lucrarse con este material reproduciendo por cualquier medio el presente y vendiéndolo a terceros, así los terceros sean estudiantes del docente en mención.

23) La propiedad intelectual, de autoría y patente está únicamente dada al autor Luis Felipe Wanumen Silva y en ningún caso será cedida.

24) Cualquier marca aquí expuesta en el presente material es propiedad de la respectiva empresa y si en algún caso la mención de alguno de ellos se hace con el fin de causar deterioro de imagen, goodwill de empresa alguna, se dice que esta no es la intencion, puesto que se respetan las marcas, empresas, propiedades, patentes y estandares y a nadie se le discrimina por se empresa de software libre o propietaria,



por tener o dejar de tener cualquier caracteristica y en la medida de lo posible se pretende dar a entender en el presente material que no se pretende pordebajear otros lenguajes de programacion, empresas, revistas o cualquier entidad relacionada directa o indirectamente con este material.

25) La utilización del presenta material es responsabiliad solamente de la persona que lo haga y el autor no corre con ninguna responsabilidad que se haga del mismo.

26) El autor no garantiza que en un 100% los conceptos sean válidos, actuales, verídicos, pero garantiza que frecuentemente hace revisiones al presente material e intenta mejorar errores encontrados en versiones anteriores.

27) El presente material no es propiedad intelectual de ningún estudiante, empresa, universidad, multinacional o similar diferente al autor: Luis Felipe Wanumen Silva.

28) El derecho comercial y de lucro del presente material es exclusividad del autor: Luis Felipe Wanumen Silva



1. PRIMEROS EJERCICIOS CON MATRICES

1.1. CREANDO INICIANDO E IMPRIMIENDO MATRIZ TIPO INT Y NO DINAMICA

En este capitulo relacionado con las matrices es importante notar que un tema bien importante es la inicilización de la matriz con valores. Para hacer la cuestión bien didáctica, vamos en primera instancia a llenar la matriz con valores colocados por el programa y a medida que vayamos avanzando iremos incorporando nuevas complejidades. El siguiente programa solamente inicializa los valores de una matriz y posteriormente los imprime.

/******************************************************************Nombre : matriz3.javaDescripcion : El siguiente programa muestra como se

: crean e inicializan matrices de tipo intTipo: : No Maneja apuntadores, maneja arrays (Matrices)

: Es de tipo APPLET : El tamaño de la matriz es establecido por : el programador

Autor : Luis Felipe Wanumen [email protected] : No hay revisiones por el momento.Agradecimientos : No hayD.Historico : 03/05/2003******************************************************************/import java.awt.*;import java.applet.*;

public class MyApp extends Applet{ int num,pos_x,pos_y,x=15,y=25; int matriz[][]; public void init() { matriz=new int[5][3]; for(pos_x=0; pos_x<5; pos_x++) { for(pos_y=0; pos_y<3; pos_y++) { num=(int)(Math.random()*13)+1; // Sirve para establecer rango de // aleatoriedad de numeros producidos // Produce Numeros entre 1 y 14 matriz[pos_x][pos_y]=num;//asigna los numeros randomicos a la matriz } } } public void paint(Graphics g) { for(pos_x=0; pos_x<5; pos_x++) { for(pos_y=0; pos_y<3; pos_y++)



{ g.drawString(""+matriz[pos_x][pos_y], x, y); x+=22; // avanzo 22 posiciones graficas en x } x=15; //Me vuelvo a colocar en la posicionn en x inicial //cada vez que comienze el otro ciclo y+=22; // avanzo 22 posiciones graficas en y } }}

1.2. CREANDO INICIANDO E IMPRIMIENDO MATRIZ TIPO INT Y DINAMICA


: crean e inicializan matrices de tipo int : Como se le asignan valores y posteriormente : se imrime el contenido en un TextArea

Tipo: : El programa utiliza CONCAT de la clase STRING : No Maneja apuntadores, maneja arrays : Es de tipo Autonomo : El tamaño de la matriz es ditigado por el : usuario

Autor : Luis Felipe Wanumen [email protected] : No hay revisiones por el momento.Agradecimientos : No hayD.Historico : 12/04/2003******************************************************************/import java.awt.*;import java.awt.event.*;

public class MyApp extends Frame{

TextArea area = new TextArea(10,50);Label etiqueta = new Label("Digite numero columnas");TextField campo = new TextField("",5);Button boton1 = new Button("Aceptar");int col=0, fil=0, contador=0, tamano=0, i, j;

public boolean action(Event evt, Object arg){ String cadena1 = new String("Digite numero columnas"); String cadena2 = new String("Digite numero filas"); int comparo1 = cadena1.compareTo(etiqueta.getText()); if(comparo1==0){

col = Integer.parseInt(campo.getText()); etiqueta.setText("Digite numero filas"); campo.setText(""); } else {

int comparo2 = cadena2.compareTo(etiqueta.getText()); if(comparo2==0 && contador==0){



fil = Integer.parseInt(campo.getText()); etiqueta.setText("La matriz se va a llenar: fil="); int Matriz[][] = new int[fil][col]; int matriz2[]; int valor = 1; for(int k=0; k<fil; k++) { for(int m=0; m<col; m++){ Matriz[k][m]=valor; valor++; } } area.setText(""); for(int ii=0; ii<fil; ii++) { for(int jj=0; jj<col; jj++){ Integer auxiliar = new Integer(Matriz[ii][jj]); String areas = new String(area.getText()); String matris = new String(auxiliar.toString()+" "); area.setText(areas.concat(matris.toString())+"");

matris.concat(auxiliar.toString()); } area.setText(area.getText()+"\n"); } campo.setText("Que paso"); campo.setVisible(false); boton1.setVisible(true); campo.setText(""); contador++; tamano = fil*col; area.setVisible(true); } else { }//cierra comparo2==0 && contador==0 } return true;}

public MyApp(){

this.addWindowListener (new WindowAdapter(){public void windowClosing(WindowEvent e){

dispose();System.exit(0);

}});

Panel p = new Panel(); add(p); //FLOWLAYOUT: 0 LEFT, 1 CENTER, 2 RIGHT p.setLayout(new FlowLayout(1,10,10));

p.add(etiqueta);p.add(campo);



p.add(area);p.add(boton1);

p.show(); boton1.setVisible(false);

}

public static void main(String args[]){

System.out.println("Starting App");MyApp f = new MyApp();f.setSize(400,300);f.show();

}}

1.3. PROGRAMA QUE PIDE CADA UNO DE LOS VALORES DE UNA MATRIZ

Uno de los programas más interesantes en la parte de matrices es el relacionado con las matrices y en especial en la forma en como se podría hacer un programa que solicite al usuario cada uno de los contenidos que irían en una matriz. En este caso particular se va a mostrar como dada una matriz de enteros de tamaño 3 x 3, se le puede pedir al usuario los valores que han de ser colocados en dicha matriz. Obviamente el programa que vamos a mostrar inserta los valores en el siguiente orden:

1 2 34 5 67 8 9

/******************************************************************Nombre : matriz3a.javaDescripcion : El siguiente programa llenar una matriz

: de tamaño prdeterminado con valores : digitados por el usuario. : El programa halla una nueva matriz inserva e : imrime el contenido de la misma en un TextArea

Tipo: : El programa utiliza ciclos : Maneja matrices estaticas : Es de tipo Applet : El tamaño de la matriz es predeterminado : por el usuario

Autor : Luis Felipe Wanumen [email protected] : No hay revisiones por el momento.Agradecimientos : No hayD.Historico : 10/09/2004******************************************************************/import java.awt.*;import java.awt.event.*;import java.applet.*;

public class MyApp extends Applet



{GridLayout grilla = new GridLayout(2,1,5,5);

Button b1 = new Button("0k");TextField t1 = new TextField();TextArea ta = new TextArea();Panel p1 = new Panel();int matriz[][] = new int[3][3];int matrizT[][] = new int[3][3];int pos_x=0, pos_y=0;String cadena = "";almacenar guardar = new almacenar();

public void init(){setLayout(grilla);add(p1);p1.add(t1);p1.add(b1);b1.addActionListener(guardar);add(ta);

} // Cierra funcion ini()

public class almacenar implements ActionListener{ public void actionPerformed(ActionEvent ev){

if(pos_x==2 && pos_y==2){ matriz[pos_x][pos_y] = Integer.parseInt(t1.getText().trim()); ta.setText(""); for(int j=0; j<3; j++){ for(int i=0; i<3; i++){ matrizT[j][i] = matriz[i][j]; cadena = cadena + matrizT[j][i]; cadena = cadena + "\t"; } // Cierra for interno

cadena = cadena + "\n"; } // Cierra for externo ta.setText(cadena); }// Cierra if(pos_x==2 && pos_y==2) if(pos_x<3 && pos_y<3){ System.out.println("ANTES = x = "+pos_x); System.out.println("ANTES = y = "+pos_y); matriz[pos_x][pos_y] = Integer.parseInt(t1.getText().trim()); if(pos_x<2){ pos_x = pos_x+1; } else{ if((pos_y+1)<3){ pos_y = pos_y+1; pos_x = 0; } } // Cierra else interno System.out.println("DESPUES = x = "+pos_x); System.out.println("DESPUES = y = "+pos_y); System.out.println(" "); } // Cierra if (pos_x<2 && pos_y<2) } // Cierra actionPerformed



} // Cierra class almacenar}

En términos de interfaz al usuario, el anterior programa tiene un aspecto similar al siguiente:

En donde el usuario puede comenzar a digitar los valores que harán parte de la matriz “matriz”. Cuando el usuario presione el botón con el rótulo “OK” se insertará dicho valor en el respectivo de la matriz. Al momento de insertar el último valor, no solo se inserta, sino que también se calcula su inversa y se muestra en el “TextArea” ubicado en la parte inferior de la aplicación. Para ser didácticos supongamos que insertamos los siguientes valores:

10 20 3040 50 6070 80 90

Al insertar el último valor obtenemos una interfaz similar a la siguiente:



1.4. PROGRAMA QUE CALCULA LA TRANSPUESTA DE UNA MATRIZ

El programa siguiente es una mejora del anterior programa, por cuanto el programa además de permitir al usuario insertar los datos digitados por el usuario en una matriz, también crea una matriz con la transpuesta y la muestra al usuario.

Veamos en primera medida el programa:

import java.awt.*;import java.applet.*;import java.awt.event.*;

public class MyApp extends Applet{

String cadena=" ";Panel p1=new Panel();llena_matriz obj=new llena_matriz();TextField t1=new TextField(" ");Button b1=new Button ("OK");TextArea ta=new TextArea();GridLayout grilla=new GridLayout(2,1,0,0);int matriz[][]=new int[4][4];int x=0,y=0,contador=0;int matrizT[][]=new int[4][4];public void init(){

setLayout(grilla);add(p1);add(ta);p1.add(t1);p1.add(b1);b1.addActionListener(obj);

}

public class llena_matriz implements ActionListener{public void actionPerformed(ActionEvent ev){

if(contador<16){int valor;valor=Integer.parseInt(t1.getText().trim());matriz[x][y]=valor;matrizT[y][x]=valor;//System.out.println(""+valor);if(y<3){

y=y+1;}else {y=0;x=(x+1);}contador=contador+1;

}else{for(int i=0;i<4;i++){

for(int j=0;j<4;j++){



cadena=cadena+matrizT[i][j]+ "\t";}

cadena=cadena+"\n";}t1.setVisible(false);b1.setVisible(false);ta.setText(cadena);}

}}

}

En primera medida cabe anotar que la disposición de los elementos es la siguiente:

En donde podemos asegurar que en la parte superior se ha colocado un panel y en la parte inferior se ha colocado un TextField, tal como se muestra a continuación:

Esto se logra con las instrucciones:

add(p1);add(ta);

Ahora bien, dentro del Panel “p1” se colocan dos elementos, tal como se muestra a continuación:


Panel p1

TextArea ta


Y esto se logra con las instrucciones:

p1.add(t1);p1.add(b1);

En donde se puede observar que los elementos van a ser insertados dentro del panel superior, el cual en nuestro caso tiene el nombre de “p1”.

En este ejercicio, se ascocia un objeto de tipo evento a nuestro boton, el cual para este caso es el botón b1, mediante la instrucción:

b1.addActionListener(obj);

Podríamos pensar que la asociación de un objeto tipo evento al botón se podría representar abstractamente de la siguiente manera:

De tal suerte que cuando se hace click sobre el botón, en realidad se activa la clase Tipo ActionListener. Las clases que implementan ActionListener son clases evento en java, por esta razón una clase para que sea activada como un evento debe implementar la clase ActionListener

Otra cuestión importante que es necesario tener en cuenta es el hecho que cuando se activa una clase tipo “ActionListener”, se ejecuta la función actionPerformed, tal como se muestra en el siguiente diagrama conceptual:


Panel p1

TextArea ta

TextField t1 Button b1

Clase Tipo ActionListener

b1

Cuando se presione el boton b1, se activa la clase ActionListener


Con todo lo mostrado hasta el momento, vemos pues que todo el programa en esencia se reduce a comprender el funcionamiento de las instrucciones inmersas en la función “actionPerformed”:

En primera medida la función “actionPerformed” contiene un primer if con las siguientes instrucciones:

if(contador<16){int valor;valor=Integer.parseInt(t1.getText().trim());matriz[x][y]=valor;matrizT[y][x]=valor;//System.out.println(""+valor);if(y<3){

y=y+1;}else {y=0;x=(x+1);}contador=contador+1;

}

Las cuales verifican que la variable contador sea menor que 16 y si ello se cumple se toma el valor que hay en la caja de texto, se convierte a entero y finalmente se almacena en la matriz, tal como se muestra en el siguiente diagrama conceptual:


Clase Tipo ActionListener

Funcion actionPerformed

¡ACTIVESE!

¡EJECUTE FUNCION ACTIONPERFORMED!


Es necesario que el amigo lector / estudiante tenga en cuenta que si para este ejercicio en particular, si estamos situados en la primera, segunda o tercera columna podemos insertar el valor en la matriz y posteriormente incrementar la variable de la columna, en este caso, la variable “y”, tal como se muestra en el siguiente diagrama conceptual:

Pero como el amigo lector / estudiante lo ha podido notar, el problema se presentará cuando lleguemos al final de la fila, con lo cual diremos que este problema se soluciona mediante las instrucciones:

if(y<3){y=y+1;

}else {y=0;x=(x+1);}


b1

b1

Y=0

Y=1

Y=2

Y=3

Guarde el valor e incremente la variable y



Guarde el valor pero NO INCREMENTE e incremente la variable y


Las cuales se encargan de incrementar el valor de la fila, pero volver a inicializar la columna en la primera columna de la matriz (valga la redundancia). Esta situación se muestra concptualmente en el siguiente diagrama mental:

Esta situación se presentará las primeras 16 veces que el usuario haga click sobre el botón. La verdad es que cuando el usuario haga click por vez 17, se ejecutará las instrucciones contenidas en el bloque “else”:

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

for(int j=0;j<4;j++){cadena=cadena+matrizT[i][j]+ "\t";}

cadena=cadena+"\n";}t1.setVisible(false);b1.setVisible(false);ta.setText(cadena);}

Las cuales vuelven a recorrer la matriz pero con el fin de colocar los datos de la matriz transpuesta en una variable “cadena”, la cual es asignada como contenido del TextArea. Al finalizar la inserción de elementos, el programa produce una pantalla similar a la siguiente con los resultados que se muestran a continuación:


1. La siguiente posición es:

2. Paso a la siguiente fila aumentando el valor de j

3. Paso a la siguiente columna dejando el valor de i en 0


Esto obviamente se debe a que existe la instrucción que deshabilita el botón y la caja de texto, haciéndola invisible al usuario. Este efecto se obtiene cuando se ejecutan las instrucciones:

t1.setVisible(false);b1.setVisible(false);

y suponiendo por supuesto que han sido asignados valores enteros consecutivos que van del 1 al 16 y se iban insertando en la matriz.

1.5. MATRIZ MAGICA


: implementa el algoritmo de la MATRIZ : MAGICA : se imrime el contenido en un TextArea

Tipo: : El programa utiliza CONCAT de la clase STRING : No Maneja apuntadores, maneja arrays : Es de tipo Autonomo : El tamaño de la matriz es ditigado por el : usuario

Autor : Luis Felipe Wanumen [email protected] : No hay revisiones por el momento.Agradecimientos : No hayD.Historico : 12/04/2003******************************************************************/import java.awt.*;import java.awt.event.*;

public class MyApp extends Frame{

TextArea area = new TextArea(10,50);Label etiqueta = new Label("Digite numero columnas");TextField campo = new TextField("",5);



Button boton1 = new Button("Aceptar");int col=0, fil=0, contador=0, tamano=0, i, j;

public boolean action(Event evt, Object arg){ String cadena1 = new String("Digite numero columnas"); String cadena2 = new String("Digite numero filas"); int comparo1 = cadena1.compareTo(etiqueta.getText()); if(comparo1==0){

col = Integer.parseInt(campo.getText()); etiqueta.setText("Digite numero filas"); campo.setText(""); } else {

int comparo2 = cadena2.compareTo(etiqueta.getText()); if(comparo2==0 && contador==0){

fil = Integer.parseInt(campo.getText()); etiqueta.setText("La matriz se va a llenar: fil="); int Matriz[][] = new int[fil][col]; int matriz2[]; for(int k=0; k<fil; k++) { for(int m=0; m<col; m++){ Matriz[k][m]=0; } } int fila, columna; fila = fil-1; columna = (col-1)/2; //CONCRETAMENTE ESTA PARTE LLENA LA MATRIZ

int valor = 1; Matriz[fila][columna]=valor;etiqueta.setText("Ey:"+fila+" "+columna+"valor"+Matriz[fila]

[columna]);

// Aqui se colocan los valores de la matriz magicado {// Cuando todo funciona normalmente// Se puede incrementar fila y colif( (fila+1)<fil && (columna+1)<fil && (Matriz[fila+1]

[columna+1]==0) ){ valor++; Matriz[fila+1][columna+1]=valor; fila++; columna++;}

// Cuando es valido incrementar fila y columna// pero esta ocupada por un numero ya puesto// se debe disminuir la fila



if( (fila+1)<fil && (columna+1)<fil && (Matriz[fila+1][columna+1]!=0) )

{ valor++; Matriz[fila-1][columna]=valor; fila--;}

// Si estoy en la posicion inferior derecha// Es decir en la posicion (n,n)// siempre debo subir en la fila// Compruebeloif( ((fila+1)==fil) && ((columna+1)==fil) ){ valor++; Matriz[fila-1][columna]=valor; fila--;}

// Siempre que estoy en la ultima columna de la matriz// pero no en la posicion (n,n) tengo la seguridad que// la columna a la que hay que pasar es a la primera// y la fila es a la siguiente.// La columna primera = 0// Fila siguiente fila++if( ((columna+1)==fil) && ((fila+1)<fil) ){valor++;fila++;columna=0;Matriz[fila][columna]=valor;}

// Siempre que estoy en la ultima fila de la matriz// pero no en la posicion (n,n) tengo la seguridad que// la fila a la que hay que pasar es a la primera// y la columna es a la siguiente.// La fila primera = 0// columna siguiente col++if( ((fila+1)==fil) && ((columna+1)<fil) ){valor++;columna++;fila=0;Matriz[fila][columna]=valor;}

} // cierra do

while(valor<fil*fil); //AQUI TUVO QUE HABER LLENADO LA MATRIZ area.setText(""); // Esta parte imprime la matriz for(int ii=0; ii<fil; ii++) {



for(int jj=0; jj<col; jj++){ Integer auxiliar = new Integer(Matriz[ii][jj]); String areas = new String(area.getText()); String matris = new String(auxiliar.toString()+" "); area.setText(areas.concat(matris.toString())+"");

matris.concat(auxiliar.toString()); } area.setText(area.getText()+"\n"); } campo.setText("Que paso"); campo.setVisible(false); boton1.setVisible(true); campo.setText(""); contador++; tamano = fil*col; area.setVisible(true); } else { }//cierra comparo2==0 && contador==0 } return true;}

public MyApp(){

this.addWindowListener (new WindowAdapter(){public void windowClosing(WindowEvent e){

dispose();System.exit(0);

}});

Panel p = new Panel(); add(p); //FLOWLAYOUT: 0 LEFT, 1 CENTER, 2 RIGHT p.setLayout(new FlowLayout(1,10,10));

p.add(etiqueta);p.add(campo); p.add(area);p.add(boton1);

p.show(); boton1.setVisible(false);

}

public static void main(String args[]){

System.out.println("Starting App");MyApp f = new MyApp();f.setSize(400,300);f.show();

}}



1.6. MATRIZ DE TEXTFIELD

A continuación se muestra que no solo es posible construir matrices de tipos de datos, ya sean objetos o tipos primitivos, sino que también es posible construir matrices de otros objetos como TextField. En este ejercicio que viene a continuación se crea una matriz de 8*8 TextField, los cuales se añaden a una cuadrícula utilizando el diseñador GridLayout y se verifica a que diagonal pertenece dicho TextField y de acuerdo a ello, se le coloca el número de la diagonal y se le coloca un color.

Veamos en primera medida el código y después la explicación del mismo:


: implementa una matriz de TextField. Tambien : muestra como dibujar un tablero de ajedrez : con dichos TextField y numerar las diagonales

Tipo: : El programa utiliza AWT de la clase APPLET : No Maneja apuntadores, maneja matrices : Es de tipo Applet : El tamaño de la matriz es 8*8



TextField textos[][] = new TextField[8][8];GridLayout grilla = new GridLayout(8,8,2,2);Graphics graficos[][] = new Graphics[8][8];

public void paint(Graphics g){

g.drawString("Hello World", 20, 20);}

public void init(){ setLayout(grilla); for(int i = 0; i<8; i++){ for(int j = 0; j<8; j++){ double par; par = (i+j) % 2; textos[i][j] = new TextField(); add(textos[i][j]); if(par == 1.0){ textos[i][j].setBackground(Color.green); textos[i][j].setForeground(Color.black); } else{



textos[i][j].setBackground(Color.blue); textos[i][j].setForeground(Color.white); } textos[i][j].setText(""+(i+j)); } }}

}

Para poder entender este ejemplo es necesario que se vea con detenimiento la siguiente matriz:

Fila/Columna 0 1 2 3 4 5 6 70 41 42 43 44 4567

Las celdas que tienen el número cuatro tienen algo en común y es que la suma de sus índices suman cuatro. Veamos pues, la siguiente tabla mejorada:

Fila/Columna 0 1 2 3 4 5 6 70 0+4

= 40+7 = 7

1 1+3 = 4

1+6 = 7

2 2+2 = 4

2+5 = 7

3 3+1 = 4

3+4 = 7

4 4+0 = 4

4+3 = 7

5 5+2 = 7

5+7 =12

6 6+1 = 7

6+6 =12

7 7+0 = 7

7+5 =12

A continuación se muestra un tablero de ajedrez y los números de sus diagonales según lo visto anteriormente:



Fila/Columna 0 1 2 3 4 5 6 70 0 1 2 3 4 5 6 71 1 2 3 4 5 6 7 82 2 3 4 5 6 7 8 93 3 4 5 6 7 8 9 104 4 5 6 7 8 9 10 115 5 6 7 8 9 10 11 126 6 7 8 9 10 11 12 137 7 8 9 10 11 12 13 14

Según esto para dibujar un tablero de ajedrez, es posible preguntar por la suma de los indices (es decir de las posiciones de la fila y la columna) y posteriormente preguntar si es par o si es impar para proceder a colocarle el color que se quiera. Es decir, se debe adicionar una variable, en este caso una denominada “par”, la cual va a tomar el residuo entre la suma de fila y columna con el numero dos. Es decir va a tomar el siguiente valor:

Par = (i+j) mod 2 para todos los valores de i y todos los valores de j.

Al utilizar dicha variable veremos que la matriz con los valores de par toma la siguiente forma:

Fila/Columna 0 1 2 3 4 5 6 70 0 1 0 1 0 1 0 11 1 0 1 0 1 0 1 02 0 1 0 1 0 1 0 13 1 0 1 0 1 0 1 04 0 1 0 1 0 1 0 15 1 0 1 0 1 0 1 06 0 1 0 1 0 1 0 17 1 0 1 0 1 0 1 0

Y por último, según dicho valor se toma la decisión de pintarlo de un color el TextField y de otro color la letra. El fondo del TextField con la función “setBackground()” y el color de la letra con la función “setForeground()”.

Ahora, si, para finalizar veamos gráficamente el resultado del programa en java mostrado anteriormente:

0 1 2 3 4 5 6 71 2 3 4 5 6 7 82 3 4 5 6 7 8 93 4 5 6 7 8 9 104 5 6 7 8 9 10 115 6 7 8 9 10 11 12



6 7 8 9 10 11 12 137 8 9 10 11 12 13 14

1.7. DETALLANDO LAS DIAGONALES DE UNA MATRIZ

En el ejercicio anterior se mostraba como identificar la siguiente diagonal:

Fila/Columna 0 1 2 3 4 5 6 70 0 1 2 3 4 5 6 71 1 2 3 4 5 6 7 82 2 3 4 5 6 7 8 93 3 4 5 6 7 8 9 104 4 5 6 7 8 9 10 115 5 6 7 8 9 10 11 126 6 7 8 9 10 11 12 137 7 8 9 10 11 12 13 14

Es decir una diagonal en forma gráfica ascendente y hacia la derecha, tal como se muestra en el siguiente gráfico:

Fila/Columna 0 1 2 3 4 5 6 701234567

Ahora nos proponemos identificar la siguiente diagonal:

Fila/Columna 0 1 2 3 4 5 6 701234



567

Esta diagonal, también la podemos identificar mediante los índices, pero esta vez, mediante la resta de sus índices, tal como se muestra a continuación:

Fila/Columna 0 1 2 3 4 5 6 70 0-0 = 0 0 – 4 = -41 1-1 = 0 1-5 = -42 2-2 = 0 2-6 = -43 3-3 = 0 3-7 = -44 4-0 = 4 4-4 = 05 5-1 = 4 5-5 = 06 6-2 = 4 6-6 = 07 7-3 = 4 7-7 = 0

Los valores de las restas se muestran todos en el siguiente cuadro:

Fila/Columna 0 1 2 3 4 5 6 70 0 -1 -2 -3 -4 -5 -6 -71 1 0 -1 -2 -3 -4 -5 -62 2 1 0 -1 -2 -3 -4 -53 3 2 1 0 -1 -2 -3 -44 4 3 2 1 0 -1 -2 -35 5 4 3 2 1 0 -1 -26 6 5 4 3 2 1 0 -17 7 6 5 4 3 2 1 0

Ahora sólo restaria asignar a la variable par el valor del residuo, pero hay que tener en cuenta que el operador “%” no funciona bien cuando el numerador es negativo y el mod es positivo, con lo cual hay que preguntar quien es mayor. Es decir:

Si (i>j) par = (i-j ) % 2Si No par = (j-i) % 2.

Con lo cual el programa definitivo que implementa esta tablero de ajedrez, pero siguiendo la lógica de las diagonales descendentes, se muestra a continuación. Veamos:


: implementa una matriz de TextField. Tambien



: muestra como dibujar un tablero de ajedrez : con dichos TextField y numerar las diagonales




TextField textos[][] = new TextField[8][8];GridLayout grilla = new GridLayout(8,8,2,2);Graphics graficos[][] = new Graphics[8][8];



public void init(){ setLayout(grilla); for(int i = 0; i<8; i++){ for(int j = 0; j<8; j++){ double par; if(i>j){ par = (i-j) % 2; } else{ par = (j-i) % 2; } textos[i][j] = new TextField(); add(textos[i][j]); if(par == 1.0){ textos[i][j].setBackground(Color.green); textos[i][j].setForeground(Color.black); } else{ textos[i][j].setBackground(Color.blue); textos[i][j].setForeground(Color.white); } textos[i][j].setText(""+(i-j)); } }}

}

Y el resultado gráfico, es el siguiente:

0 -1 -2 -3 -4 -5 -6 -7



1 0 -1 -2 -3 -4 -5 -62 3 0 -1 -2 -3 -4 -53 4 5 0 -1 -2 -3 -44 5 6 7 0 -1 -2 -35 6 7 8 9 0 -1 -26 7 8 9 10 11 0 -17 8 9 10 11 12 13 0

1.8. TRIANGULARES Y DIAGONALES DE UNA MATRIZ

Con todos los ejercicio hechos hasta el momento no es difícil entender que la fórmula para identificar que un elemento se encuentre en una triangular o en una diagonal específica, está dada por la siguiente tabla:

En donde se encuentra Forma para identificarlo con los indices de columna y filaEn la triangular superior Fila – columna < 0 En la triangular inferior Fila – columna > 0En la diagonal ascendente Fila + Columna = máximo valor de indice de la matriz

cuadradaEn la diagonal descendente Fila = columna

Y la implementación de dicho programa no hace más que preguntar por estas condiciones y de acuerdo a la respuesta coloca el TextField de un color o de otro. Veamos pues el código fuente del ejercicio:

/******************************************************************Nombre : matriz5.javaDescripcion : El siguiente programa muestra como se identifica

: las diagonales de una matriz. : También se identifican los triangulos superior e : e inferior formados por dichas diagonales




TextField textos[][] = new TextField[8][8];



GridLayout grilla = new GridLayout(8,8,2,2);Graphics graficos[][] = new Graphics[8][8];



public void init(){ setLayout(grilla); for(int i = 0; i<8; i++){ for(int j = 0; j<8; j++){ textos[i][j] = new TextField(); add(textos[i][j]); if(i>j){ textos[i][j].setBackground(Color.green); textos[i][j].setForeground(Color.black); } if(i<j){ textos[i][j].setBackground(Color.blue); textos[i][j].setForeground(Color.white); } if(i==j){ textos[i][j].setBackground(Color.red); textos[i][j].setForeground(Color.white); } if( (i+j)==7){ textos[i][j].setBackground(Color.cyan); textos[i][j].setForeground(Color.black); } textos[i][j].setText(""+(i-j)); } }}

}

El programa anterior produce el siguiente resultado:

0 -1 -2 -3 -4 -5 -6 -71 0 -1 -2 -3 -4 -5 -62 3 0 -1 -2 -3 -4 -53 4 5 0 -1 -2 -3 -44 5 6 7 0 -1 -2 -35 6 7 8 9 0 -1 -26 7 8 9 10 11 0 -17 8 9 10 11 12 13 0

1.9. PROGRAMA QUE COLOCA 15 MINAS EN UNA MATRIZ

La idea de esta parte del libro es ir dando elementos para desarrollar completamente el problemas de un buscaminas, pero para poder hacerlo, es necesario que primero se haga el



ejercicio de colocar 15 minas en una matriz. La forma de hacerlo, es definiento dos vectores denominados vectx[] y vecty[], los cuales contendrán 15 posiciones vistas como parejas; es decir:

Posición 0 = matriz[vectx[0]][vecty[0]]Posición 1 = matriz[vectx[1]][vecty[1]]Posición 2 = matriz[vectx[2]][vecty[2]]Posición 3 = matriz[vectx[3]][vecty[3]]Posición 4 = matriz[vectx[4]][vecty[4]]Posición 5 = matriz[vectx[5]][vecty[5]]Posición 6 = matriz[vectx[6]][vecty[6]]Posición 7 = matriz[vectx[7]][vecty[7]]Posición 8 = matriz[vectx[8]][vecty[8]]Posición 9 = matriz[vectx[9]][vecty[9]]Posición 10 = matriz[vectx[10]][vecty[10]]Posición 11 = matriz[vectx[11]][vecty[11]]Posición 12 = matriz[vectx[12]][vecty[12]]Posición 13 = matriz[vectx[13]][vecty[13]]Posición 14 = matriz[vectx[14]][vecty[14]]Posición 15 = matriz[vectx[15]][vecty[15]]

Y en dichas posiciones de la matriz estarán las minas. Ahora bien, por medio de unas instrucciones, se garantiza que siempre se van a colocar 15 minas, es decir en 15 posiciones de la matriz estará el número “1” y en el resto, estará el número “0”. Las instrucciones mencionadas son las siguientes:

for(int x=0;x<15;x++){

minasx = (int)(Math.random()*10);minasy = (int)(Math.random()*10);if(minas[minasx][minasy] != 1){

minas[minasx][minasy] = 1;vecx[x] = minasx;vecy[x] = minasy;

}else x--;

}

El programa completo es el siguiente:

/******************************************************************Nombre : matriz6.javaDescripcion : El siguiente programa muestra como se colocan

: quince unos en diferentes posiciones de una matriz : para despues mostrarlos gráficamente : Lo cual será util para desarrollar un buscaminas

Tipo: : El programa utiliza AWT de la clase APPLET : No Maneja apuntadores, maneja matrices



: Es de tipo Applet : El tamaño de la matriz es 10*10

Autor : Luis Felipe Wanumen [email protected] : No hay revisiones por el momento.Agradecimientos : No hayD.Historico : 26/05/2003******************************************************************/import java.awt.*;import java.applet.*;import java.awt.event.*;


GridLayout grilla = new GridLayout(10,10,3,3);Panel[][] paneles = new Panel[10][10];Panel principal = new Panel();Panel comandos = new Panel();Button boton1 = new Button("Colocar 15 minas");int numeros[][] = new int[10][10];int minas[][] = new int[10][10];int vecx[] = new int[15];int vecy[] = new int[15];int minasx, minasy;public void paint(Graphics g){

for(int x=0;x<10;x++){ for(int y=0;y<10;y++){ minas[x][y] = 0; }}

for(int x=0;x<15;x++){



}else x--;

}

for(int i = 0; i<10; i++){ for(int j = 0; j<10; j++){ if(minas[i][j]== 1){ paneles[i][j].setBackground(Color.red); } else{ paneles[i][j].setBackground(Color.yellow); } } }

// init();}



public void init(){ setLayout(null); principal.setLayout(grilla); add(principal); principal.setBounds(0,30,300,300); add(comandos); comandos.setBounds(0,0,100,30); comandos.add(boton1); boton1.addActionListener(new aleatorio()); for(int i = 0; i<10; i++){ for(int j = 0; j<10; j++){ paneles[i][j] = new Panel(); principal.add(paneles[i][j]); // paneles[i][j].setBackground(Color.green); } // Cierra for interno } // Cierra for externo } // Cierra funcion init()

public class aleatorio implements java.awt.event.ActionListener{ public void actionPerformed(ActionEvent ev){ if(ev.getSource() == boton1){ repaint(); } // Cierra if } // Cierra actionPerformed} // Cierra aleatorio()

}

A manera de ejemplo, el programa anterior puede mostrar una pantalla similar a la siguiente(similar, debido a que es aleatorio):

En donde los paneles de color rojo son los paneles que indican que existe una mina en dicha posición.

1.10. PROGRAMA QUE COLOCA UN BUSCAMINAS DESCUBIERTO

Ahora intentaremos colocar en las posiciones alrededor de las minas los números correpondientes al número de minas que debe tener cada posición. Es decir que se va a



colocar un valor para las posiciones cuya parte izquierda, derecha, inferior, superior o diagonal en cualquier sentido tenga una mina. El programa mejorado con respecto al anterior es pues, el siguiente:

/******************************************************************Nombre : matriz7.javaDescripcion : El siguiente programa muestra como se colocan

: valores en las posiciones cercanas a las minas : del anterior ejercicio : Es el mismo programa anterior, pero mejorado




GridLayout grilla = new GridLayout(10,10,3,3);Panel[][] paneles = new Panel[10][10];Panel principal = new Panel();Panel comandos = new Panel();Button boton1 = new Button("Colocar 15 minas");Label letreros[][] = new Label[10][10];int numeros[][] = new int[10][10];int minas[][] = new int[10][10];int vecx[] = new int[15];int vecy[] = new int[15];int minasx, minasy;public void paint(Graphics g){

// Se inicializa la matriz en cerosfor(int x=0;x<10;x++){ for(int y=0;y<10;y++){ minas[x][y] = 0; numeros[x][y] = 0; }}

// Se colocan solo 15 minas en la matrizfor(int x=0;x<15;x++){





}else x--;

}

// Se pintan las minas de rojo y el resto de amarillofor(int i = 0; i<10; i++){

for(int j = 0; j<10; j++){ if(minas[i][j]== 1){ paneles[i][j].setBackground(Color.red); } else{ paneles[i][j].setBackground(Color.yellow); } } // Cierra for interno } // Cierra for externo

for(int i = 0; i<10; i++){ for(int j = 0; j<10; j++){ letreros[i][j].setText(" "); if(minas[i][j]== 1){ letreros[i][j].setText("M"); } // Si hay una mina a la derecha if(j<9 && minas[i][j+1]==1 && minas[i][j]!= 1){ numeros[i][j]++; letreros[i][j].setText(""+numeros[i][j]); } // Si hay una mina abajo if(i<9 && minas[i+1][j]==1 && minas[i][j]!= 1){ numeros[i][j]++; letreros[i][j].setText(""+numeros[i][j]); } // Si hay una mina a la izquierda if(j>0 && minas[i][j-1]==1 && minas[i][j]!= 1){ numeros[i][j]++; letreros[i][j].setText(""+numeros[i][j]); } // Si hay una mina arriba if(i>0 && minas[i-1][j]==1 && minas[i][j]!= 1){ numeros[i][j]++; letreros[i][j].setText(""+numeros[i][j]); } // Si hay una mina arriba izquierda if(i>0 && j>0 && minas[i-1][j-1]==1 && minas[i][j]!= 1){ numeros[i][j]++; letreros[i][j].setText(""+numeros[i][j]); } // Si hay una mina arriba derecha if(i>0 && j<9 && minas[i-1][j+1]==1 && minas[i][j]!= 1){ numeros[i][j]++; letreros[i][j].setText(""+numeros[i][j]); } // Si hay una mina abajo a la izquierda if(i<9 && j>0 && minas[i+1][j-1]==1 && minas[i][j]!= 1){ numeros[i][j]++; letreros[i][j].setText(""+numeros[i][j]); }



// Si hay una mina abajo a la derecha if(i<9 && j<9 && minas[i+1][j+1]==1 && minas[i][j]!= 1){ numeros[i][j]++; letreros[i][j].setText(""+numeros[i][j]); } } // Cierra for interno } // Cierra for externo } // Cierra funcion paint()

public void init(){ setLayout(null); principal.setLayout(grilla); add(principal); principal.setBounds(0,30,300,300); add(comandos); comandos.setBounds(0,0,100,30); comandos.add(boton1); boton1.addActionListener(new aleatorio()); for(int i = 0; i<10; i++){ for(int j = 0; j<10; j++){ paneles[i][j] = new Panel(); principal.add(paneles[i][j]); letreros[i][j] = new Label(" "); paneles[i][j].add(letreros[i][j]); // paneles[i][j].setBackground(Color.green); } // Cierra for interno } // Cierra for externo } // Cierra funcion init()

public class aleatorio implements java.awt.event.ActionListener{ public void actionPerformed(ActionEvent ev){ if(ev.getSource() == boton1){ repaint(); } // Cierra if } // Cierra actionPerformed} // Cierra aleatorio()

}

A manera de ejemplo, el programa anterior muestra un resultado similar al siguiente:

1 M 2 2 1 11 1 2 2 M 3 M 11 M 1 1 2 M 2 11 2 2 1 1 1 2 1 12 4 M 2 1 M 1M M M 2 1 1 2 1 12 3 2 1 1 M 2 1 1 1

1 2 M 2 2 M



1 1 1 1 2 M 2 11 M 1 1 1 1

1.11. PROGRAMA QUE IMPLEMENTA UN BUSCAMINAS

Ahora bien, después de haber analizado los dos anteriores programas, vemos que es cuestión de ocultar las minas y de agregar una variable global que se llame “comienzo”, la cual cuando tenga el valor de “1” es porque es el comienzo del programa y cuando tenga el valor de “0”, es porque es el fin del programa. Entonces como se verá en el siguiente programa, lo que se hace es añadir a la función “paint()”, una pregunta para indagar por el valor de esta variable y si es el comienzo se juega. En caso de ser el final, se buscan las minas y se muestran (con setVisible(true)), utilizando para ello la matriz denominada “minas[][]”.

El siguiente es el código que se añade:

for(int x=0;x<10;x++){ for(int y=0;y<10;y++){ if(minas[x][y] == 1){

paneles[x][y].setBackground(Color.red); letreros[x][y].setVisible(true);

//paneles[x][y].setBackground(Color.yellow); } } // Cierra for interno} // Cierra for externo

También se agrega una función mouseDown, con la cual se pregunta en que panel se hace clic y se compara si en dicha posición hay o no hay mina, si no hay mina, se va descrubriendo el Label, tal como se muestra en el siguiente fragmento de código:

for(int i = 0; i<10; i++){ for(int j = 0; j<10; j++){ if(evt.target == paneles[i][j] && comienzo ==1){ if(minas[i][j] == 0){ letreros[i][j].setVisible(true); visibles[i][j] = 1; } else{ comienzo = 0; repaint(); } } // Cierra if } // Cierra for interno } // Cierra for externo

Y en caso de ser una mina, se termina el juego colocando la variable comienzo en cero y volviendo a llamar a la función “paint()”. Recordemos que cuando se llame a la función “paint()” y la variable comienzo valga cero sencillamente se descubren todas las minas.



También es bueno mencionar que ahora ya no es necesario pintar las minas de diferente color cuando empieza el juego, por cuanto el chiste es que el usuario piense donde están las minas. Por lo tanto el siguiente código:


for(int j = 0; j<10; j++){ if(minas[i][j]== 1){ paneles[i][j].setBackground(Color.blue); } else{ paneles[i][j].setBackground(Color.blue); } } // Cierra for interno } // Cierra for externo

fue reemplazado por:

for(int i = 0; i<10; i++){ for(int j = 0; j<10; j++){ paneles[i][j].setBackground(Color.blue); paneles[i][j].setBackground(Color.blue); } // Cierra for interno } // Cierra for externo

Bueno, pero ahora para lograr un entendimiento global del programa veamos, el programa completo que implementa un buscaminas:

/******************************************************************Nombre : matriz8.javaDescripcion : El siguiente programa muestra como se implementa

: en su totalidad un buscaminas. Es la mejora a los : dos ejercicios anteriores




GridLayout grilla = new GridLayout(10,10,3,3);Panel[][] paneles = new Panel[10][10];Panel principal = new Panel();Panel comandos = new Panel();Button boton1 = new Button("Colocar 15 minas");Label letreros[][] = new Label[10][10];



int numeros[][] = new int[10][10];int minas[][] = new int[10][10];int visibles[][] = new int[10][10];int vecx[] = new int[15];int vecy[] = new int[15];int comienzo;int minasx, minasy;public void paint(Graphics g){ if(comienzo == 1){

// Se inicializa la matriz en cerosfor(int x=0;x<10;x++){ for(int y=0;y<10;y++){ minas[x][y] = 0; numeros[x][y] = 0; }}

// Se colocan solo 15 minas en la matrizfor(int x=0;x<15;x++){



}else x--;

}


for(int j = 0; j<10; j++){ paneles[i][j].setBackground(Color.blue); paneles[i][j].setBackground(Color.blue); } // Cierra for interno } // Cierra for externo

for(int i = 0; i<10; i++){ for(int j = 0; j<10; j++){ letreros[i][j].setText(" "); if(minas[i][j]== 1){ letreros[i][j].setText("M"); } // Si hay una mina a la derecha if(j<9 && minas[i][j+1]==1 && minas[i][j]!= 1){ numeros[i][j]++; letreros[i][j].setText(""+numeros[i][j]); } // Si hay una mina abajo if(i<9 && minas[i+1][j]==1 && minas[i][j]!= 1){ numeros[i][j]++; letreros[i][j].setText(""+numeros[i][j]); } // Si hay una mina a la izquierda if(j>0 && minas[i][j-1]==1 && minas[i][j]!= 1){



numeros[i][j]++; letreros[i][j].setText(""+numeros[i][j]); } // Si hay una mina arriba if(i>0 && minas[i-1][j]==1 && minas[i][j]!= 1){ numeros[i][j]++; letreros[i][j].setText(""+numeros[i][j]); } // Si hay una mina arriba izquierda if(i>0 && j>0 && minas[i-1][j-1]==1 && minas[i][j]!= 1){ numeros[i][j]++; letreros[i][j].setText(""+numeros[i][j]); } // Si hay una mina arriba derecha if(i>0 && j<9 && minas[i-1][j+1]==1 && minas[i][j]!= 1){ numeros[i][j]++; letreros[i][j].setText(""+numeros[i][j]); } // Si hay una mina abajo a la izquierda if(i<9 && j>0 && minas[i+1][j-1]==1 && minas[i][j]!= 1){ numeros[i][j]++; letreros[i][j].setText(""+numeros[i][j]); } // Si hay una mina abajo a la derecha if(i<9 && j<9 && minas[i+1][j+1]==1 && minas[i][j]!= 1){ numeros[i][j]++; letreros[i][j].setText(""+numeros[i][j]); } if(visibles[i][j]== 1){ letreros[i][j].setVisible(true); } else{ letreros[i][j].setVisible(false); } } // Cierra for interno } // Cierra for externo } // Cierra si comienzo == 1 SI INICIA JUEGO else{

for(int x=0;x<10;x++){ for(int y=0;y<10;y++){ if(minas[x][y] == 1){

paneles[x][y].setBackground(Color.red); letreros[x][y].setVisible(true);

//paneles[x][y].setBackground(Color.yellow); } } // Cierra for interno} // Cierra for externo

} // Cierra si comienzo NO ES 1 "SI ES FINAL DE JUEGO"} // Cierra funcion paint()

public void init(){ setLayout(null); principal.setLayout(grilla); add(principal); principal.setBounds(0,30,300,300); add(comandos); comandos.setBounds(0,0,100,30);



comandos.add(boton1); boton1.addActionListener(new aleatorio()); comienzo = 1; for(int i = 0; i<10; i++){ for(int j = 0; j<10; j++){ paneles[i][j] = new Panel(); principal.add(paneles[i][j]); // paneles[i][j].addActionListener(new aleatorio()); letreros[i][j] = new Label(" "); visibles[i][j] = 0; paneles[i][j].add(letreros[i][j]); // paneles[i][j].setBackground(Color.green); } // Cierra for interno } // Cierra for externo } // Cierra funcion init()

public boolean mouseDown(Event evt, int x, int y){ for(int i = 0; i<10; i++){ for(int j = 0; j<10; j++){ if(evt.target == paneles[i][j] && comienzo ==1){ if(minas[i][j] == 0){ letreros[i][j].setVisible(true); visibles[i][j] = 1; } else{ comienzo = 0; repaint(); } } // Cierra if } // Cierra for interno } // Cierra for externo return false;

} // Cierra mouseDown

public class aleatorio implements java.awt.event.ActionListener{ public void actionPerformed(ActionEvent ev){ if(ev.getSource() == boton1){ comienzo = 1; for(int i = 0; i<10; i++){ for(int j = 0; j<10; j++){ visibles[i][j] = 0; } // Cierra for interno } // Cierra for externo repaint(); } // Cierra if

// repaint(); } // Cierra actionPerformed} // Cierra aleatorio()

}

1.12. PROGRAMA QUE ENSEÑA A DIVIDIR



El siguiente programa, funciona con algunos valores, la verdad no funciona con todos los valores, por cuanto no se tuvo en cuenta el caso en el que al hacer la resta se disminuye un valor. Es decir cubre el caso: 82-75 = 7 (El resultado tiene una cifra menos que los operandos), pero no cubre los casos en los cuales el resultado tiene el mismo número de digitos que los operandos. Por ejemplo para los siguientes casos funciona:

44389 / 452443892 / 45369852 /587

Y para otros valores no funciona. Pero bueno, usted se estará preguntando porque en un libro como este aparece un ejercicio que no funciona con todos los valores. La respuesta es muy sencilla: ¡Es un ejercicio para que usted amigo lector practique con las matrices y con la programación en Java!.

Bueno y para no hablar demasiado, veamos el ejercicio:

/******************************************************************Nombre : matriz9.javaDescripcion : Programa que enseña a dividir

: Con algunos valores no funciona : Si el problema sobrepasa el No de paneles : produce un error de desbordamiento.


Autor : Luis Felipe Wanumen [email protected] : No hay revisiones por el momento.Agradecimientos : No hayD.Historico : 27/05/2003******************************************************************/import java.awt.*;import java.applet.*;import java.util.Vector;import java.awt.event.*;

public class MyApp extends Applet implements java.awt.event.ActionListener{

int comienzo;int cociente;Panel pregunta = new Panel();Panel respuesta = new Panel();Label numerador = new Label("Dividendo");Label denominador = new Label("Divisor");Button boton1 = new Button("Calcular");TextField operando1 = new TextField();TextField operando2 = new TextField();Vector dividendo[][] = new Vector[6][11];Vector divisor[][] = new Vector[6][11];TextField textos1[][] = new TextField[11][11];int numeros[][] = new int[11][11];



int lon1; // Longitud del dividendoint lon2; // Longitud del divisorint lon3; // Longitud del cociente


int columnis = 1;

g.drawString("Hello World", 20, 20);if(comienzo == 2){

// Este for es para hacer las restas sucesivas for(int x = 0; x<11; x++){ int resta1 = 0; int resta2 = 0; int contador = 0; int encontro = 0; int inicial = 0; for(int y = 0; y<11; y++){ if(numeros[x][y]== 99){ contador++; if(encontro == 0){ inicial = y; encontro = 1; } // Cierra if interno } // Cierra primer if } // Cierra for interno if(encontro == 1){ String cadena = new String(""); String cadena1 = new String(""); for(int j = inicial; j<(inicial+contador); j++){ String cad = new String(cadena+numeros[x-2][j]); cadena = cad; String cad1 = new String(cadena1+numeros[x-1][j]); cadena1 = cad1; } int oper_resta1 = Integer.parseInt(cadena); int oper_resta2 = Integer.parseInt(cadena1); int subtotal = oper_resta1 - oper_resta2; System.out.println(subtotal); String sub_resta = new String(""+subtotal); for(int j = 0; j<contador; j++){ numeros[x][j+columnis] =

Integer.parseInt(sub_resta.substring(j,j+1)); } columnis++; } // Cierra if encontro == 1 } // Cierra for externo para las restas // Para graficar el resultado for(int i = 0; i<11; i++){ for(int j = 0; j<11; j++){ if(numeros[i][j] >= 0){ textos1[i][j].setText(""+numeros[i][j]); System.out.println("numeros["+i+"]["+j+"]="+numeros[i][j]);



} else{ textos1[i][j].setVisible(false); } // Colorea el divisor if(i== 0 && j>=6){ textos1[i][j].setBackground(Color.green); } // Colorea el cociente if(i== 1 && j>=6){ textos1[i][j].setBackground(Color.yellow); } // Colorea el dividendo if(i== 0 && j<6){ textos1[i][j].setBackground(Color.pink); } } // Cierra for interno } // Cierra for externo para graficar

} // Cierra if comienzo == 2

} // Cierra funcion paint()

public void init(){ setLayout(null); comienzo = 1; pregunta.setLayout(null); respuesta.setLayout(null); add(pregunta); pregunta.setBounds(0,0,300,60); pregunta.setBackground(Color.yellow); pregunta.add(numerador); pregunta.add(operando1); numerador.setBounds(0,0,90,30); operando1.setBounds(0,30,90,30); pregunta.add(denominador); pregunta.add(operando2); denominador.setBounds(100,0,90,30); operando2.setBounds(100,30,90,30); pregunta.add(boton1); boton1.setBounds(200,20,90,30); boton1.addActionListener(this); add(respuesta); GridLayout grilla = new GridLayout(11,11,2,2); respuesta.setBounds(0,60,300,290); respuesta.setBackground(Color.cyan); respuesta.setLayout(grilla); for(int i = 0; i<11; i++){ for(int j = 0; j<11; j++){ textos1[i][j] = new TextField("X"); respuesta.add(textos1[i][j]); numeros[i][j] = -1; } // Cierra for interno } // Cierra for externo} // Cierra funcion init()



public void actionPerformed(ActionEvent ev){ if(ev.getSource() == boton1 && comienzo==1){ String op1 = new String(operando1.getText().trim()); String op2 = new String(operando2.getText().trim()); int arriba = Integer.parseInt(op1); int abajo = Integer.parseInt(op2); cociente = arriba/abajo; String op3 = new String((new Integer(cociente)).toString()); lon1 = op1.length(); lon2 = op2.length(); lon3 = op3.length(); if(lon1>lon2 && lon1<7 && lon2>0 && lon1>0 && lon2<5){ comienzo = 2; // Este for para colocar el dividendo for(int m = 0; m<op1.length(); m++){ String aux = new String(""+op1.substring(m,m+1)); textos1[0][m].setText(aux.trim()); numeros[0][m] = Integer.parseInt(aux); System.out.println(""+aux ); System.out.println("Bien dentro"+numeros[0][m]); } // Este for para colocar el divisor for(int k = 0; k<op2.length(); k++){ String aux = new String(""+op2.substring(k,k+1)); textos1[0][k+6].setText(aux.trim()); numeros[0][k+6] = Integer.parseInt(aux); System.out.println(""+aux ); System.out.println("Bien dentro"+numeros[0][k+6]); } // Este for para colocar el cociente for(int n = 0; n<op3.length(); n++){ String aux = new String(""+op3.substring(n,n+1)); textos1[1][n+6].setText(aux.trim()); numeros[1][n+6] = Integer.parseInt(aux); System.out.println(""+aux ); System.out.println("Bien dentro"+numeros[1][n+6]); } int columna = 0; int longitud = 0; int pos_cociente = 0; int valor_cociente = 0; // Este for para hacer las divisiones for(int t = 0; t<op3.length(); t++){ String aux = new String(""+op3.substring(t,t+1)); valor_cociente = abajo*Integer.parseInt(aux); String st_cociente = new String(""+valor_cociente); for(int y = 0; y<st_cociente.length(); y++){ String au = new String(""+st_cociente.substring(y,y+1)); numeros[t*2+1][columna+y] = Integer.parseInt(au); // Para bajar la cifra if(t>0 && y == 0){ numeros[t*2][columna+y+st_cociente.length()-1]= numeros[0]

[columna+y+st_cociente.length()-1]; } else{ if(t>0) numeros[t*2][columna+y-1] = 99;



} } columna++; } // Cierra for que hace las divisiones } // Cierra ir validador de entrada de datos repaint(); } // Cierrra if externo si es boton1} // Cierra mouseDown()

}

1.13. PROGRAMA QUE MUESTRA LOS MOVIMIENTOS DEL CABALLO EN EL AJEDREZ

Suponga un tablero de ajedrez de ocho por ocho como es lo común. ¿Se acuerda como se mueve el caballo en un tablero de ajedrez?, pues bien, de lo que se trata es de hacer la suposición que en el tablero de ajedrez, solamente existe un caballito y que dicho caballito debe desplazarse por todo el tablero de ajedrez, recorriendo las 64 posiciones del mismo, sin repetir posición. A continuación se muestra una solución a dicho problema en el cual la posición inicial está marcada con el número uno (1) y la posición siguiente que ocupa el mismo caballito es la indicada por el número dos (2), y así sucesivamente. Veamos pues el cuadro:

37 56 25 2 27 40 15 424 1 38 57 14 3 28 4155 36 13 26 39 58 5 1612 23 64 59 50 47 42 2935 54 49 46 63 60 17 622 11 62 51 48 45 30 4353 34 9 20 61 32 7 1810 21 52 33 8 19 44 31

La implementación es la siguiente.

/******************************************************************Nombre : caballito.javaDescripcion : El siguiente programa implementa el juego

: del movimiento del caballo en el ajedrez : de tal suerte que ocupe todas las casillas

Tipo: : El programa utiliza java.awt.* y java.applet.* : No Maneja apuntadores, no maneja matrices : Es de tipo Applet : NO ES RECURSIVO

Autor : Luis Felipe Wanumen [email protected] : No hay revisiones por el momento.Agradecimientos : No hayD.Historico : 28/05/2003



******************************************************************/import java.awt.*;import java.applet.*;


int matriz[][] = new int[8][8];int fila, columna, contador;public void paint(Graphics g){

g.drawString("Hello World", 20, 20);for(int i = 0; i<8; i++){ for(int j = 0; j<8; j++){ System.out.println("matriz["+i+"]["+j+"]="+matriz[i][j]); } // Cierra for interno} // Cierra for externo

}

public void valida(int fil, int col, int par1, int par2){ if(fil<8 && fil>=0 && col<8 && col>=0 && par1 == par2){ if(matriz[fil][col]==0){ matriz[fil][col] = par1; System.out.println("fil="+fil+" col = "+col+ " par1 ="+par1); fila = fil; columna = col; contador++; } // Cierra if interno } // Cierra if externo} // Cierra funcion valida

public void init(){ fila = 1; columna = 2; contador = 0;

for(int i = 0; i<8; i++){ for(int j = 0; j<8; j++){ matriz[i][j] = 0; } // Cierra for interno} // Cierra for externo

for(int k= 1; k<=64; k++){ contador = k; if(fila <= columna){ valida(fila-2,columna+1,contador, k); valida(fila-1,columna+2,contador, k); valida(fila+1,columna+2,contador, k); valida(fila+2,columna+1,contador, k); valida(fila+2,columna-1,contador, k); valida(fila+1,columna-2,contador, k); valida(fila-1,columna-2,contador, k); valida(fila-2,columna-1,contador, k); } // Cierra si fila <= columna else{ valida(fila+2,columna-1,contador, k); valida(fila+1,columna-2,contador, k); valida(fila-1,columna-2,contador, k);



valida(fila-2,columna-1,contador, k); valida(fila-2,columna+1,contador, k); valida(fila-1,columna+2,contador, k); valida(fila+1,columna+2,contador, k); valida(fila+2,columna+1,contador, k); } // Cierra else }// Cierra for hasta k < 64}

}

El programa anterior llena la siguiente matriz:

11 24 37 52 1 14 27 4036 51 12 25 38 41 2 1523 10 53 58 13 26 39 2850 35 64 61 42 55 16 39 22 57 54 59 62 29 4434 49 60 63 56 43 4 1721 8 47 32 19 6 45 3048 33 20 7 46 31 18 5

Bueno, se estará preguntando que este ejercicio soluciona el problema de otra forma, la pregunta es: ¿existen muchas formas de solucionar el problema?. La respuesta es: ¡Si!, pues todo depende de la posición en la que empiece el movimiento del caballo en el ajedrez. Surge entonces otra pregunta: ¿qué regla sigue el caballo para moverse por el ajedrez?. La respuesta no es tan rápida e inmediata como se piensa, pues el movimiento del caballito en el ajedrez, depende de la posición en la que se encuentre o mejor dicho de la región del ajedrez en la que se encuentre actualmente el caballo.

Con todo lo expuesto anteriormente, es claro cuál es el problema y animo al amigo lector / estudiante para que intente solucionar el problema manualmente y se dará cuenta que no es tan rápido solucionarlo. Pues bien, muchas personas ya han solucionado dicho problema y después de analizar los resultados han establecido métodos y normas que debe seguir el caballo para lograr cubrir el ajedrez completamente. Recordemos que el caballo no puede pasar por la misma posición dos o más veces

Supongamos el caballo que se encuentra donde está la letra “X” en las casillas blancas, las celdas sombreadas indican el número de fila o columna respectiva

Col 0 Col 1 Col 2 Col 3 Col 4 Col 5 Col 6 Col 7Fila 0Fila 1 XFila 2Fila 3Fila 4Fila 5Fila 6



Fila 7

En dicho tablero el caballo ubicado en esta posición se encuentra en una región que cumple la siguiente condición: Fila <= Columna, con lo cual los movimientos que puede hacer el caballo se evaluan en un orden especifico de acuerdo al primero que sea válido y ese se ejecutará. El orden de los movimientos a evaluar para un caballo que se encuentre en una posición que cumpla dicha condición es el mostrado en la siguiente figura:



Y para las veces en que el caballo se encuentre en la diagonal inferior del tablero de ajedrez, se debe seguir la evaluación de posibles movimientos en el orden mostrado por la siguiente figura:

Recordemos que los movimientos se evalúan en este orden, y tan pronto se ejecuta un movimiento por ser valido (no haber terminado el juego y estar la siguiente posición sin pisar), los demás movimientos ya no se ejecutan y de acuerdo a la siguiente posición se vuelve a mirar en que posición del ajedrez se encuentra el caballo y se procede a continuar evaluando los movimientos según el caso.

Bueno, pero para llegar a ser un poco más didáctico analicemos la siguiente posición que debe tomar el caballo que venimos trabajando:


caballito

18

45

27

6 3

Region A

caballito

54

81

63

2 7

Region B


Retroceder dos filas y avanzar dos columnas, no lo puede hacer debido a que se saldría del tablero. El siguiente movimiento a evaluar es retroceder una fila y avanzar dos columnas y este movimiento si lo puede hacer. A continuación se muestra la posición resultado de hacer dicho movimiento y se marca con la letra “Y”. Veamos:



Col 0 Col 1 Col 2 Col 3 Col 4 Col 5 Col 6 Col 7Fila 0 YFila 1 XFila 2Fila 3Fila 4Fila 5Fila 6Fila 7

Dado que el contador de nuestro programa comenzó con cero, es necesario hacer 64 movimientos y el uno se coloca en la posición Y, lo cual produce nuestro resultado:

Col 0 Col 1 Col 2 Col 3 Col 4 Col 5 Col 6 Col 7Fila 0 11 24 37 52 1 14 27 40Fila 1 36 51 12 25 38 41 2 15Fila 2 23 10 53 58 13 26 39 28Fila 3 50 35 64 61 42 55 16 3Fila 4 9 22 57 54 59 62 29 44Fila 5 34 49 60 63 56 43 4 17Fila 6 21 8 47 32 19 6 45 30Fila 7 48 33 20 7 46 31 18 5

Por el momento, se deja como ejercicio final al amigo lector / estudiante la implementación de dicho ejercicio en forma gráfica, lo cual es bastante sencillo, pues es únicamente ir colocando paneles de colores e ir cambiando el color de los paneles mediante un hilo de acuerdo con los valores que están en dicha matriz, buscando siempre el valor siguiente (con un hilo para que de la apariencia de irlos colocando despacio). Bueno hay otras soluciones al problema pero es tarea de usted querido estudiante / lector implementarlas con el fin de avanzar en el manejo de las matrices y de java.

Bien, hay algo muy importante que resaltar con respecto al problema del movimiento del caballo en el ajedrez, y es que no siempre utilizando el mismo algoritmo descrito anteriormente se llega a una respuesta completa, es decir que cubra todas las casillas del ajedrez. Osea que el algoritmo descrito funciona solo si la posición inicial está entre la siguiente lista de posiciones:

(1,2), (2,3), (5,4), (6,5) y (6,7), donde las parejas (x,y) indican fila “x” y columna “y”.



Y para lograr un entendimiento más completo del problema, a continuación se muestra una tabla en la que se describe el número de posiciones avanzadas por el caballo cuando se comienza el programa en cada una de las diferentes posiciones del tablero de ajedrez.

(0,0) = 12 (0,1) = 62 (0,2) = 62 (0,3) = 58 (0,4) = 62 (0,5) = 60 (0,6) = 56 (0,7) = 56(1,0) = 58 (1,1) = 58 (1,2) = 64 (1,3) = 56 (1,4) = 54 (1,5) = 58 (1,6) = 62 (1,7) = 61(2,0) = 24 (2,1) = 59 (2,2) = 58 (2,3) = 64 (2,4) = 56 (2,5) = 54 (2,6) = 58 (2,7) = 60(3,0) = 58 (3,1) = 56 (3,2) = 56 (3,3) = 62 (3,4) = 58 (3,5) = 62 (3,6) = 60 (3,7) = 47(4,0) = 47 (4,1) = 60 (4,2) = 62 (4,3) = 58 (4,4) = 60 (4,5) = 56 (4,6) = 56 (4,7) = 60(5,0) = 54 (5,1) = 58 (5,2) = 60 (5,3) = 56 (5,4) = 64 (5,5) = 61 (5,6) = 62 (5,7) = 24(6,0) = 63 (6,1) = 59 (6,2) = 58 (6,3) = 60 (6,4) = 56 (6,5) = 64 (6,6) = 56 (6,7) = 64(7,0) = 56 (7,1) = 56 (7,2) = 60 (7,3) = 62 (7,4) = 58 (7,5) = 62 (7,6) = 58 (7,7) = 12

En donde las posiciones sombreadas son las descritas anteriormente.

1.14. MOVIMIENTOS DEL CABALLO EN EL AJEDREZ EN FORMA RECURSIVA

Ahora bien, sería necesario solucionar estos pequeños problemas para lograr que el juego se pueda desarrollar independientemente de la posición inicial en la que se comience el juego. La implementación de este juego para que funcione desde cualquier posición en la que inicie el juego es la siguiente:

/******************************************************************Nombre : caballito1.javaDescripcion : El siguiente programa implementa el juego

: del movimiento del caballo en el ajedrez : de tal suerte que ocupe todas las casillas : Es la mejora a la anterior implementacion : Independiente de la posicion inicial de juego

Tipo: : El programa utiliza java.awt.* y java.applet.* : No Maneja apuntadores, no maneja matrices : Es de tipo Applet : NO ES RECURSIVO



int matriz1[][] = new int[8][8];public void paint(Graphics g){ // boolean h = mover(0,0,1); for(int i = 0; i<8; i++){ for(int j = 0; j<8; j++){ System.out.println("matriz1["+i+"]["+j+"]="+matriz1[i][j]); } // Cierra for interno } // Cierra for externo



} // Cierra funcion paint()

public boolean mover(int filis, int columnis, int contar){if(contar<=64){ if(filis<0) return false; if(filis>7) return false; if(columnis<0) return false; if(columnis>7) return false;

matriz1[filis][columnis] = contar; System.out.println("LF matriz1["+filis+"]

["+columnis+"]="+matriz1[filis][columnis]);

if(filis>columnis) { if(mover(filis+2,columnis-1,contar+1)||mover(filis+1,columnis-

2,contar+1)||mover(filis-1,columnis-2,contar+1)||mover(filis-2,columnis-1,contar+1)||mover(filis-2,columnis+1,contar+1)||mover(filis-1,columnis+2,contar+1) ||mover(filis+1,columnis+2,contar+1) ||mover(filis+2,columnis+1,contar+1))

return true; } // Cierra if(filis>columnis) else{ if(mover(filis-2,columnis+1,contar+1)||mover(filis-

1,columnis+2,contar+1)||mover(filis+1,columnis+2,contar+1)||mover(filis+2,columnis+1,contar+1)||

mover(filis+2,columnis-1,contar+1)||mover(filis+1,columnis-2,contar+1)||mover(filis-1,columnis-2,contar+1)||mover(filis-2,columnis-1,contar+1))

return true; } // Cierra else if(filis>columnis)

return false;

} // cont<=64else return true;

} // Cierra mover

public void init(){ boolean h = mover(1,4,1);} // Cierra funcio init()

} // Cierra class MyApp

Como podrá apreciar estimado lector / estudiante, este ejercicio fue desarrollado implementando la recursividad y funciona para cualquier posición inicial.



1.15. EJERCICIO DE MULTIPLICACIÓN DE MATRICES

Este programa de Java multiplica una matriz con su matriz transpuesta. El tamaño de la matriz inicial es de 3*4 y dicha matriz puede ser digitada por el usuario. Finalmente cuando el usuario presiona el botón con el rótulo "ELEVAR", se multiplica dicha matriz por su transpuesta y el resultado se muestra en el panel derecho.

import java.awt.*;import java.awt.event.*;import java.applet.*;

public class MyApp extends Applet implements ActionListener{

TextField t1[][] = new TextField[3][4];TextField t2[][] = new TextField[4][4];int A[][] = new int[3][4];int B[][] = new int[4][3];int C[][] = new int[4][4];GridLayout g0 = new GridLayout(1,3,2,2);GridLayout g1 = new GridLayout(4,3,2,2);GridLayout g2 = new GridLayout(4,4,2,2);Panel p1 = new Panel();Panel p2 = new Panel();Button b = new Button("ELEVAR");

public void init(){

setLayout(g0);add(p1);add(b);add(p2);p1.setLayout(g1);p2.setLayout(g2);b.addActionListener(this);

for(int j = 0; j<4; j++){ for(int i = 0; i<3; i++){ t1[i][j] = new TextField(" "+i+""+j); p1.add(t1[i][j]); String m_a = t1[i][j].getText().trim(); A[i][j] = Integer.parseInt(m_a); B[j][i] = A[i][j]; }}for(int x = 0; x<4; x++){ for(int y = 0; y<4; y++){ t2[x][y] = new TextField(" "+x +" " +y); p2.add(t2[x][y]); }



} // Cierra for externo} // Cierra init

public void actionPerformed(ActionEvent ev){ System.out.println("Me poncharon"); if(ev.getSource()==b){

for(int j = 0; j<4; j++){ for(int i = 0; i<3; i++){

String aux = t1[i][j].getText().trim(); A[i][j] = Integer.parseInt(aux); B[j][i] = A[i][j];

} // Cierra for interno} // Cierra for externo

for(int x = 0; x<4; x++){ for(int y = 0; y<4; y++){ C[x][y]= 0; String aux = "";

for(int k = 0; k<3; k++){ C[x][y] = C[x][y] + A[k][y]*B[x][k]; aux = aux + "A["+k+"]["+y; aux = aux + "]*B["+x+"]["+k; aux = aux + "]="+(A[k][y]*B[x][k]); System.out.println(aux);

} t2[x][y].setText(""+C[x][y]); aux = "Resultado de C["+x+"]["+y; aux = "]"+C[x][y]; System.out.println(aux);

}} // Cierra for externo

} // Cierra if} // Cierra actionPerformed

} // Cierra applet

El anterior programa, gráficamente muestra una pantalla similar a la siguiente:



Observe amigo lector / estudiante que en la parte izquierda aparecen unas cajas de texto ubicadas en una estructura de 4 filas y 3 columnas. En realidad dichas cajas fueron colocadas en el panel denominado “p1”. De otra parte es interesante que el amigo lector / estudiante observe que en la parte derecha se muestran otras cajas de texto en una estructura de 4 filas y de 4 columnas. Estas cajas fueron pues colocadas en el panel “p2”. Observemos también que en el centro, se encuentra un botón que tiene el rótulo “ELEVAR”. Dicho botón está asociado con la función actionPerdormed, de tal suerte que cuando sea presionado active la ejecución de tal función.

Algunas personas dirán que porqué se crearon dos matrices de objetos tipo TextField y la razón fundamental, es la simple comodidad de programación.

Tengamos en cuenta que en la función INIT() del programa anterior se colocan los objetos de interfaz y esto se hace con el fin de lograr que los objetos aparezcan en el preciso momento en el que se carga el applet, debido a que la función INIT() es la primera que se ejecuta cuando se carga el applet.

De otra parte es bueno que se tenga en cuenta que sin importar lo que el usuario digite en cualquiera de las cajas de texto de la parte izquierda, en todos los casos siempre será tomado dicho valor como un valor tipo String, lo cual obliga lógicamente a que sea convertido a entero mediante las instrucciónes:

for(int j = 0; j<4; j++){ for(int i = 0; i<3; i++){

String aux = t1[i][j].getText().trim(); A[i][j] = Integer.parseInt(aux); B[j][i] = A[i][j];



} // Cierra for interno} // Cierra for externo

En las cuales se puede apreciar que se captura el valor digitado por el usuario y se tiene la precaución de quitarle los espacios con la función “trim()”. Después de lo cual, se convierte dicho valor a entero con la función “parseInt()” de la clase “Integer” y dicho valor es asignado a la matriz “A”. De otra parte como se decía en el enunciado del ejercicio, es importante recordar que no se puede elevar al cuadrado una matriz que no sea cuadrada, razón por la cual se emplea el artificio de multiplicarla por su inversa. Pero antes de multiplicar la matriz A por su matriz inversa es importante calcular los valores de dicha matriz. Esto se logra básicamente con la última instrucción mostrada anteriormente en el ciclo for.

Finalmente podemos pensar que ya se tienen los datos para multiplicar la matriz por su inversa, puesto que en la matriz “A” , ha quedado la matriz original convertida a entera y previamente digitada por el usuario y en la matriz “B” ha quedado la matriz transpuesta que puede multiplicarse obviamente con su matriz original.

Y antes de lanzarnos con el algoritmo en código de la multiplicación propiamente dicha, se harán algunas precisiones que harán que el algoritmo sea lo más claro posible.

En primera medida se dirá que para una matriz como la siguiente:

1 2 34 0 12 2 10 0 1

Que se multiplique con su inversa, es decir con la matriz siguiente:

1 4 2 02 0 2 03 1 1 1

Los términos de la matriz multiplicación se obtienen de la siguiente forma:

1*1+2*2+3*3 1*4+2*0+3*1 1*2+2*2+3*1 1*0+2*0+3*14*1+0*2+1*3 4*4+0*0+1*1 4*2+0*2+1*1 4*0+0*0+1*12*1+2*2+1*3 2*4+2*0+1*1 2*2+2*2+1*1 2*0+2*0+1*10*1+0*2+1*3 0*4+0*0+1*1 0*2+0*2+1*1 0*0+0*0+1*1

Con lo cual podemos observar que se dan las siguientes relaciones teniendo en cuenta las posiciones de filas y columnas que varían y que no varían. Veamos:

Para la matriz A, se tiene que varía la columna de






la primera matriz y permanece la fila en 0.Para la matriz B, se tiene que permanece en todo momento en la columna 0 y la fila es la que varia




Para la matriz A, se tiene que varía la columna de la primera matriz y permanece la fila en 1.Para la matriz B, se tiene que permanece en todo momento en la columna 0 y la fila es la que varia












Es bueno que el amigo lector/ estudiante observe detenidamente los números que se resaltan con negrilla en la anterior tabla para que logre comprender la relación en términos generales que se presenta en mencionada tabla de multiplicación:

El número de sumas que se hacen para obtener el valor de cada una de las posiciones de la matriz multiplicación es igual a tres y de otra parte se cumple que para todas las multiplicaciones de un término de la matriz A, con otro término de la matriz B, se presenta que la columna de la matriz A varía y la fila de la matriz B varía.

Con todo lo dicho anteriormente, podemos concluir que se debe hacer dos ciclor for para ir recorriendo la matriz completamente y por cada posición que se esté analizando se deben hacer tres operaciones de suma



teniendo en cuenta la norma anteriormente deducida. Tal situación se muestra en código como sigue:

for(int x = 0; x<4; x++){ for(int y = 0; y<4; y++){ C[x][y]= 0; String aux = "";

for(int k = 0; k<3; k++){ C[x][y] = C[x][y] + A[k][y]*B[x][k]; aux = aux + "A["+k+"]["+y; aux = aux + "]*B["+x+"]["+k; aux = aux + "]="+(A[k][y]*B[x][k]); System.out.println(aux);

} }} // Cierra for externo

Obviamente el anterior código se debe ejecutar en alguna de las funciones que manejen eventos para permitir que se multipliquen las matrices cuando se presione el botón “ELEVAR” por parte del usuario.

1.16. TALLERES A DESARROLLAR SOBRE MATRICES

Con el fin de lograr que el amigo lector / estudiante profundice sobre las matrices a continuación se presentan los ejercicios que se deben desarrollar para lograr un completo cubrimiento del tema de arreglos bidimensionales:

Recordemos que una matriz por ejemplo de tamaño 6*6 tiene el siguiente aspecto:

Estructura de una matriz de 6*6Columna 1 Columna 2 Columna 3 Columna 4 Columna 5 Columna 6

Fila 1 Poscion(1,1) Poscion(1,2) Poscion(1,3) Poscion(1,4) Poscion(1,5) Poscion(1,6)Fila 2 Poscion(2,1) Poscion(2,2) Poscion(2,3) Poscion(2,4) Poscion(2,5) Poscion(2,6)Fila 3 Poscion(3,1) Poscion(3,2) Poscion(3,3) Poscion(3,4) Poscion(3,5) Poscion(3,6)Fila 4 Poscion(4,1) Poscion(4,2) Poscion(4,3) Poscion(4,4) Poscion(4,5) Poscion(4,6)Fila 5 Poscion(5,1) Poscion(5,2) Poscion(5,3) Poscion(5,4) Poscion(5,5) Poscion(5,6)Fila 6 Poscion(6,1) Poscion(6,2) Poscion(6,3) Poscion(6,4) Poscion(6,5) Poscion(6,6)

También recordemos que las diagonales de una matriz gráficamente son:

DIAGONALES DE UNA MATRIZDD DA

DD DADD DA



DD DADA DD

DA DDDA DD

DA DD

Donde “DA” = Diagonar ascendente y “DD” = Diagonar descendenteCondiciones:En la diagonal ascendenteFila + Columna = máximo valor de indice de la matriz cuadrada

En la diagonal descendenteFila = columna También recordemos que las triangulares de una matriz gráficamente son:

DIAGONALES DE UNA MATRIZ

TS TS TS TS TS TS TSTS TS TS TS TS TS

TI TS TS TS TS TSTI TI TS TS TS TSTI TI TI TS TS TSTI TI TI TI TS TSTI TI TI TI TI TSTI TI TI TI TI TI

Donde “TI” = Triangular inferior y “TS” = Triangular superiorCondiciones:En la triangular superiorFila - columna < 0

En la triangular inferiorFila - columna > 0

Dadas las matrices A y B, siguientes:

Matriz A

37643258

Matriz B

652889867



5

7682927589

482837

85874392

86368355954

85385376279

55

6734636255

53185335486

869835193853

64367564839

572535718769

1) Hallar la suma de la matriz A con la matriz B2) Elevar al cuadrado los elementos de la matriz A que se encuentran en la triangular

superior de la misma.3) Elevar al cubo los elementos de la matriz B que se encuentran en la triangular

inferior de la misma4) Hallar la diferencia de la matriz A con la B y de la matriz B con la A.



5) Hallar la multiplicación de la matriz A con la matriz B.6) Hallar la transpuesta de la matriz A7) Hallar la inversa de la matriz B8) Determinar si la matriz A es escalonada9) Hallar el determinante de la matriz A y el de la matriz B10) Rotar 90° a la derecha a la matriz B



Los siguiente ejercicios muestran gráficamente en que consiste la rotación de una matriz

Matriz original

5353454

35872325

43688764

4899372

Matriz Rotada 90° a la derecha

4433553

8968875

93872334

72642454

Matriz original

56468764

46359974

64853365

Matriz Rotada 90° a la izquierda

64746555

87993345

46358535



86354555

56466486

Matriz original

75748327

45557495

65344744

87433965

Matriz rotada 180° (da igual a la izquierda que a la derecha)

65394387

44473465

95745545

27837475

11) Rotar 180° a la matriz A y a la matriz B12) Rotar a la izquierda 90° la matriz B13) Rotar a la derecha 90° la matriz A14) Encontrar el mayor elemento de la matriz A y de la matriz B y mostrar la posición

en la que se encuentra.15) Encontrar el menor elemento de la matriz A y de la matriz B y mostrar la posición

en la que se encuentra.



2. EJERCICIO DE MATRIZ TIPO ESPIRAL

2.1. VERSIÓN 1

Este programa genera una matriz espiral:

1 1 1 1 1 1 1 1 1 1 1 1 11 2 2 2 2 2 2 2 2 2 2 2 11 2 3 3 3 3 3 3 3 3 3 2 11 2 3 4 4 4 4 4 4 4 3 2 11 2 3 4 5 5 5 5 5 4 3 2 11 2 3 4 5 6 6 6 5 4 3 2 11 2 3 4 5 6 7 6 5 4 3 2 11 2 3 4 5 6 6 6 5 4 3 2 11 2 3 4 5 5 5 5 5 4 3 2 11 2 3 4 4 4 4 4 4 4 3 2 11 2 3 3 3 3 3 3 3 3 3 2 11 2 2 2 2 2 2 2 2 2 2 2 11 1 1 1 1 1 1 1 1 1 1 1 1


public class MyApp extends Applet implements ActionListener{ Button b1 = new Button("OK"); TextArea ta = new TextArea(" "); BorderLayout g1 = new BorderLayout(10,15); String cad = ""; int N = 13; int matrix[][] = new int[13][13];

public void init(){

setLayout(g1);add("North",b1);add("Center",ta);b1.addActionListener(this);

} // Cierra funcion init()



public void actionPerformed(ActionEvent ev){ int mitad = N/2; for(int i=0;i<13;i++){ int cont = 1; int total=1; for(int j=0;j<13;j++){ if(i<=mitad){ matrix[i][j] = j+1; total = i+1; } else{ if(j>mitad){ matrix[i][j]= N-i; total = N-i; } } }// Cierra for medio for(int x=0;x<N;x++){ if(x<total){ matrix[x][i]=x+1;

// matrix[x][i]=200; System.out.println("matriz["+x+"]["+i+"]= "+ matrix[x][i]); } else{ if(x>(N-total)){ matrix[x][i]=N-x; System.out.println("matriz["+x+"]["+i+"]= "+ matrix[x][i]); } else{ matrix[x][i]=total; System.out.println("matrixxz["+x+"]["+i+"]= "+ matrix[x][i]); } } // Cierra else if(j<total) } // Cierra for(int x=0;x<N;x++) System.out.println("re"); } // Cierra for externo

for(int i=0;i<13;i++){ for(int j=0;j<13;j++){ System.out.println("matriz["+i+"]["+j+"]= "+ matrix[i][j]); cad = cad + matrix[i][j]; cad = cad + "\t"; } cad = cad + "\n"; } ta.setText(cad);} // Cierra actionPerformed

} // Cierra clase MyApp

El anterior ejercicio muestra una interfaz similar a la siguiente:



De tal suerte que cuando se presiona el botón con la etiqueta “OK”, se ejecutan las instrucciones que se encuentran en la función “actionPerformed()” y el resultado de dicha ejecución de instrucciones, se muestra al amigo lector / usuario en forma similar a la siguiente:

Obviamente el programa anterior no es óptimo, por cuanto es posible disminuir el número de líneas de código y el número de recursos utilizados por el mismo a fin de conseguir una versión mejor del programa. De deja al amigo lector / estudiante la tarea de verificar por qué el programa anterior produce una matriz tipo espiral y de explicar completamente el programa

2.2. VERSIÓN 2

Como se había comentado en páginas anteriores cuando se mostraban las primeras versiones del programa que implementaba la matriz en espiral, se dijo que era posible optimizar dicho algoritmo. Pues bien, es interesante observar que para desarrollar un algoritmo que solucione el problema de la matriz en espiral, existen múltiples formas de hacerlo y en esta sección se muestra una de las posibles formas de solucionar dicho problema.



En primera medida, se parte diciendo que en una matriz cuadrada se pueden notar que existen dos diagonales notables. La diagonal principal que gráficamente es la siguiente:

1 0 0 0 0 0 00 1 0 0 0 0 00 0 1 0 0 0 00 0 0 1 0 0 00 0 0 0 1 0 00 0 0 0 0 1 00 0 0 0 0 0 1

En la que los elementos de dicha diagonal cumplen la condición:

Fila = Columna

Los elementos que se encuentran debajo de la diagonal principal cumplen la condición: Fila > Columna y los elementos que se encuentran sobre la diagonal principal cumplen la condición: Fila < Columna

Y la diagonal secundaria que gráficamente es la siguiente:

0 0 0 0 0 0 10 0 0 0 0 1 00 0 0 0 1 0 00 0 0 1 0 0 00 0 1 0 0 0 00 1 0 0 0 0 01 0 0 0 0 0 0

En la cual los elementos de dicha diagonal cumplen la condición:

Fila + Columna = N, donde el tamaño de la matriz es N x N

Los elementos que se encuentran debajo de la diagonal secundaria cumplen la condición: Fila + Columna > N y los elementos que se encuentran sobre la diagonal secundaria cumplen la condición: Fila + Columna < N



Ahora bien, después de haber comprendido los conceptos fundamentales de las diagonales y los elementos que se encuentran encima y debajo de dichas diagonales, es posible deducir que los elementos que se encuentran en la siguiente matriz:

0 0 0 0 0 0 10 0 0 0 0 1 00 0 0 0 1 0 00 0 0 1 0 0 00 0 1 0 0 0 00 1 0 0 0 0 01 0 0 0 0 0 0

Deben cumplir las siguientes condiciones:

Fila > =Columna Fila + Columna < =N

Por cuanto se encuentran debajo de la diagonal principal y sobre la diagonal secundaria, incluyendo las diagonales

Para lograr mayor claridad en la aplicación de estos conceptos, a continuación se muestra un programa sencillo que crea una matriz de TextField, los coloca en forma cuadriculada sobre un applet y posteriormente pinta de color turquesa los elementos que se encuentran debajo de la diagonal principal y sobre la diagonal secundaria.

Veamos pues el programa:

import java.awt.*;import java.applet.*;

public class MyApp extends Applet{ TextField matriz[][] = new TextField[13][13];




public void init(){ setLayout(grilla); for(int i = 0; i<13; i++){ for(int j = 0; j<13; j++){ matriz[i][j] = new TextField(); add(matriz[i][j]);

if(i>=j && (i+j)<13){



matriz[i][j].setBackground(Color.cyan); matriz[i][j].setForeground(Color.black); matriz[i][j].setText(""+(j+1)); matriz[i][j].setText(""+(j+1)); } // Cierra if } // Cierra for interno } // Cierra for externo

} // Cierra init()} // Cierra class MyApp

Es importante notar que el valor que se coloca en las cajas de texto es un valor que corresponde al número de la columna, aumentado en uno, debido a que se debe comenzar con el número “1”, pero por la naturaleza de las matrices en los diversos lenguajes de programación, la primera posición es la posición “0”. También es bueno notar que se pinta dicha caja de texto, pero se muestran todas las cajas de texto. Obviamente las que no cumplen la condición no se les asigna número y tampoco se les coloca color de fondo, con lo cual el resultado producido por el anterior programa es similar al siguiente:

Podríamos pensar en hacerle algunas modificaciones al programa anterior con el fin de implementar el programa de las matrices en espiral. Para esto, basta con agregar otras tres condiciones al programa. A continuación se muestran en mayor detalle dichas condiciones.

PARA EL TRIANGULO SUPERIOR (Que es diferente a la triangular superior)

1 1 1 1 1 1 1 1 1 1 1 1 1

0 2 2 2 2 2 2 2 2 2 2 2 0

0 0 3 3 3 3 3 3 3 3 3 0 0

0 0 0 4 4 4 4 4 4 4 0 0 0



0 0 0 0 5 5 5 5 5 0 0 0 0

0 0 0 0 0 6 6 6 0 0 0 0 0

0 0 0 0 0 0 7 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0

Se debe tener en cuenta que se encuentre sobre la diagonal secundaria y sobre la diagonal primaria

if(j>=i && (i+j)<13){ matriz[i][j].setBackground(Color.blue); matriz[i][j].setForeground(Color.white); matriz[i][j].setText(""+(i+1)); }

PARA EL TRIANGULO DERECHO

0 0 0 0 0 0 0 0 0 0 0 0 1

0 0 0 0 0 0 0 0 0 0 0 2 1

0 0 0 0 0 0 0 0 0 0 3 2 1

0 0 0 0 0 0 0 0 0 4 3 2 1

0 0 0 0 0 0 0 0 5 4 3 2 1

0 0 0 0 0 0 0 6 5 4 3 2 1

0 0 0 0 0 0 7 6 5 4 3 2 1

0 0 0 0 0 0 0 6 5 4 3 2 1

0 0 0 0 0 0 0 0 5 4 3 2 1

0 0 0 0 0 0 0 0 0 4 3 2 1

0 0 0 0 0 0 0 0 0 0 3 2 1

0 0 0 0 0 0 0 0 0 0 0 2 1

0 0 0 0 0 0 0 0 0 0 0 0 1

Se debe tener en cuenta que se encuentre sobre la diagonal primaria y debajo de la diagonal secundaria

if(j>=i && (i+j+1)>=13){ matriz[i][j].setBackground(Color.blue); matriz[i][j].setForeground(Color.white); matriz[i][j].setText(""+(13-j)); }



PARA EL TRIANGULO INFERIOR

0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 7 0 0 0 0 0 0

0 0 0 0 0 6 6 6 0 0 0 0 0

0 0 0 0 5 5 5 5 5 0 0 0 0

0 0 0 4 4 4 4 4 4 4 0 0 0

0 0 3 3 3 3 3 3 3 3 3 0 0

0 2 2 2 2 2 2 2 2 2 2 2 0

1 1 1 1 1 1 1 1 1 1 1 1 1

Se debe tener en cuenta que se encuentre debajo de la diagonal secundaria y debajo de la diagonal primaria

if(i>=j && (i+j+1)>=13){ matriz[i][j].setBackground(Color.cyan); matriz[i][j].setForeground(Color.black); matriz[i][j].setText(""+(13-i));

}

Para terminar con esta sección, a continuación se muestra un programa que tiene en cuenta en que posición o área de la matriz se encuentra y de acuerdo a esto, le coloca un valor y un color a dicho “TextArea” de tal suerte que se implemente en forma total el algoritmo para solucionar el problema de la matriz en espiral. Veamos pues el programa completo:

import java.awt.*;import java.applet.*;

public class MyApp extends Applet{ TextField matriz[][] = new TextField[13][13];






public void init(){ setLayout(grilla); for(int i = 0; i<13; i++){ for(int j = 0; j<13; j++){ matriz[i][j] = new TextField(); add(matriz[i][j]);

if(i>=j && (i+j)<13){ matriz[i][j].setBackground(Color.cyan); matriz[i][j].setForeground(Color.black); matriz[i][j].setText(""+(j+1)); matriz[i][j].setText(""+(j+1)); } if(j>=i && (i+j)<13){ matriz[i][j].setBackground(Color.blue); matriz[i][j].setForeground(Color.white); matriz[i][j].setText(""+(i+1)); }

if(i>=j && (i+j+1)>=13){ matriz[i][j].setBackground(Color.cyan); matriz[i][j].setForeground(Color.black); matriz[i][j].setText(""+(13-i)); } if(j>=i && (i+j+1)>=13){ matriz[i][j].setBackground(Color.blue); matriz[i][j].setForeground(Color.white); matriz[i][j].setText(""+(13-j)); } } // Cierra for interno

} // Cierra for externo } // Cierra init()} // Cierra MyApp

Observe amigo lector / estudiante que no todos los TextField fueron coloreados del mismo color, con el ánimo de lograr la mayor comprensión de este programa. A continuación se muestra una gráfica que nos da una idea sobre los resultados que arroja el anterior programa. Veamos:

Obsérvese que en este programa se van creando las cajas de texto y al mismo tiempo se le asigna el valor y se pinta de un color. A diferencia del programa de la sección siguiente que implementa la matriz espiral con matrices, y obviamente puede asignarle un valor a otra posición de la matriz, sin importar si actualmente se encuentre posicionado en dicho elemento de la matriz.



2.3. VERSIÓN 3

Este programa se realiza utilizando una matriz de enteros. Se utilizan dos variables auxiliares de nominadas “izq” y “der” inicializadas en “0” y “N” respectivamente. La idea es hacer un recorrido vertical del vector, tal como muestra la siguiente figura:

La posición de la columna varía hasta que llegue a la mitad de la matriz. Pues bien, si una variable aumenta y la otra disminuye, pues obviamente se harán N/2 ciclos for. Ahora bien, cada ciclo for comienza en un elemento ubicado en la diagonal principal, con lo cual se cumple que:

Fila = Columna

Es decir que dentro del ciclo for, la fila en la que comienza debe ser la columna en la que se encuentra ubicado. La columna está dada por la variable “izq”, es decir que la fila en la que comienza el ciclo for debe ser también la que tiene la variable “izq” y dado que la variable “der” va disminuyendo conforme aumenta la variable “izq”, está tendrá el límite hasta el cual se va a recorrer verticalmente el vector.

Para no ir más lejos con las explicaciones, podemos decir que las siguientes instrucciones:

int izq = 0; int der = N; while (izq < der){ for(int i=izq;i<der;i++){ Espi[i][izq] = izq+1; } izq++; der--; }

Colocan los números {1,2,3,4,5,6} en algunas posiciones de la matriz, tal como muestra la siguiente gráfica:

1 0 0 0 0 0 0 0 0 0 0 0 01 2 0 0 0 0 0 0 0 0 0 0 01 2 3 0 0 0 0 0 0 0 0 0 01 2 3 4 0 0 0 0 0 0 0 0 01 2 3 4 5 0 0 0 0 0 0 0 01 2 3 4 5 6 0 0 0 0 0 0 01 2 3 4 5 6 7 0 0 0 0 0 01 2 3 4 5 6 0 0 0 0 0 0 0



1 2 3 4 5 0 0 0 0 0 0 0 01 2 3 4 0 0 0 0 0 0 0 0 01 2 3 0 0 0 0 0 0 0 0 0 01 2 0 0 0 0 0 0 0 0 0 0 01 0 0 0 0 0 0 0 0 0 0 0 0

El triangulo de la derecha se calcula sacando el complemento. Es decir, si hay una posición “Espi[i][izq]” no su transpuesto, sino su inverso o complemento es la posición “Espi[N-i-1][N-izq-1]”

De forma análoga, las instrucciones siguientes:

int izq = 0; int der = N; while (izq < der){ for(int i=izq;i<der;i++){ Espi[izq][i] = izq+1; } izq++; der--; }


1 1 1 1 1 1 1 1 1 1 1 1 10 2 2 2 2 2 2 2 2 2 2 2 00 0 3 3 3 3 3 3 3 3 3 0 00 0 0 4 4 4 4 4 4 4 0 0 00 0 0 0 5 5 5 5 5 0 0 0 00 0 0 0 0 6 6 6 0 0 0 0 00 0 0 0 0 0 7 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0

Que vendrían a ser los elementos transpuestos con respecto a los elementos del triangulo de la izquierda anteriormente expuesto.

El triangulo de abajo se calcula sacando el complemento. Es decir, si hay una posición “Espi[izq][i]” no su transpuesto,



sino su inverso o complemento es la posición “Espi[N-izq-1][N-i-1]”

Las instrucciones:

int izq = 0; int der = N; while (izq < der){ for(int i=izq;i<der;i++){ Espi[N-i-1][N-izq-1] = izq+1; } izq++; der--; }


0 0 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0 0 0 0 0 0 2 10 0 0 0 0 0 0 0 0 0 3 2 10 0 0 0 0 0 0 0 0 4 3 2 10 0 0 0 0 0 0 0 5 4 3 2 10 0 0 0 0 0 0 6 5 4 3 2 10 0 0 0 0 0 7 6 5 4 3 2 10 0 0 0 0 0 0 6 5 4 3 2 10 0 0 0 0 0 0 0 5 4 3 2 10 0 0 0 0 0 0 0 0 4 3 2 10 0 0 0 0 0 0 0 0 0 3 2 10 0 0 0 0 0 0 0 0 0 0 2 10 0 0 0 0 0 0 0 0 0 0 0 1

Y finalmente las instrucciones:

int izq = 0; int der = N; while (izq < der){ for(int i=izq;i<der;i++){ Espi[N-izq-1][N-i-1] = izq+1; } izq++; der--; }


0 0 0 0 0 0 0 0 0 0 0 0 0



0 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 7 0 0 0 0 0 00 0 0 0 0 6 6 6 0 0 0 0 00 0 0 0 5 5 5 5 5 0 0 0 00 0 0 4 4 4 4 4 4 4 0 0 00 0 3 3 3 3 3 3 3 3 3 0 00 2 2 2 2 2 2 2 2 2 2 2 01 1 1 1 1 1 1 1 1 1 1 1 1

Finalmente, es bueno que el amigo lector / estudiante observe que los cuatro ciclos while y for expuestos son idénticos, excepto en la línea que asigna el valor. Con ello se puede notar que es posible simplificar el algoritmo aún más, incluyendo las cuatro líneas expuestas anteriormente juntas en el mismo ciclo. Con lo cual la función, quedaría como se muestra a continuación:

int izq = 0; int der = N; while (izq < der){ for(int i=izq;i<der;i++){ //Triangulo de la izquierda Espi[i][izq] = izq+1; // Triangulo de arriba Espi[izq][i] = izq+1; // Triangulo de abajo Espi[N-izq-1][N-i-1] = izq+1; // Triangulo de la derecha Espi[N-i-1][N-izq-1] = izq+1; }//Cierra for(int i=izq;i<der;i++) izq++; der--; } // Cierra while

y produciría el resultado:

1 1 1 1 1 1 1 1 1 1 1 1 11 2 2 2 2 2 2 2 2 2 2 2 11 2 3 3 3 3 3 3 3 3 3 2 11 2 3 4 4 4 4 4 4 4 3 2 11 2 3 4 5 5 5 5 5 4 3 2 11 2 3 4 5 6 6 6 5 4 3 2 11 2 3 4 5 6 7 6 5 4 3 2 11 2 3 4 5 6 6 6 5 4 3 2 11 2 3 4 5 5 5 5 5 4 3 2 11 2 3 4 4 4 4 4 4 4 3 2 11 2 3 3 3 3 3 3 3 3 3 2 11 2 2 2 2 2 2 2 2 2 2 2 11 1 1 1 1 1 1 1 1 1 1 1 1



Para terminar se muestra al lector el programa completo más óptimo para solucionar el problema de la matriz en espiral. Veamos pues:


public class MyApp extends Applet implements ActionListener{ int Espi[][]=new int [13][13]; Button b1=new Button("ESPIRAL"); TextArea ta=new TextArea ( ); Panel p1 = new Panel(); BorderLayout g1=new BorderLayout (1,2); final int N=13; int fila=1; int cont1=0; int i=0;

public void init(){ setLayout(g1); setBackground(Color.yellow); add("Center", ta); add("North", p1); p1.add(b1); b1.addActionListener(this); b1.setBackground(Color.green); } // Cierra init public void actionPerformed(ActionEvent ev) { if (ev.getSource() == b1){ int izq = 0; int der = N; while (izq < der){ for(int i=izq;i<der;i++){ //Triangulo de la izquierda Espi[i][izq] = izq+1; // Triangulo de arriba Espi[izq][i] = izq+1; // Triangulo de abajo Espi[N-izq-1][N-i-1] = izq+1; // Triangulo de la derecha Espi[N-i-1][N-izq-1] = izq+1; }//Cierra for(int i=izq;i<der;i++) izq++; der--; } // Cierra while String cad10= ""; for(int i=0;i<N;i++){ for(int j=0;j<N;j++){ cad10 = cad10 + Espi[i][j]; cad10 = cad10 + "\t"; } // Cierra for interno



cad10 = cad10 + "\n"; } // Cierra for externo ta.setText(cad10); } // if (ev.getSource() == b1) } // Cierra ActionPerformed } // Cierra MyApp

Que muestra una interfaz similar a la siguiente:

En la cual el usuario puede presionar el botón con el rótulo “ESPIRAL” y se obtiene un resultado similar al siguiente:



TABLA DE CONTENIDO

1. PRIMEROS EJERCICIOS CON MATRICES_________________________________101.1. CREANDO INICIANDO E IMPRIMIENDO MATRIZ TIPO INT Y NO DINAMICA____________________________________________________________101.2. CREANDO INICIANDO E IMPRIMIENDO MATRIZ TIPO INT Y DINAMICA______________________________________________________________________111.3. PROGRAMA QUE PIDE CADA UNO DE LOS VALORES DE UNA MATRIZ_131.4. PROGRAMA QUE CALCULA LA TRANSPUESTA DE UNA MATRIZ_______161.5. MATRIZ MAGICA__________________________________________________221.6. MATRIZ DE TEXTFIELD____________________________________________261.7. DETALLANDO LAS DIAGONALES DE UNA MATRIZ___________________291.8. TRIANGULARES Y DIAGONALES DE UNA MATRIZ____________________321.9. PROGRAMA QUE COLOCA 15 MINAS EN UNA MATRIZ________________331.10. PROGRAMA QUE COLOCA UN BUSCAMINAS DESCUBIERTO__________361.11. PROGRAMA QUE IMPLEMENTA UN BUSCAMINAS___________________401.12. PROGRAMA QUE ENSEÑA A DIVIDIR_______________________________451.13. PROGRAMA QUE MUESTRA LOS MOVIMIENTOS DEL CABALLO EN EL AJEDREZ_____________________________________________________________491.14. MOVIMIENTOS DEL CABALLO EN EL AJEDREZ EN FORMA RECURSIVA______________________________________________________________________561.15. EJERCICIO DE MULTIPLICACIÓN DE MATRICES_____________________581.16. TALLERES A DESARROLLAR SOBRE MATRICES_____________________63

2. EJERCICIO DE MATRIZ TIPO ESPIRAL___________________________________692.1. VERSIÓN 1________________________________________________________692.2. VERSIÓN 2________________________________________________________712.3. VERSIÓN 3________________________________________________________78

TABLA DE CONTENIDO__________________________________________________88



Pais: Colombia

Teléfono principal: 2780615

Teléfono auxiliar: 2004217

Dirección de Correo Permanente: [email protected]

Dirección de Correo Trabajo: [email protected]

Dirección física: Facultad Tecnológica – Universidad Distrital

Sitio Personal: Gemini.udistrital.edu.co/comunidad/profesores/lwanumen

Cualquier parecido de esta obra con alguna existente es pura casualidad, por cuanto el desarrollo de la misma fue inédita y personal.

Enciclopedia Conociendoã Luis Felipe Wanumen SilvaCopyright Enero de 2004ISBN En proceso de registroEdición autorizada para venta en ColombiaImpreso en Colombia – Printed in Colombia

Derechos ReservadosLos derechos de publicación en cualquier lengua de cualquier tomo de la Enciclopedia Conociendo, no han sido transferidos a editor alguno. El editor solamente está autorizado para imprimir 1000 ejemplares y vendérselos únicamente al autor.

Prohibida su reproducción parcial o total por cualquier medio sin permiso escrito del propietario de los derechos de copyright

NOTA IMPORTANTEEl autor no será jurídicamente responsable por daños y perjuicios causados en datos, archivos, información o hardware por el uso directo o indirecto ya sea correcto o incorrecto del presente material.

Carátula, arte y diseño:Luis Felipe Wanumen Silva

ImpresiónEditorial Kimpres Ltda.



Tels: 260 1680 – 4 13 6884


JAVAMATRICESTOMOLXI

Documents

Transcript of JAVAMATRICESTOMOLXI