lunes, 14 de noviembre de 2011

Deitel_Java_7.21 (Lenguaje Logo en Java)


Saludo en Logo
7.21 (Gráficos de Tortuga) El lenguaje logo hizo famoso el concepto de los gráficos de tortuga. Imagine a una tortuga mecánica que camina por todo el cuarto, bajo el control de una aplicación en Java. La tortuga sostiene una pluma en una de dos posiciones, arriba o abajo. Mientras la pluma está abajo, la tortuga va trazando figuras a medida que se va moviendo, y mientras la pluma está arriba, la tortuga se mueve alrededor libremente sin trazar nada. En este problema usted simula la operación de la tortuga y creará un blog de dibujo computarizado.
Utilice un arreglo de 20 por 30 llamado piso que se inicialice con ceros. Lea los comandos de un arreglo que los contenga. Lleve el registro de la posición actual de la tortuga en todo momento, y si la pluma se encuentra arriba o abajo. Suponga que la tortuga siempre empieza en la posición (0,0) del piso con su pluma hacia arriba. El conjunto de comandos de la tortuga que su aplicación debe procesar se muestra a continuación.

1 Pluma arriba
2 Pluma abajo.
3 Gira a la derecha.
4 Gira a la izquierda.
5 Avanza.
6 Imprime el arreglo.
9 Centinela (Fin de datos)
_____________________________________________________________________________________
SOLUCIÓN:
Este programa también aparece resuelto en C++ en este blog. Esta versión en Java me ha resultado más fácil de escribir. Es posible añadir más comandos y hacer este código más interesante. Como consejo si lo que quiere es escribir este código, lo primero que debe hacerse es asegurarse que la tortuga gira correctamente hacia la derecha y hacia la izquierda. Para esto es necesario saber cual es la dirección de la tortuga, esto lo hace el método Dirección. He usado las letras k, l, j, h para referirme a "arriba", "derecha", "abajo" y "izquierda" respectivamente, porque esas son las teclas de desplazamiento del editor Vi. Una vez que la tortuga gira correctamente es necesario hacerla avanzar y retroceder en líneas horizontales, y después en verticales. Finalmente he agregado la opción imprimir comando para que el usuario sepa en todo momento qué se espera de él.

Este código debe guardarse con el nombre UsaLogo.java

public class UsaLogo
 {            // Abre clase Logo
 
 public static void main(String args[])
 {     // Abre main
 Logo miObjeto = new Logo();
 miObjeto.Administrador_Logo();
 }      // Cierra main
 }            // Cierra clase Logo


Este código debe guardarse con el nombre Logo.java

