martes, 31 de mayo de 2011

Deitel_Java_5.16 (Gráficos de Barra en Java)

5.16 Una aplicación interesante de las computadoras es dibujar gráficos convencionales y de barra. Escriba una aplicación que lea cinco números, cada uno entre 1 y 30. Por cada número leído su programa debe mostrar ese número de asteriscos adyacentes. Por ejemplo, si su programa lee el número 7, debe mostrar *******.

Este problema es bastante sencillo. El código a continuación debe guardarse en un archivo llamado Deitel_5_16.java.


  public class UsaDeitel_5_16

  {         // Abre clase UsaDeitel_5_16

   public static void main( String args[])
   {   // Abre main

  // Se crea un Objeto Deitel_5_16

  Deitel_5_16 miObjeto = new Deitel_5_16();

  // Se llama al metodo Imprime
  miObjeto.Imprime();
   }       //Cierra main
  }         // Cierra clase UsaDeitel_5_16 

El siguiente código debe guardarse como Deitel_5_16.java
 import java.util.Scanner; 
  
  public class Deitel_5_16 
  {         // Abre clase Deitel_5_16

  public void Imprime()
  {      // Abre Imprime
  System.out.print("\nIntroduzca cinco enteros entre 1 y 30");
  System.out.println(" y se imprimira un histograma horizontal.\n");  

  Scanner entrada = new Scanner(System.in);

  int numero;
  int contador = 1;

  while ( contador <= 5 )
  {         // Abre while
  System.out.printf("\nPor favor introduzca el numero %d:\n ", contador);
  numero = entrada.nextInt();

  if ((5 <= numero) && ( 30 >= numero))
  {     // Abre if

  for ( int i = 1; i <= numero; i++ )
  System.out.print("*");

  System.out.println();

  contador++;
  }       // Cierra if
  }         // Cierra while
  

  }      // Cierra Imprime

         
  }        // Cierra clase Deitel_5_16

Redireccionando la Salida de Archivos en Unix/Linux

En programas que generen una enorme cantidad de datos, como estos, ustedes necesitan que la salida no sea a la consola, sino a un archivo de texto. Posteriormente podrían abrirlo desde otro programa, o pueden también crear el archivo desde su programa, de la forma en que se explica aquí. Incluso podrían jugar un poco con llamadas System para conectar varios códigos.

En Unix y, desde luego, en su hijo más famoso, Linux, ustedes pueden redireccionar la salida con las siguientes instrucciones:

./Ejecutable.out > MiArcbivo.extension

lo cual crea el fichero MiArchivo.extension en el directorio en que se encuentran y, si existe, borra todo lo anterior y sólo graba la salida del ejecutable actual.

O con

./Ejecutable.out >> MiArcbivo.extension

lo cual crea el fichero Miarchivo.extension y, si ya existe, concatena la salida con lo que tiene el archivo.

También es posible usarlos cuando se ejecuta un programa en java:

java MiPrograma >> MiArcbivo.extension

y

java MiPrograma >> MiArcbivo.extension

Con resultados idénticos a los señalados arriba.
Más acerca de los sistemas Unix Linux en Aprendiendo A Usar Linux

Deitel_Java_5.15 (Mostrar Triángulos con Asteriscos en Java)

_____________________________________________________________________________________
5.15 Escriba una aplicación que muestre los siguientes patrones por separado, uno debajo del otro. Use ciclos for para generar los patrones. Todos los asteriscos (*) deben imprimirse mediante una sola instrucción de la forma System.out.print("*"); la cual hace que los asteriscos se impriman uno al lado del otro. Puede utilizarse una instrucción de la forma System.out.println(); para posicionarse en la siguiente línea. Puede usarse una instrucción de la forma System.out.print(" "); para mostrar un espacio para los últimos dos patrones. No debe haber ninguna otra instrucción de salida en el programa. [Sugerencia: los últimos dos patrones requieren que cada línea empiece con un número apropiado de espacios en blanco].

*             **********       **********             *
**            *********         *********            **
***           ********           ********           ***
****          *******             *******          ****
*****         ******               ******         *****
******        *****                 *****        ******
*******       ****                   ****       *******
********      ***                     ***      ********
*********     **                       **     *********
**********    *                         *    **********

