// Lab03.java (C) 2007,2010 adolfo@di-mare.com

/**
    @(#)Lab03.java 2007,2010
    Ejemplos de uso de \c while() y de \c for(;;).
    @author Adolfo Di Mare <adolfo@di-mare.com>
*/

import java.io.*; // Clases para leer desde el teclado
import java.lang.System; // Esta siempre la importa Java

/** Clase que contiene el programa principal {@code main()}. */
public class Lab03 {
    /** Programa principal.
      * <li> Invoca a las demás rutinas {@code main()}.
      */
    public static void main( String args[] ) throws IOException {
        Bib.main_suma_123_126();
        Bib.main_for_anidados();
        Bib.main_break_for();
        Bib.anidados3();
        Bib.main_matriz_loca();
        {
            int    n[] = {    3 ,    4 };    //   3        4
            double X[] = { 2.0  , 5.0  };    //  2 == 8   5  == 498
            Bib.main_for_while( X[0],n[0] ); //  2.0^3 == 8.0
            Bib.main_for_while( X[1],n[1] ); //  5.0^4 == 498.0
        }
        Bib.main_invierteRango();
        if ( false ) {
            /** CIN es el mecanismo que permite leer hileras del teclado. */
            BufferedReader CIN; // Flujo de entrada estándar
            CIN = new BufferedReader( new InputStreamReader(System.in) );
            Bib.main_promedio( CIN );
        }
        return;
    }
    /** Constructor por defecto.
      * {@code private} previene que la clase sea instanciada. */
    // private Lab03() { super(); }
} // Lab03

/** Contiene los métodos que realizan cada uno de los pasos del proceso. */
class Bib {

    /** Calcula {@code X^n} usando {@code while()} vs {@code for(;;)}. */
    static void main_for_while( double X, int n ) {
        double res, res_for, res_while;

        // cálculo equivalente realizado con for(;;)
        res = 1.0;
        for ( int i=0; i<n; ++i ) {
            res *= X;
        }   // "i" no existe aquí
        res_for = res;

        // cálculo equivalente realizado con while()
        res = 1.0;
        {
            int i=0;
            while ( i<n ) {
                res *= X;
                ++i;
            }   // "i" sí existe aquí
        }       // "i" no existe aquí
        res_while = res;

        if ( ! (res_while == res_for) ) { // siempre son iguales
            System.out.println( "\n*** error del compilador ***\n" );
        }
        System.out.println( (X) + "^" + (n) + " == " + (res) + '\n' );
    }

    /** Muestra la diferencia que hace anidar ciclos {@code for(;;)}. */
    static void main_for_anidados() {
        {   // 5 renglones de 2 valores                    // Rectángulo
            System.out.print( "\nRectángulo\n" );          // 0 1
            for (int i=0; i<5; ++i ) {                     // 2 3
                for (int j=0; j<2; ++j ) {                 // 4 5
                    System.out.print( (i*2 + j) + " " );   // 6 7
                }                                          // 8 9
                System.out.print( "\n" );
            }
        }
        {   // 2 renglones solitos                         // Lineal
            System.out.print( "\nLineal\n" );              // 0 1 2 3 4
            for (int i=0; i<5; ++i ) {                     // 0 1
                System.out.print( (i) + " " );
            }
            System.out.print( "\n" );
            for (int j=0; j<2; ++j ) {
                System.out.print( (j) + " " );
            }
            System.out.print( "\n" );
        }
    }

    /** Muestra que {@code break} quiebra solo el ciclo inmediato. */
    static void main_break_for() {
        int M[][] = new int[5][2], n=0;                // M[5][2]
        System.out.print( "\nM[][]\n" );               // 0 1
        for (int i=0; i<M.length; ++i ) {              // 2 3
            for (int j=0; j<M[i].length; ++j ) {       // 4 0 <==
                int formula = (i*2+j);                 // 6 7
                if ( 5 == formula ) {                  // 8 9
                    ++n;
                    break;
                }
                M[i][j] = formula;
            }
        }
        if ( (n!=1) || (M[2][1]!=0) ) {
            System.out.print( "\nERROR break\n" );
        }
    }

    /** Muestra que las filas de una matriz pueden ser de diferente tamaño. */
    /*
        M
        +--->+===+              j=[0...3]
             | 2 |     +===++----+----+----+----+
             +===+  +->| 4 || 10 | 11 | 12 | 13 |
        i==0 | *-|-/   +===++----+----+----+----+
             +---+
        i==1 | *-|-\   +===++----+----+----+----+----+----+
             +---+  +->| 6 || 14 | 15 | 16 | 17 | 18 | 19 |
                       +===++----+----+----+----+----+----+
                     M[1].length   M[1][0] .. M[1][6-1]
    */
    static void main_matriz_loca() {
        boolean assertTrue = false;
        int M[][] = new int[2][];     assertTrue = ( 2 == M.length );
        M[0] = new int[4];            assertTrue = ( 4 == M[0].length );
        M[1] = new int[6];            assertTrue = ( 6 == M[1].length );

        int n = 10;
        for (int i=0; i<M.length; ++i ) {
            for (int j=0; j<M[i].length; ++j ) {
                M[i][j] = n++;
            }
        }
        assertTrue = ( 10 == M[0][0] );    assertTrue = ( 14 == M[1][0] );
        assertTrue = ( 11 == M[0][1] );    assertTrue = ( 19 == M[1][5] );
    }

