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

Tarea #2 [solución]

Inversión de los valores de un vector

      Complete la implementación del método alVerres() para que funcione de acuerdo a su especificación. Note que el vector R[] siempre queda lleno de ceros pues el programa nunca calcula el valor del vector invertido porque falta el ciclo en que se rellena el valor de R[] con base al valor del vector V[].

      Además, incluya más datos de prueba para el métdodo testAlVerres(), pues los que tiene no son suficientes. Recuerde usar DrJava como platforma de desarrollo. También recuerde pulsar el botón [Test] para activar el programa usando pruebas tipo JUnit (es más complicado ejecutar el programa activando el botón "run"). Recuerde: agregue su algoritmo dentro del bloque marcado "{ *** RELLENE CON SU ALGORITMO *** }"... ¡No modifique ninguna otra parte del programa!

      Para esta tarea programada ustedes debe enviarme estos archivos:

  1. TestAlVerres.java
  2. CARNET.docx

      En el documento CARNET.docx deben describir su experiencia de aprendizaje para completar esta tarea. Explique qué hizo, cómo lo hizo y por qué lo hizo. En especial, es importante que mencionen por qué escogieron las instrucciones que incluyeron y cuáles fueron las dificultades que enfrentaron.

Consulta:
Profe: Podría explicarme de una manera mas concreta qué tengo que hacer en esta tarea.
Respuesta:
  1. Hay que agregarle el ciclo de inversión al método alVerres() donde está el cuadrado "RELLENE CON SU ALGORITMO".
  2. Hay que agregar pruebas tipo assertTrue() en testAlVerres() para completar por lo menos 20 pruebas.
  3. Las pruebas que aparecen en testAlVerres() no deben ser repetitivas y deben mostrar diferentes datos de entrada. Para eso pueden usar nuevos vectores además de los que aparecen en la implementación de la clase TestAlVerres.

      Cuando el programa funcione, la barrita "Test Progress" del DrJava se pondrá toda verde . 

/**
    @(#)TestAlVerres.java 2010,2012
    adolfo@di-mare.com
    Datos de prueba para {@code alVerres()}.

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

import junit.framework.*;
import java.util.Random; // Clases para números aleatorios

/** Datos de prueba para el método {@code alVerres()}. */
public class TestAlVerres extends TestCase {

    /** Retorna una copia de {@code V[]} con los valores invertidos.
        <li> alVerres( {'a','b','c'} ) retorna {'c','b','a'} </li>
    */
    public static char[] alVerres( char V[] ) {
        if ( V == null ) {
            return null;
        }
        int size = V.length;          // dimensión de V[] y de R[]
        char R[] = new char[ size ];  // R[] es la copia invertida de V[]
        int i, j;                     // indices para V[] && R[]
        {    
            /******************************\
            *                              *
            *   RELLENE CON SU ALGORITMO   *
            *                              *
            \******************************/
        //  System.out.println( "R" + vString(R) );
        }
        return R;
    }

    static char Vbcdefgh[] = { 'b','c','d','e','f','g','h' };
    static char Vhgfedcb[] = { 'h','g','f','e','d','c','b' };

    static char Vabababa[] = { 'a','b','a','b','a','b','a' };

    static char Vunos[]    = { '1','1','1','1','1','1','1' };

    static char Abbbb[]    = { 'b','b','b','b' };
    static char Aabcd[]    = { 'a','b','c','d' };
    static char Adcba[]    = { 'd','c','b','a' };

    static char Aba[]      = { 'b','a' };
    static char Aab[]      = { 'a','b' };
    static char Ab[]       = { 'b' };

    static char Ajjabcd[]  = { 'j','j','a','b','c','d' };
    static char Adcba99[]  = { 'd','c','b','a','j','j' };

    /** Prueba el método {@code alVerres()} nunca son modificados. */
    public void testAlVerres() {
        assertTrue( sonIguales( Vbcdefgh, alVerres(Vhgfedcb) ) );
        assertTrue( sonIguales( Vabababa, alVerres(Vabababa) ) );
        assertTrue( sonIguales( Vunos,    alVerres(Vunos)    ) );
        assertTrue( sonIguales( Abbbb,    alVerres(Abbbb)    ) );
        assertTrue( sonIguales( Aabcd,    alVerres(Adcba)    ) );
        assertTrue( sonIguales( Aab,      alVerres(Aba)      ) );
        assertTrue( sonIguales( Ab,       alVerres(Ab)       ) );
        assertTrue( sonIguales( Ajjabcd,  alVerres(Adcba99)  ) );

        assertTrue( sonIguales( Vhgfedcb, alVerres(Vbcdefgh) ) );
        assertTrue( sonIguales( Adcba,    alVerres(Aabcd)    ) );
        assertTrue( sonIguales( Aba,      alVerres(Aab)      ) );
        assertTrue( sonIguales( Adcba99,  alVerres(Ajjabcd)  ) );

        assertTrue(   sonIguales( null,     alVerres(null)   ) );
        assertTrue( ! sonIguales( Adcba99,  alVerres(null)   ) );

        Random rand = new Random( 213 );
        for ( int k=6; k<=17; ++k ) {
            char V[] = new char[k]; assertTrue( V.length == k );
            for ( int i=0; i<k; ++i ) {
                V[i] = (char)('0'+rand.nextInt(10)); // rellena con dígitos aleatorios
            }
            String Vstr = "V" + vString( alVerres(V) );
            String Rstr = "V" + vString( alVerresRecursivo(V) );
            String msg  = Vstr + " != " + Rstr;
            // compara el valor calculado por el alumno con el valor correcto
            assertTrue( msg, sonIguales( alVerres(V), alVerresRecursivo(V) ) );
        }
    }