_____________________________________________________________________________________
Solución:
En este programa se puede modificar la variable privada Tamano para generar un patrón diferente al presentado.

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

public class UsaDeitel_5_15

{        // Abre clase UsaDeitel_5_15

public static void main(String args[])
{          // Abre main
// Se crea el objeto miObjeto
Deitel_5_15 miObjeto = new Deitel_5_15();
// Se llama al metodo Imprime
miObjeto.Imprime();
}          // Cierra main

}        // Cierra clase UsaDeitel_5_15

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

// En este programa solo se puede usar las siguientes
// instrucciones: 
// System.out.print("*");
// System.out.println();
// System.out.print(" ");
   
public class Deitel_5_15
{              // Abre clase Deitel_5_15

private int Tamano = 10;

public void Imprime()
{       // Abre metodo Imprime

System.out.println("\n");

for ( int i = 1; i <= Tamano; i++ )
{           // Abre for
for ( int j = 1; j <= i; j++ )
System.out.print("*");

for ( int k = i + 1; k <= Tamano; k++)
System.out.print(" ");

System.out.print(" ");
System.out.print(" ");
System.out.print(" ");
System.out.print(" ");

for ( int l = 1; l <= Tamano + 1 - i; l++ )
System.out.print("*");

for ( int m = Tamano - 1 -i; m <= Tamano; m++)
System.out.print(" ");

System.out.print(" ");
System.out.print(" ");
System.out.print(" ");
System.out.print(" ");

for ( int n = 1; n < i; n++ )
System.out.print(" ");
   
for ( int p = i; p <= Tamano; p++ )
System.out.print("*");

System.out.print(" ");
System.out.print(" ");
System.out.print(" ");
System.out.print(" ");

for ( int q = 1; q <= Tamano - i; q++ )
System.out.print(" ");

for ( int r = Tamano - i; r < Tamano; r++ )
System.out.print("*");

System.out.println();
}           // Cierra for

System.out.println("\n");
}       // Cierra metodo Imprime

}              // Cierra clase Deitel_5_15

La ejecución de éste programa produce la salida mostrada arriba.
_____________________________________________________________________________________
Ahora vamos a revisar el programa línea por línea:
Lo primero que hay que ver es que éste programa está dividido en dos archivos. El primero es llamado UsaDeitel_5_15.java y el segundo Deitel_5_15.java. Es importante recordar que en java el nombre de los archivos no es indistinto. Se pueden cambiar, pero de tal manera que los cambios sean consecuentes con las llamadas a las clases que se harán posteriormente.Desde luego, puede parecer redundante tener dos archivos cuando podría todo el programa estar contenido en uno sólo. Sin embargo, me he acostumbrado a escribir por lo menos dos archivos para un proyecto, y ésto lo hago de manera automática. Esta es una buena práctica de programación.

public class UsaDeitel_5_15

Como su nombre lo indica, el primer archivo hace uso del segundo. Actúa como un administrador de los métodos de Deitel_5_15.java.

{        // Abre clase UsaDeitel_5_15

El cuerpo de las clases se delimita por llaves: { }. //Abre clase.... es un comentario. Se comenta esta llave simplemente por costumbre, como una buena práctica de programación. Cuando un programa se va haciendo cada vez más grande, puede ser difícil saber a qué cuerpo de instrucciones corresponde determinada llave.

public static void main(String args[])

Dentro de la clase solamente hay un método, el método main. main, como su nombre lo indica, es el método principal. Todos los programas tienen al menos ese método. La ejecución del programa empieza ahí. Los argumentos entre paréntesis deben incluirse siempre.

{          // Abre main

Como las clases, los métodos son cuerpos de instrucción delimitados por llaves.

// Se crea el objeto miObjeto
Deitel_5_15 miObjeto = new Deitel_5_15();

De la clase Deitel_5_15.java, se crea un nuevo objeto, llamado, por falta de un nombre mejor, miObjeto. La forma de crear un objeto es usar la palabra reservada new y a continuación el nombre de la clase, seguida por un par de paréntesis.

// Se llama al metodo Imprime
miObjeto.Imprime();

Una vez creado miObjeto, es posible llamar los métodos de dicho objeto. El primero, a partir del cual se llamarán los demás es Imprime, que no requiere argumentos. Con ésto pasamos el control del programa al siguiente archivo.

}          // Cierra main

}        // Cierra clase UsaDeitel_5_15