import java.util.Scanner;

 public class Logo
 {   // Abre clase Logo
 Scanner entrada = new Scanner(System.in);
 private int Direccion = 'l';
 private int Pluma = 1; // La pluma inicia hacia arriba
 private int ANCHO_TABLERO = 90;
 private int ALTO_TABLERO = 40;
 private int Tablero[][] = new int[ALTO_TABLERO + 1][ANCHO_TABLERO + 1];
 private int X = 1;  // La tortuga inicia en la parte superior
 private int Y = 1;  // izquierda
 

 public void Administrador_Logo()
 {       // Abre metodo Administrdor_Logo

 int comando;

 
 System.out.println("\nPor favor introduzca comando: ");
 comando = entrada.nextInt();

 while ( 0 != comando )
 {      // Abre while 
 switch (comando)
 {   // Abre switch
 case 1:
 System.out.println("\nLa pluma esta hacia arriba.");
 Pluma = 1;
 break;
 case 2:
 System.out.println("\nLa pluma esta hacia abajo.");
 Pluma = 2;
 break;

 case 3:
 System.out.println("\nSe gira a la derecha.");
 switch (Direccion)
 {  // Abre switch anidado
 case 'k':
 Direccion = 'l';
 break;
 case 'l':
 Direccion = 'j';
 break;
 case 'j':
 Direccion = 'h';
 break;
 case 'h':
 Direccion = 'k';
 break;
 default:
 System.out.println("\nDireccion Invalida");
 break; 
 }  // Cierra switch anidado
 break;

 case 4:
 System.out.println("\nSe gira a la izquierda");
 switch (Direccion)
 {     // Abre switch
 case 'k':
 Direccion = 'h';
 break;
 case 'h':
 Direccion = 'j';
 break;
 case 'j':
 Direccion = 'l';
 break;
 case 'l':
 Direccion = 'k';
 break;
 default:
 System.out.println("\nDireccion invalida.");
 break;
 }     // Cierra switch
 break;

 case 5:
 Avanza();
 break;
 case 6:
 Imprimir_Tablero();
 break;
 case 7:
 System.out.printf("\nLa direccion de la tortuga es: %c", Direccion);
 System.out.printf("\nLa posicion de la tortuga es X = %d, Y = %d\n", X, Y);
 break;
 case 8:
 System.out.println("\nLos comandos son:");
 Imprimir_Comandos();
 break;

 default:
 System.out.println("\nComando invalido.\n");
 break;
  
 }   // Cierra switch
 System.out.print("\nPor favor introduzca comando, 0 para terminar, ");
 System.out.print("8 para imprimir los comandos.\n");
 comando = entrada.nextInt();
 
 }      // Cierra while
 }       // Cierra metodo Administrador_Logo

 ////////////////////////////////////////////////
 // METODO AVANZA
 ///////////////////////////////////////////////
 
 public void Avanza()
 {        // Abre metodo Avanza
 int casillas_avanza;
 System.out.println("\nPor favor introduzca las posiciones que avanzara la tortuga: ");
 casillas_avanza = entrada.nextInt();
 switch (Direccion)
 {     // Abre switch
 case 'l':
 
 if ( X + casillas_avanza <= ANCHO_TABLERO)
 
 { // Abre if 
 if ( 1 != Pluma) // Si la pluma esta hacia abajo
 for ( int i = X; i <= X + casillas_avanza; i++ )
 Tablero[Y][i] = 1; 

 // El cambio en X se hace al final 
 // para no afectar a la variable que de hecho aparece
 // en el ciclo for anterior
 X += casillas_avanza;
 
 }  // Cierra if
 else
 {  // Abre else
 if ( 1 != Pluma )
 for ( int j = X; j <= ANCHO_TABLERO; j++ )
 Tablero[Y][j] = 1;
 X = ANCHO_TABLERO;
 // De nuevo, el cambio en X se hace al final, de lo contrario
 // Se alteraria la misma variable que aparece en el diclo for
 }  // Cierra else
 break;

 case 'h':
 if ( 1 <= X - casillas_avanza )
 {  // Abre if
 if ( 1 != Pluma )
 for ( int i = X; i >= X - casillas_avanza; i--)
 {  // Abre for
 Tablero[Y][i] = 1; 
 }  // Cierra for
 
 X -= casillas_avanza;
 }  // Cierra if 
 else  // es decir, si X - casillas_avanza < 1
 {    // Abre else
 if ( 1 != Pluma )
 for ( int i = X; i >= 1; i--)
 Tablero[Y][i] = 1;

 X = 1; 
 }    // Cierra else
 break;

 case 'j':
 if ( Y + casillas_avanza <= ALTO_TABLERO)
 
 { // Abre if 
 if ( 1 != Pluma) // Si la pluma esta hacia abajo
 for ( int i = Y; i <= Y + casillas_avanza; i++ )
 Tablero[i][X] = 1; 

 // El cambio en Y se hace al final 
 // para no afectar a la variable que de hecho aparece
 // en el ciclo for anterior
 Y += casillas_avanza;
 
 }  // Cierra if
 else
 {  // Abre else
 if ( 1 != Pluma )
 for ( int j = Y; j <= ALTO_TABLERO; j++ )
 Tablero[j][X] = 1;
 Y = ALTO_TABLERO;
 // De nuevo, el cambio en X se hace al final, de lo contrario
 // Se alteraria la misma variable que aparece en el diclo for
 }  // Cierra else
 break;
 
 case 'k':

 if ( 1 <= Y - casillas_avanza )
 {  // Abre if
 if ( 1 != Pluma )
 for ( int i = Y; i >= Y - casillas_avanza; i--)
 {  // Abre for
 Tablero[i][X] = 1; 
 }  // Cierra for
 
 Y -= casillas_avanza;
 }  // Cierra if 
 else  // es decir, si X - casillas_avanza < 1
 {    // Abre else
 if ( 1 != Pluma )
 for ( int i = Y; i >= 1; i--)
 Tablero[i][X] = 1;

 Y = 1; 
 }    // Cierra else
 break;

 default:
 System.out.println("\nDireccion equivocada.");
 break; 
 }    // Cierra switch  
 }        // Cierra metodo Avanza 

 ///////////////////////////////////////////////
 // IMPRIMIR_TABLERO 
 ///////////////////////////////////////////////

 public void Imprimir_Tablero()
 {    // Abre metodo Imprimir_Tablero

 System.out.printf("\nEl Tablero es de %d de ancho X %d de alto\n", ANCHO_TABLERO, ALTO_TABLERO);
 // Imprime contorno superior del tablero
 System.out.printf("|");
 for ( int n = 1; n <= ANCHO_TABLERO; n++ )
 System.out.printf("-");

 System.out.printf("|\n");
 // Imprime el tablero
 for ( int i = 1; i <= ALTO_TABLERO; i++ )
 {   // Abre for
 // Escribe contorno derecho
 System.out.printf("|");
 // Imprime renglon
 for ( int j = 1; j <= ANCHO_TABLERO; j++ )
 {  // Abre for anidado
 if ( 0 == Tablero[i][j])
 System.out.printf(" ");
 else
 System.out.printf("*");
 }      // Cierra for anidado
 System.out.printf("|%d\n", i);
 }  // Cierra for 

 // Imprime contorno inferior del tablero
 System.out.printf("|");
 for ( int m = 1; m <= ANCHO_TABLERO; m++ )
 System.out.printf("-");
 System.out.printf("|");
 
 
 }    // Cierra metodo Imprimir_Tablero

 ///////////////////////////////////////////////
 // METODO IMPRIMIR_COMANDOS
 ///////////////////////////////////////////////

 public void Imprimir_Comandos()
 {     // Abre metodo Imprimir_Comandos
 System.out.println("\n1 Pluma hacia arriba.");
 System.out.println("2 Pluma hacia abajo.");
 System.out.println("3 Gira a la derecha.");
 System.out.println("4 Gira a la izquierda.");
 System.out.println("5 Avanza.");
 System.out.println("6 Imprime Tablero.");
 System.out.println("7 Imprime Posicion y Direccion.");
 System.out.println("8 Imprime comandos.");
 }     // Cierra metodo Imprimir_Comandos

 
 }   // Cierra clase Logo

10 comentarios:

  1. No sabes como me ayudo este programa... ahora tendre que hacer el mio. Muchas Gracias

    ResponderEliminar
  2. Buen código.
    Te podrías haver ahorrado algunas instrucciones del código, por ejemplo en el caso que Avanza hacia la derecha 'l' podría quedar así.
    http://pastebin.com/Xeqa4NZw

    ResponderEliminar
  3. oye disculpa no tienes aun código de graficas así como un histograma ??

    te agradecería mucho si lo tuvieras gracias

    ResponderEliminar
  4. me salen errores al escribir una palabra

    ResponderEliminar
    Respuestas
    1. ¿Errores de compilación, de lógica? Si me dices tal vez lo pueda mejorar. Gracias.

      Eliminar
  5. guarde clase logo y luego la usalogo no me corre :(

    ResponderEliminar

Related Posts Plugin for WordPress, Blogger...