Universidad de Costa Rica
Escuela de Ciencias de la
Computación e Informática
Profesor Adolfo Di Mare
CI-0202
II Semestre 2009
[<=] [home] [<>] [\/] [=>]
CI-0202 Principios de Informática

Tarea #8 [solución]

Remolvo en Espiral

      Use como base la implementación que se muestra al final de este documento para producir un programa que muestre, paso a paso, como se llena en espiral una matriz que respeta las proporciones 4x3.

      En el recuadro se muestra un bosquejo del programa construido de acuerdo al patrón Modelo-Vista-Controlador. Su trabajo consisten en entregar primero una versión del programa que sí compila, y después el programa completo. Por ejemplo, lo usual es que cada clase esté en un archivo aparte, pero además es necesario declarar "public" todo lo que se usa en otra clase. La lógica también está medio chueca (pues tiene errores introducidos a propósito con el fin de que usted se divierta...).

      Para esta tarea programada usted debe enviarme todos estos archivos:

  1. Todos los archivos de implementación, con extensión .java
  2. Todos los archivos con la documentación Javadoc, en formato HTML.
  3. CARNET.docx

Consulta:
Profe: Yo no pude hace la primera parte de la tarea, pero veo que usted ya subió la solución de mis compañeros a la red. ¿Tengo que usar mi propia solución o puedo usar alguna de las soluciones de mis compañeros?
Respuesta:
Pueden usar cualquier solución. Escojan la que mejor les sirva.
Consulta:
Profe: ¿Cómo hago la segunda parte de la tarea?
Respuesta:
Se vale usar como base cualquier solución a la primera parte para producir un programa que muestre cómo se rellena la matriz en espiral. El primer paso puede ser definir cómo ser verá la matriz paso a paso. Una forma es imprimirla como se ve en la tarea programada de la caída matricial. Si la espiral final tiene 12 pasos, habría que imprimir 12 versiones de la matriz, cada una más avanzada que la anterior:
1  2   3    4    5    6    7    8    9   10   11   12
X XX XXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX
                 X    X    X    X    X X  X XX X XXXX
                      X   XX  XXX XXXX XXXX XXXX XXXX
Consulta:
Profe: ¿Cómo obtengo la documentación Javadoc?
Respuesta:
La forma más rápida de obtenerla abrir todos los archivos y luego es pulsar el botón [Javadoc] que aparece en el menú de DrJava. Perderán muchos muchos puntos si falta la especificación para cualquier método o clase.
Otra forma de lograr lo mismo es buscar en la carpeta "bin" que está dentro de "jdk_version" en el directorio "Java" adonde está instalado el JDK y el JRE:
X:\DIR\SubDir> dir "%ProgramFiles%\Java\*.exe" /s
Tiempo de entrega: 10 días
Entregue un versión completa de todos los archivos de su programa en la primera fecha, y luego entregue el programa completo en la segunda fecha.
Segunda etapa: 7 días
Modalidad: En parejas

[mailto:] Entrega de Tareas

// Remolvo.java  (c) 2009 adolfo@di-mare.com

/**
    @(#)Remolvo.java 2009
    Muestra cómo se llena un tablero en espiral.

    @author Adolfo Di Mare <adolfo@di-mare.com>
*/

/* Gestiona eventos y usa los algoritmos que implementan el programa. */
class Controlador {
    /** Programa principal. */
    public static void main( String args[] ) {
        // Pide el tamaño del juego
        int dim = Interfaz.obtengaDimension();
        Tablero T(dim);        // Este es el tablero
        Reina f = new Reina(); // esta es la única ficha
        int pos[] = { 0 , 0 }; // posición actual en el tablero
        T.set(pos[0],pos[1], f);
        // Camina la ficha es espiral dentro del tablero
        do {
            Interfaz.grabeTablero( T );
        } while ( Algoritmo.Espiral(T,pos) );
    }
}

/** Esta clase contiene la lógica y los algoritmos del programa. */
class Algoritmo {
    /** Mueve la ficha actual en forma espiral dentro del tablero {@code T}.
        La ficha debe estar en la posición {@code (pos[0],pos[])}.
        Al ser movida, otra copia de la ficha queda en la siguiente casilla.
        Nunca mueve la ficha a una casilla ya ocupada.
        Retorna {@code true} si pudo mover la ficha.
     */
    public static boolean Espiral( Tablero T , int pos[] ) {
        Ficha = T.getFicha( pos[0],pos[1] );
        if ( f==null ) {
            return false; // casilla vacía, no hay nada que hacer
        }
        T.mueveArriba( f );
        if ( !( (f.getHor()==pos[0]) && (f.getHor()==pos[0]) ) ) {
            pos[0] = f.getHor();
            pos[1] = f.getVer()
            return true; // la pudo mover horizontal
        }
        T.mueveAbajo( f );
        if ( !( (f.getHor()==pos[0]) && (f.getHor()==pos[0]) ) ) {
            return true;
        }
        T.mueveIzq( f );
        if ( !( (f.getHor()==pos[0]) && (f.getHor()==pos[0]) ) ) {
            return true;
        }
        T.mueveDer( f );
        if ( !( (f.getHor()==pos[0]) && (f.getHor()==pos[0]) ) ) {
            return true;
        }
        return false; // no pudo mover la ficha
    }
}