Éste par de líneas, como lo indican los comentarios, cierran los cuerpos de main y UsaDeitel_5_15, respectivamente.

Ahora vamos a considerar el siguiente archivo, Deitel_5_15.java

// En este programa solo se puede usar las siguientes
// instrucciones: 
// System.out.print("*");
// System.out.println();
// System.out.print(" ");
   

Éstas líneas son un comentario. El comentario aclara que sólo es posible usar las instrucciones que ahí aparecen.

public class Deitel_5_15
{              // Abre clase Deitel_5_15

ÉStas líneas ya no son desconocidas. estamos declarando una clase pública a la que hemos llamado iguan que el archivo: Deitel_5_15. El cuerpo de dicha clase se limita por llaves. La primera llave aparece junto a un comentario que indica que se trata de la llave de apertura.

private int Tamano = 10;

Ésta variable de tipo entero, por ser private puede ser usada por todos los métodos de la clase. En éste caso sólo hay un método, Imprime. se establece en 10 porque es la altura y la anchura de los triángulos. Si se cambia ese número por, digamos, 15, el programa funciona exactamente igual, como se puede ver en la siguiente figura, generada al cambiar sólo ese valor:

*                  ***************       ***************                  *
**                 **************         **************                 **
***                *************           *************                ***
****               ************             ************               ****
*****              ***********               ***********              *****
******             **********                 **********             ******
*******            *********                   *********            *******
********           ********                     ********           ********
*********          *******                       *******          *********
**********         ******                         ******         **********
***********        *****                           *****        ***********
************       ****                             ****       ************
*************      ***                               ***      *************
**************     **                                 **     **************
***************    *                                   *    ***************


public void Imprime()
{       // Abre metodo Imprime

Aquí se define un método público llamado Imprime, y se abre el cuerpo de instrucciones. Imprime no recibe ni regresa argumentos.

System.out.println("\n");

Con ésta orden, estamos saltando una línea.

for ( int i = 1; i <= Tamano; i++ )
{           // Abre for

Este ciclo for controla el número de renglones, o altura, que tendrán los triángulos.

for ( int j = 1; j <= i; j++ )
System.out.print("*");

Éste primer ciclo for dibuja el primer triángulo. La anchura se corresponde con la altura, esto es, el ciclo corre a la par que el ciclo for externo.

for ( int k = i + 1; k <= Tamano; k++)
System.out.print(" ");

Éste ciclo for imprime un segundo triángulo, ahora de espacios vacíos, a partir del siguiente en el que queda el ciclo for anterior. Por ejemplo, en la primera línea (i = 1) se imprime un *. A partir de la posición 2 (i + 1) se imprimen espacios en blanco hasta alcanzar la variable Tamano.

System.out.print(" ");
System.out.print(" ");
System.out.print(" ");
System.out.print(" ");

Estas líneas son simples. Son los espacios entre cada cuadrado (formado por un par de triángulos, uno de * y uno blanco).

for ( int l = 1; l <= Tamano + 1 - i; l++ )
System.out.print("*");

Este ciclo imprime un triángulo invertido. En el renglón 1 (i = 1), se imprime un * desde la posición 1 hasta la posición Tamano(Tamano + 1 - 1). A partir de ahí, se empieza a imprimir un asterisco menos, hasta llegar a 1.

for ( int m = Tamano - 1 -i; m <= Tamano; m++)
System.out.print(" ");

Con éste ciclo for se imprime un triángulo en blanco que completa el cuadrado.

System.out.print(" ");
System.out.print(" ");
System.out.print(" ");
System.out.print(" ");

De nuevo, se imprimen cuatro espacios.

lunes, 30 de mayo de 2011

Deitel_Java_5.14 (Cálculo de interés compuesto en Java)

_____________________________________________________________________________________
5.14 Modifique la aplicación de interés compuesto de la figura 5.6, repitiendo sus pasos para las tasas de interés del 5, 6, 7, 8, 9 y 10%. Use un ciclo for para variar la tasa de interés.
_____________________________________________________________________________________
Solución:
El problema que resuelve este programa es el siguiente:
"Una persona invierte $1000.00 en una cuenta de ahorro que produce el 5% de interés. Suponiendo que todo el interés se deposita en la duenta, calcule e imprima el monto de dinero en la cuenta al final de cada año durante 10 años. Use la siguiente fórmula para determinar los montos:
c = p(1 +r)^n
en donde
p es el monto que se invirtió originalmente (es decir, el monto principal)
r es la tasa de interés anual (por ejemplo, use 0.05 para el 5%)
n es el número de años
c es la cantidad de positada al final del año enésimo.

Para resolver este problema solamente se agrega un ciclo for al ejemplo de la figura 5.6.

El siguiente código debe guardarse con el nombre UsaDeitel_5_14.java

public class UsaDeitel_5_14

  {              // Abre clase UsaDeitel_5_14
 
  public static void main(String args[])
  {       // Abre main 
  Deitel_5_14 miObjeto = new Deitel_5_14();

  // Llama metodo UsaDeitel_5_14

  miObjeto.Interes(); 

  }        // Cierra main

  }              // Cierra clase UsaDeitel_5_14


El siguiente código debe guardarse con el nombre Deitel_5_14.java

public class Deitel_5_14

    {             // Abre clase Deitel_5_14
     private double monto;
     private double principal = 1000;


     
     public void Interes()
     {      //Abre método Interes


     for(double tasa = 0.05; tasa <= 0.1; tasa += 0.01 )
     {  // Abre primer for 


     System.out.printf("\n%s%20s", "Anio", "Monto en deposito");
     System.out.printf(" para una tasa igual a: %.2f\n", tasa);

     for( int anio = 1; anio <= 10; anio++ )
     {  // Abre for
     monto = principal * Math.pow( 1.0 + tasa, anio );
     System.out.printf("%4d%,20.2f\n", anio, monto);
     }  // Cierra for

     System.out.println("\n");
     }   // Cierra primer for 

     }      // Cierra método Interes

    }             // Cierra clase Deitel_5_14

La ejecución de este programa produce la siguiente salida:

Anio   Monto en deposito para una tasa igual a: 0.05
   1            1,050.00
   2            1,102.50
   3            1,157.63
   4            1,215.51
   5            1,276.28
   6            1,340.10
   7            1,407.10
   8            1,477.46
   9            1,551.33
  10            1,628.89



Anio   Monto en deposito para una tasa igual a: 0.06
   1            1,060.00
   2            1,123.60
   3            1,191.02
   4            1,262.48
   5            1,338.23
   6            1,418.52
   7            1,503.63
   8            1,593.85
   9            1,689.48
  10            1,790.85



Anio   Monto en deposito para una tasa igual a: 0.07
   1            1,070.00
   2            1,144.90
   3            1,225.04
   4            1,310.80
   5            1,402.55
   6            1,500.73
   7            1,605.78
   8            1,718.19
   9            1,838.46
  10            1,967.15



Anio   Monto en deposito para una tasa igual a: 0.08
   1            1,080.00
   2            1,166.40
   3            1,259.71
   4            1,360.49
   5            1,469.33
   6            1,586.87
   7            1,713.82
   8            1,850.93
   9            1,999.00
  10            2,158.92



Anio   Monto en deposito para una tasa igual a: 0.09
   1            1,090.00
   2            1,188.10
   3            1,295.03
   4            1,411.58
   5            1,538.62
   6            1,677.10
   7            1,828.04
   8            1,992.56
   9            2,171.89
  10            2,367.36



Anio   Monto en deposito para una tasa igual a: 0.10
   1            1,100.00
   2            1,210.00
   3            1,331.00
   4            1,464.10
   5            1,610.51
   6            1,771.56
   7            1,948.72
   8            2,143.59
   9            2,357.95
  10            2,593.74


Multiplicación de Matrices en Java

Presento este programa clásico ahora en java. Se pueden encontrar también en este blog las versiones en C: Multiplicación de Matrices en C y en C++:Multiplicación de Matrices en C++. El algoritmo central es el mismo. El problema debe atacarse pensando primero en la multiplicación de dos vectores (un ciclo for), depués en un vector por una matriz (dos ciclos for) y finalmente dos matrices (tres ciclos for). Esto puede verse en el método Multiplicar. Como todos los programas, basta copiar y pegar en un editor de texto el código aquí presentado. Este programa recibe las matrices, las multiplica e imprime el resultado. En realidad el corazón del programa (la multiplicación) son unas cuántas líneas de código. Es más complicado presentar los resultados en pantalla. De todas formas creo que eso es muy útil para el usuario final y por eso lo incluyo.


El siguiente código debe guardarse con el nombre UsaMultiplicacion.java


public class UsaMultiplicacion

  {                   // Abre clase UsaMultiplicacion

   public static void main(String args[])
   {       // Abre main
   
   Multiplicacion miObjeto = new Multiplicacion();

   // Llamada a Recibe_Entradas1()
   miObjeto.Recibe_Entradas1();

   // Llamada a Recibe_Entradas2()
   miObjeto.Recibe_Entradas2();

   //Llamada a Multiplicar
   miObjeto.Multiplicar();

   //Llamada a metodo Imprime
   miObjeto.Imprimir();

   }       // Cierra main
  }              // Cierra clase UsaMultiplicacion
El siguiente código debe guardarse con el nombre Multiplicacion.java
 import java.util.Scanner;

 public class Multiplicacion

{                 // Abre clase Multiplicacion

    //Si se quiere multiplicar matrices de distinta dimension 
    //solo hay que cambiar los valores de M, N y P
    private int M = 3;
    private int N = 2;
    private int P = 4;
    private int Matriz1[][] = new int[N][M];
    private int Matriz2[][] = new int[M][P];
    private int Matriz3[][] = new int[N][P];

        Scanner entrada = new Scanner(System.in);


    //Metodo Recibe_Entradas1
    public void Recibe_Entradas1()

    { // Abre metodo Recibe_Entradas1
          
    System.out.printf("\nEste programa multiplica una matriz de %d columnas y %d renglones", M, N);
    System.out.printf(" con una de %d columnas y %d renglones\n\n", P, M);
    System.out.print("\nAqui se reciben las entradas de la primera matriz " );
    System.out.printf("de %d filas y %d columnas.\n", M, N );


    for ( int i = 0; i < N; i++ )
    for ( int j = 0; j < M; j++ )

    { // Abre for
    System.out.printf("Introduzca el valor de la entrada en el renglon %d  y la columna %d: ", i + 1,  j + 1 );
    Matriz1[i][j] = entrada.nextInt();
        } // Cierra for
    } // Cierra metodo Recibe_Entradas1



    public void Recibe_Entradas2( )

    { // Abre metodo Recibe_Entradas2

    System.out.print("\nAqui se reciben las entradas de la segunda matriz " );
    System.out.printf("de  %d  filas y %d columnas", M, P);

    for ( int i = 0; i < M; i++ )
    for ( int j = 0; j < P; j++ )
    { // Abre for
    System.out.printf("\nIntroduzca el valor en el renglon %d y la columna %d: ",  i + 1,  j + 1 );
        Matriz2[i][j] = entrada.nextInt();
            } // Cierra for

    } // Cierra metodo Recibe_Entradas2



    // Metodo Multiplicar
    public void Multiplicar( )

    { // Abre metodo Multiplicar

    for ( int k = 0; k < N; k++)
    { // abre primer ciclo for
    for ( int j = 0; j < P; j++)
    { // abre el segundo ciclo for
    for ( int i = 0; i < M; i++ )
    Matriz3[ k ][j ] += Matriz1[k][i]*Matriz2[i][j];

    } // Cierra el segundo ciclo for
    }

    } // Cierra el metodo Multiplicar



        
  void Imprimir( )
  {  // Abre metodo Imprimir
  // Aqui se imprimen la dos matrices y la matriz producto
  int i, j, k;

  System.out.printf("\n\nAQUI SE IMPRIMEN LAS DOS MATRICES Y EL PRODUCTO: \n\n");
  for ( i = 0; i < N; i++ )
  { // abre for que controla numero de renglones

  // Este ciclo imprime la primera matriz
  // No hay ningun problema para imprimir la primera matriz, ya que se
  // trata de un par de ciclos for. Sin embargo se quiere imprimir las
  // tres matrices, lo cual hace un poquito mas complicado el asunto.
  // De todas formas la primera se imprime renglon por renglon
  // solo que antes de pasar al siguiente renglon, se escriben las entradas
  // correspondientes de la segunda y tercera matrices.

  for ( k = 0; k < M; k++)
  { // Abre ciclo for
  System.out.printf("%3d", Matriz1[i][k]);
  // Se imprime el renglon i de la matriz 1
  } //Cierra ciclo for

  System.out.printf("\t\t"); // Esta instruccion separa una matriz de otra

  // Este ciclo imprime la segunda matriz

  for ( j = 0; j < P; j++)
  { // abre for
  if ( i <= (N - 1)) // El numero de columnas de la segunda matriz puede ser
  // menor o mayor que el numero de filas de la primera
  // Si es mayor no pasa nada, pero si es menor se estara
  // haciendo referencia a un elemento inexistente en el arreglo
  // El caso en el que N > M se trata fuera del ciclo controlado por i
  // El -1 es debido a que i empieza a correr en cero

  System.out.printf("%3d", Matriz2[i][j]); // se imprime el renglon i de la matriz 2

  else // De lo contrario solo se imprimen 3 espacios en blanco
     // correspondientes con 3d

  System.out.printf(" ");
  } // Cierra for

  System.out.printf ("\t\t"); // Esta instruccion separa la matriz 2 de la matriz
                 // producto

  // Este es el ciclo que imprime la matriz producto
  for ( j = 0; j < P; j++ )
  { // abre for
  System.out.printf("%3d", Matriz3[i][j]);
  // se imprime el renglon i de la matriz producto
  } // Cierra for

  System.out.printf("\n");
  // Aqui se cambia de renglon
  } // Cierra for que controla numero de renglones

  // Es probable que N > M, por lo cual en el ciclo anterior no se
  // imprimiria la segunda matriz en su totalidad
  // Con el siguiente bloque se imprime lo que falta

  if ( M > N)
  { // Abre if
  int l = N;

  while ( l < M )
  { // Abre while
  for ( i = 0; i < M; i++)
  System.out.printf(" ");
  System.out.printf("\t\t\t");      
  for ( j = 0; j < P; j++ )
  System.out.printf("%3d", Matriz2[l][j]);
  System.out.printf("\n"); // Aqui se cambia de linea
  l++; // Se incrementa el numero de linea
  } // Cierra while
  } // Cierra if
  }  // Cierra metodo Imprimir

}       // Cierra clase Multiplicacion

domingo, 29 de mayo de 2011

Deitel_Java_5.13

5.13 Los factoriales se utilizan frecuentemente en los problemas de probabilidad. El factorial de un entero positivo n (se escribe como n!) es igual al producto de los enteros del 1 a n. Escriba una aplicación que evalúe los factoriales de los enteros del 1 al 5. Muestre los resultados en formato tabular. ¿Qué dificultad podría impedir que usted calculara el factorial de 20?
Se usa un ciclo for, que va de 1 a 5, dentro del cual se calcula el factorial mediante un ciclo while.
El siguiente código debe guardarse en un archivo llamado UsaDeitel_5_13.java.
  public class UsaDeitel_5_13
  
  {           // Abre clase UsaDeitel_5_13
  public static void main(String args[])

  {          // Abre main
  Deitel_5_13 miObjeto = new Deitel_5_13();

  // Se llama metodo factorial
  miObjeto.factorial();

  }          // Cierra main
  }           // Cierra clase UsaDeitel__13


El siguiente código debe guardarse en un archivo llamado Deitel_5_13.java
  public class Deitel_5_13

  {      // Abre clase publica Deitel_5_13

  public void factorial()
  {             // Abre metodo factorial
  for ( int i = 1; i <= 5; i++ )
  {   // Abre for
  
  int factor = 1;
  int numero = i;

  // Este ciclo while calcula el factorial
  while ( 0 < numero )
  {        // Abre while
  factor *= numero--;
  }        // Cierra while

  System.out.printf("\nEl factorial de %d es: %d\n", i, factor );


  }   // Cierra for
  }             // Cierra metodo factorial


  }      // Cierra clase publica Deitel_5_13


El problema de calcular el factorial de 20 es que en java los enteros van de -2147483648 a 2147483647, en tanto que 20! es un número con 19 cifras que supera pronto el tamaño máximo de un int de 4 bytes (32 bits) en memoria.

Deitel_Java_5.12

5.12 Escriba una aplicación que calcule el producto de los enteros impares del 1 al 15.

Este problema también es bastante fácil. Primero se define la variable producto que se inicializa a 1. A continuación, con un ciclo for se verifica si cada uno de los números del 1 al 15 es o no impar, para ésto se usa el operador %, en caso de ser impar la variable producto se transforma en producto*número.

El siguiente código debe guardarse en un archivo llamado UsaDeitel_5_12.java

   public class UsaDeitel_5_12

   {              // Abre clase UsaDeitel_5_12

   public static void main(String args[])
   {          // Abre metodo main

   Deitel_5_12 miObjeto = new Deitel_5_12();
   
   // Se llama a producto
   miObjeto.Producto();

   // Se llama al metodo Imprime
   miObjeto.Imprime(); 

   }          // Cierra metodo main
   }              // Cierra clase UsaDeitel_5_12

El siguiente código debe guardarse en un archivo llamado Deitel_5_12.java y en el mismo directorio que el anterior.

  public class Deitel_5_12

    {           // Abre clase Deitel_5_12


        
    int producto = 1;
    // Variable comun y accesible a todos los 
    // metodos de la clase

        public void Producto()
        {          // Abre metodo producto

    System.out.println("\nEste programa calcula el producto ");
    System.out.println("\nde los enteros impares del 1 al 15\n");


    // Se asume que el numero que no es par es impar
    // y por lo tanto producto sera igual a producto*numero
    

    for ( int i = 1; i <= 15; i++ )
    {           // Abre for

        if( i % 2 != 0 )
            producto *= i;

    }           // Cierra for



        }         // Cierra metodo producto


    public void Imprime()
    {         // Abre metodo Imprime
    System.out.printf("\nEl producto es: %d\n", producto );
    }         // Cierra metodo Imprime

    }           // Cierra clase Deitel_5_12

Deitel_Java_5.11 (Encontrar el Menor de Varios Enteros)

5.11 Escriba una aplicación que encuentre el menor de varios enteros. Suponga que el primer valor leído especifíca el número de valores que el usuario introducirá.

Este problema es bastante sencillo. Solamente se requiere una variable que controle el número de entradas que se recibirán ( aquí se usa x), una que almacene el menor (llamada menor) y una que vaya recibiendo los valores cada vez ( y ). Se recibe el primer número y ese es automáticamente el menor hasta el momento, luego se recibe el segundo y se compara con menor, en caso de ser más pequeño, la variable menor toma el valor del segundo, y así hasta recibir y comparar todos los enteros (x).


El siguiente código debe guardarse en un archivo llamado UsaDeitel_5_11.java


   
    public class UsaDeitel_5_11

      {         // Abre clase UsaDeitel_5_11

          public static void main(String args[])
          {                // Abre main

          Deitel_5_11 miObjeto = new Deitel_5_11();

          miObjeto.Recibe();

          }            // Cierra main

      }          // Cierra clase UsaDeitel_5_11


El siguiente código debe guardarse en un archivo llamado Deitel_5_11.java

  import java.util.Scanner;


  public class Deitel_5_11

         {                  // Abre clase Deitel_5_11

         public void Recibe()
         {          // Abre metodo recibe

          int x;
      int y;
      int menor;

      Scanner entrada = new Scanner(System.in);
      System.out.println("\nEste programa le dira cual es el menor ");
          System.out.println(" de unos enteros. Introduzca cuantos numeros");

          System.out.println(" quiere comparar: ");
      x = entrada.nextInt();

        
      System.out.println("\nPor favor introduzca el primer numero: ");
      menor = entrada.nextInt();



      for( int i = 2; i <= x; i++ )
      {     // Abre for

      System.out.printf("\nPor favor introduzca el entero numero: %d\n", i);
          y = entrada.nextInt();
            
      if ( y < menor )
          menor = y;

      }       // Cierra for


      System.out.printf("\nEl menor de los %d numeros es: %d\n", x, menor);
                  }         // Cierra metodo recibe



     }                  // Cierra clase Deitel_5_11
Related Posts Plugin for WordPress, Blogger...

¿Qué lenguaje de programación usas?