    /** Muestra cómo calcular una sumatoria con {@code for()} vs {@code while()}.
        <ul>
        <li> Suma los cuadrados de lo números en el rango {@code [123..126]} </li>
        </ul>
    */
    static void main_suma_123_126() {
        {    // con for(;;)
            int suma = 0;
            for ( int i=123 ; i<=126 ; ++i ) {
                suma += i*i;
            }
            // aquí "i" ya no existe
            // System.out.println( "Variable \"i\" no existe " + (i) );
            if ( suma != 62007 ) {
                System.out.println( '\n' + "suma == " + (suma) + " != 62007 ERROR" );
            }
        }

        {   // con while() equivalente al for(;;) anterior
            int suma = 0;
            {    // con corchete
                 int i=123;
                 while ( i<=126 ) {
                     suma += i*i;
                     ++i;
                 }
            }    // con corchete
            // aquí "i" ya no existe
            // System.out.println( "Variable \"i\" no existe " + (i) );
            if ( suma != 62006 ) {
                System.out.println( '\n' + "suma == " + (suma) + " != 62006 ERROR" );
            }
        }

        {   // con while() pero sin corchetes
            int suma = 0;
            //  // sin corchete
                int i=123;
                while ( i<=126 ) {
                    suma = suma + i*i;
                    ++i;
                }
            //  // sin corchete
            // aquí "i" si existe
            if ( i!=126+1 ) {
                System.out.println( "Variable \"i\" si existe " + (i) );
            }
            if ( suma != 62006 ) {
                System.out.println( '\n' + "suma == " + (suma) + " != 62006 ERROR" );
            }
        }
    }

    /** Calcula promedios de clase, usando un valor como sentinela. */
    static void main_promedio( BufferedReader CIN ) throws IOException {
        int total,       // total de notas
            n,           // cantidad de notas ingresadas
            nota;        // una nota
        float promedio;  // promedio, con punto decimal

        // fase de inicialización
        n     = 0;
        total = 0;
        System.out.println();

        // fase de proceso
        System.out.println( "Ingrese cada nota, -1 para terminar: " );
        nota =  Integer.parseInt( CIN.readLine() );

        while ( nota >= 0 ) {
            total = total + nota;
            n = n + 1;
            System.out.println( "Ingrese cada nota, -1 para terminar: " );
            nota =  Integer.parseInt( CIN.readLine() );
        }

        // fase de conclusión
        if ( n != 0 ) {
            promedio = (float)(total) / (float)n;
            System.out.println(  "El promedio de la clase es " +(promedio) );
        } else {
            System.out.println( "Ninguna nota fue ingresada" );
        }
    }

    /** Intercambia <code>V[i] <==> V[j]</code>. */
    static void intercambie( char V[], int i, int j ) {
        char tmp = V[i];
        V[i] = V[j];
        V[j] = tmp;
    }

    /** Invierte las letras de "{@code L[]}" en el rango {@code [izq..der]} (extremos incluidos).
      <li> Si <code> (der<izq) || (izq>der) </code> no hace nada.
      */
    static void invierteRango( char L[], int izq, int der ) {
        int i,j;
        for ( i=izq, j=der ; i<j ; ++i,--j ) { // ++j
            intercambie( L, i, j );
            //  System.out.println( "intercambie( L, " + (i) + " , " + (j) + " )");
        }
    }

    /** Graba en {@code System.out} el valor completo de {@code L[]}. */
    static void grabeVector( char L[] ) {
        for ( int i=0 ; i<L.length ; ++i ) { // ++j
            System.out.print( L[i] + " ");
        }
        System.out.println();
    }

    /** Graba un rango de letras invertido y al derecho, varias veces. */
    static void main_invierteRango() {
        final int N = 20; // 20 letras
        char veinteLetras[] = new char[N];
        for (int i=0; i<N; ++i) { // ++j
            veinteLetras[i] = (char) ( (int)('D') + i );
        }
        grabeVector(   veinteLetras );
        invierteRango( veinteLetras , 0, 5 );
        grabeVector(   veinteLetras );
        invierteRango( veinteLetras , 11, 19 );
        grabeVector(   veinteLetras );
        invierteRango( veinteLetras , 6, 10 );
        grabeVector(   veinteLetras );
        System.out.println( "=======================================");
        invierteRango( veinteLetras , 0, 5 );
        grabeVector(   veinteLetras );
        invierteRango( veinteLetras , 11, 19 );
        grabeVector(   veinteLetras );
        invierteRango( veinteLetras , 6, 10 );
        grabeVector(   veinteLetras );
    }

    public static void anidados3( ) {
        System.out.print( 5*3*4 + "\n" );
        int n = 1;
        for (int i=0; i<5; i++) {
            for (int j=0; j<3; j++) {
                for (int k=0; k<4; k++) {
                    System.out.print( "\n" + n + " " + i + " " +  j + " " +  k
                    ); ++n;
                }
            }
        }
    }

    /** Constructor por defecto.
      * {@code private} previene que la clase sea instanciada. */
        public Bib() { super(); }
} // Bib

// NOTA: Para ejecutar use el comando:
// > java Lab03
// [en la pantalla de interacciones del DrJava]

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

// EOF: Lab03.java