/** Clase que sirve para interactuar con el usuario del programa.
  * Se encarga de leer/desplegar datos.
  */
class Interfaz {
    /** Lee un número que representa la dimensión del tablero. */
    int obtengaDimension() {
        System.out.print( "Ingrese el tamaño del juego [0..20]" );
        return 6;
    }
    /** Graba el tablero completo actual en modo caracter. */
    void grabaTablero( Tablero T ) {
        final int N = T.alto();
        final int M = T.ancho();
        for ( int i=0; i<N; ++i ) {
            for ( int j=0; j<N; ++j ) {
                char ch = T.getFicha(i,j).nombre().charAt(0);
                ch = Character.toUpper(ch);
                System.out.print( ch );
                // ... truena si get() retorn "null"
            }
            System.out.println();
        }
    }
}

/** Tablero del juego Remolvo. */
class Tablero {
    /** Multiplicador proporcional del eje vertical del tablero. */
    private static final int V = 3;
    /** Multiplicador proporcional del eje horizontal del tablero. */
    private static final int H = 4;
    /** La dimensión del tableros siempre es H*m_dim x V*m_dim. */
    private int m_dim;
    /** Tablero de fichas. */
    private Ficha m_MAT[][];

    void Tablero() { m_dim = 0; }
    
    void Tablero( int dim ) { setDim(dim); }

    void set( int i , int j , Ficha f ) {
        m_MAT[i][j] = f;
        f.setHor(i);
        f.setVer(j);
        f.setTablero( this );
    }

    void setDim( int dim ) {
        m_dim = ( dim > 0 ? dim : -dim );
        if ( m_dim==0 ) {
            m_MAT = null; // nada de tablero
        }
        else {
            m_MAT = new Ficha[V*m_dim][H*m_dim];
        }
    }
    /** Cantidad de posiciones en el eje vertical del tablero. */
    int ancho() { return V*m_dim; }
    /** Cantidad de posiciones en el eje horizontal del tablero. */
    int alto()  { return H*m_dim; }

    /** Mueve la ficha hacia arriba en su tablero. */
    void mueveArriba( Ficha f ) {
        if ( f.getTablero() != this ) {
            return; // esa ficha no está en este tablero
        }
        int i = f.getHor();
        int j = f.getVer();
        if ( ! ( (i<V*m_dim) && (j<V*m_dim) ) ) {
            return; // ficha posicionada fuera del tablero
        }
        if ( m_MAT[i][j] != f ) {
            return; // ficha mala que no marca su sitio en el tablero
        }
        if ( i>0 ) {
        //  m_MAT[i][j] = null; // la ficha queda en 2 posiciones
            i--;
            if ( m_MAT[i][j]==null ) {
                m_MAT[i][j] = f;
                f.setHor( i );
            }
        }
    }
    /** Mueve la ficha hacia abajo en su tablero. */
    void mueveAbajo( Ficha f ) {}
    /** Mueve la ficha hacia la izquierda en su tablero. */
    void mueveIzq( Ficha f ) {}
    /** Mueve la ficha hacia la derecha en su tablero. */
    void mueveDer( Ficha f ) {}
}

/** Ficha abstracta del del juego Remolvo. */
abstract class Ficha {
    /** Tablero en que está la ficha. */
    Tablero m_MAT;
    /* Posición horizontal de la ficha. */
    int m_hor;
    /* Posición vertical de la ficha. */
    int m_ver;

    Tablero getTablero() { return m_TABLERO; }
    /** Retorna el nombre de la ficha. */
    /** Retorna la posición horizontal de la ficha en el tablero. */
    int getHor() { return m_hor; }
    /** Retorna la posición vertical de la ficha en el tablero. */
    int getVer() { return m_ver; }
    /** Cambia a {@code h} la posición horizontal de la ficha en el tablero. */
    int setHor(int h) { return m_hor = h; }
    /** Cambia a {@code v} la posición vertical de la ficha en el tablero. */
    int setVer(int v) { return m_ver = v; }
    /** Retorna el tablero en el que está posicionada la ficha. */
    String nombre();
}

class Peon extends Ficha {
    String nombre() { return "Peón"; }
}

class Reina extends Ficha {
    String nombre() { return "Reina"; }
}

// EOF: Remolvo.java

Soluciones

[mailto:] Adolfo Di Mare <adolfo@di-mare.com>.
Copyright © 2009
Derechos de autor reservados © 2009
[home] <> [/\]