    /** Verifica que los vectores {@code L[]} y {@code R[]} tengan exactamente los mismos valores */
    public static boolean sonIguales( char L[] , char R[] ) {
        if ( L == null && R == null ) {
            return true; // ambos están vacíos
        }
        else if ( L == null || R == null ) {
            return false; // solo uno está vacío
        }
        else if ( L.equals(R) ) {
            return true; // referencian el mismo objeto
        }
        if ( L.length != R.length ) {
            return false;
        }
        for ( int i=0; i<L.length; ++i ) {
            if ( L[i] != R[i] ) {
                return false; // este no calza
            }
        }
        return true;
    }

    /** Paso intermedio en la implementación recursiva de {@code alVerresRecursivo( char V[] )}.
    */
    public static void alVerresRecursivo( int i, char V[], char R[] ) {
        if ( i==V.length ) {
            return;
        }
        R[i] = V[ V.length-i-1 ];
        alVerresRecursivo( i+1,V,R );
        return;
    }

    /** Retorna una copia de {@code V[]} con los valores invertidos.
        <li> alVerres( {'a','b','c'} ) retorna {'c','b','a'}
    */
    public static char[] alVerresRecursivo( char V[] ) {
        if ( V ==null ) {
            return null;
        }
        int size = V.length;         // dimensión de V[] y de R[]
        char R[] = new char[ size ]; // R[] es la copia invertida de V[]
        alVerresRecursivo(0,V,R);
        return R;
    }

    /** Retorna una hilera que contiene los dígitos de {@code L[]}. */
    public static String vString( char L[] ) {
        if ( L == null ) {
            return "";
        }
        StringBuffer res = new StringBuffer();
        for ( int i=0; i<L.length; ++i ) {
            res.append( new Integer(L[i]).toString() );
        }
        return new String(res);
    }

}

// EOF: TestAlVerres.java

Consulta:
Profe: Porqué no me funciona el TestAlVerres.java en Jeliot?
Respuesta:
Jeliot no puede ejecutar programas que se activan con el botón [Test] de JUnit (para eso hay que usar el DrJava). Aquí está una versión del programa que sí se puede ejecutar en Jeliot. Es importante recordar que el nombre del archivo TestAlVerresJeliot.java debe calzar con el nombre de la clase TestAlVerresJeliot que contiene al programa principal main(). 

/**
    @(#)TestAlVerresJeliot.java 2010,2012
    adolfo@di-mare.com
    Programa de prueba para {@code alVerres()}.

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

/** Datos de prueba para el método {@code alVerres()}. */
public class TestAlVerresJeliot {

    /** Retorna una copia de {@code A[]} con los valores invertidos.
        <li> alVerres( {'a','b','c'} ) retorna {'c','b','a'} </li>
    */
    public static char[] alVerres( char V[] ) {
        if ( V == null ) {
            return null;
        }
        int size = V.length  ;        // dimensión de V[] y de R[]
        char R[] = new char[ size ];  // R[] es la copia invertida de V[]
        int i,j;                      // indices para V[] && R[]
        {    
            /******************************\
            *                              *
            *   RELLENE CON SU ALGORITMO   *
            *                              *
            \******************************/
        //  System.out.println( "R" + vString(R) );
        }
        return R;
    }

    /** Programa principal. */
    public static void main( String args[] ) {
        char Z[];
        if (true)  { char A[]={ 'b','c','d','e','f','g','h' };   Z = alVerres(A); }
        if (true)  { char A[]={ 'a','b','c','b','c','b','a' };   Z = alVerres(A); }
        if (true)  { char A[]={ 'h','g','f','e','d','c','b' };   Z = alVerres(A); }

        if (false) { char A[]={ 'b','b','b','b' };               Z = alVerres(A); }
        if (false) { char A[]={ 'a','b','c','d' };               Z = alVerres(A); }
        if (false) { char A[]={ 'd','c','b','a' };               Z = alVerres(A); }

        if (false) { char A[]={ 'b','a' };                       Z = alVerres(A); }
        if (false) { char A[]={ 'a','b' };                       Z = alVerres(A); }
        if (false) { char A[]={ 'b' };                           Z = alVerres(A); }

        if (false) { char A[]={ 'j','j','a','b','c','d' };       Z = alVerres(A); }
        if (false) { char A[]={ 'd','c','b','a','j','j' };       Z = alVerres(A); }

        if (false) { char A[]={};                                Z = alVerres(A); }

        // NOTA: active con (true) el ejemplo que desea visualizar
    }
}

// Jeliot:
// - http://cs.joensuu.fi/jeliot/javaws/jeliot.jnlp

// EOF: TestAlVerresJeliot.java

Consulta:
Profe: Por favor, recomiéndeme algunos ejercicios para entrarle a esta tarea.
Respuesta:
Podés usar el Lab03.java para hacer la siguiente práctica en Jeliot:
  1. Ejecución del ciclo for ( int i=123 ; i<=126 ; ++i ) { }
  2. Cambiar ese for(;;){} para que haga cáculo a la inversa, desde 126 bajando hasta 123 (alVerres).
  3. Hacer otra vez lo mismo, pero sin usar comparaciones ">=" o "<=".
  4. Hacerlo un nuevo ciclo for(;;){} que haga los 2 cálculos simultáneamente:
    Las variables sumaArriba && i sirven para hacer el cálculo hacia adelante (123->126)
    Las variables sumaAbajo && j sirven para hacer el cálculo hacia atrás (126->123)
    OJO: Hay que usar un único ciclo for(;;){}
  5. Luego ya podés resolver esta tarea con Jeliot (en TestAlVerresJeliot.java).
  6. Finalmente podés usar tu solución Jeliot con DrJava (en TestAlVerres.java).

      Entregue su tarea por correo electrónico, como lo hizo anteriormente.

Soluciones

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