Deitel_Java_7.14 ( Multiplicación con un Arreglo)

7.14 Escriba una aplicación que caulcule el producto de una serie de enteros quese pasan al método producto, usando una lista de argumentos de longitud variable. Pruebe su método con varias llamadas, cada una con un número distinto de argumentos.

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

  public class UsaDeitel_7_14
  {   // Abre clase UsaDeitel_7_14
  public static void main(String args[])
  {     // Abre main
  Deitel_7_14 miObjeto = new Deitel_7_14();

  miObjeto.Recibe();
  }   // Cierra main
  }   // Cierra clase Usa_Deitel7_14

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

      /*++++++++++++++++++++++++++++++++++++++++++++++++++++ 
       *                                                   *
       *                                                   *
       *                 DEITEL JAVA 7.14                  *
       *                 ________________                  *
       *                         .                         *
       *                 ________________                  *
       *                                                   *
       *                                                   *
       *   Este programa recibe una lista de enteros y     +
       *   calcula y despliega su producto.                *
       *                                                   *
       *                                                   *
       *   22 de octubre de 2011                           *
       *++++++++++++++++++++++++++++++++++++++++++++++++++ */

      /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*
       *                           _________                           *
       *                           ALGORITMO                           *
       *                           _________                           *
       *                                                               *
       *   PASO 1: Pedir los numeros al usuario                        *
       *   Mediante un ciclo debe pedirse cada vez que se introduzca   *
       *   un numero cada vez. Se deben almacenar en un arreglo.       *
       *                                                               *
       *   PASO 2: Calcular el producto de los numeros recibidos       *
       *   Pasar el arreglo a un metodo que lea las entradas y calcule *
       *   el producto. Debe retornar el producto de los numeros.      *
       *                                                               *
       *   PASO 3: Imprimir el producto                                *
       * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */                                                             

  import java.util.Scanner;

  public class Deitel_7_14
  {  // Abre clase Deitel_7_14
 
  Scanner entrada = new Scanner(System.in);
  int Tamano_Arreglo = 10;
  // Modifique la variable Tamano_Arreglo para recibir una cantidad diferente
  // de enteros.

  //////////////////////////////////////////////////////////////////////
  // METODO RECIBE
  //////////////////////////////////////////////////////////////////////
 
  public void Recibe()
  {          // Abre metodo Recibe
  int Arreglo[] = new int[Tamano_Arreglo];

  for (int i = 0; i < Tamano_Arreglo; i++ )
  {      // Abre for
  System.out.printf("\nPor favor introduzca el numero %d\n", i + 1);
  Arreglo[i] = entrada.nextInt();
  }      // Cierra for 

  System.out.printf("\nEl producto es %d\n",  Multiplica( Arreglo ));

  }          // Cierra metodo Recibe
 
  ///////////////////////////////////////////////////////////////////////
  // METODO MULTIPLICA
  ///////////////////////////////////////////////////////////////////////
 
  public int Multiplica( int A[])
  {  // Abre metodo Multiplica
  int producto = 1;
 
  for ( int j = 0; j < A.length; j++ )
  {      // Abre for
  producto *= A[j];
  }      // Cierra for 

  return producto;
  }  // Cierra metodo Multiplica
  }    // Cierra clase Deitel_7_14
  

Deitel_Java_7.12 (Eliminación de Números Duplicados en Java)

7.12 (Eliminación de duplicados) Use un arreglo unidimensional para resolver el siguiente problema: escriba una aplicación que reciba como entrada cinco números, cada uno de los cuales debe estar entre 10 y 100. A medida que se lee cada número, muéstrelo solamente si no es un duplicado de un número que ya se haya leído. Prepárese para el "peor caso", en el que los cinco números son diferentes. Use el arreglo más pequeño que sea posible para resolver este problema. Muestre el conjunto completo de valores únicos introducidos, después de que el usuario introduzca cada nuevo valor.

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

 public class UsaDeitel_7_12
 {  // Abre clase publica UsaDeitel_7_12
 public static void main(String args[])
 {  // Abre main
 Deitel_7_12 miObjeto = new Deitel_7_12();
 miObjeto.Recibe();
 } // Cierra main 
 }   // Cierra clase publica UsaDeitel_7_12

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

 /* *******************************************************************
  *                                                                   *                                                                 
  *                       DEITEL JAVA 7.12                            *
  *                     _________   _________                         *
  *                               .                                   *
  *                     _________   _________                         *
  *                                                                   *
  *    Este programa recibe 5 numeros distintos entre 10 y 100 y      *
  *    los imprime solo si no han sido repetidos.                     *
  *                                                                   *
  *    19 de octubre de 2011                                          *
  *                                                                   *
  ******************************************************************* */

 import java.util.Scanner;

 public class Deitel_7_12
 {  // Abre clase Deitel_7_12

 /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
  *                                                                  *
  * Declaracion de variables globales                                *
  *                                                                  *
  ****************************************************************** */

 Scanner entrada = new Scanner(System.in);
 enum Estado {SI, NO};
 private int Tamano = 5;
 private int numero;
 private int numeros_recibidos = 0;
 Estado almacenar;
 Estado imprimir;
 int Arreglo[] = new int[Tamano];

 //////////////////////////////////////////////////////////////////////
 // Metodo Recibe
 //////////////////////////////////////////////////////////////////////

 public void Recibe()
 {  // Abre metodo Recibe

 for ( int n = 0; n <  Tamano; n++ )
 { // Abre for 

 numero = 0;
 while ( (10 > numero) || ( 100 < numero) )
 {
 System.out.println("\nPor favor introduzca un numero entre 10 y 100 inclusive\n");
 numero = entrada.nextInt();
 }

 Arreglo[n] = numero;
 numeros_recibidos++;
 Imprime();
 }   // Cierra for

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

 }  // Cierra metodo Recibe


 /* El metodo Imprime pone en la pantalla los numeros recibidos hasta el momento */
 
 //////////////////////////////////////////////////////////////////////////////////
 // METODO IMPRIME                                                                 
 //////////////////////////////////////////////////////////////////////////////////
 
 public void Imprime()
 {     // Abre metodo Imprime
 System.out.printf("\nLos numeros recibidos: %d", numeros_recibidos);
 imprimir = Estado.SI;

 System.out.printf("\n%d", Arreglo[0]);

 for ( int j = 1; j < numeros_recibidos; j++ )
 {  // Abre for
 imprimir = Estado.SI;

 for ( int k = 0; k < j; k++)
 {
 if ( Arreglo[j] == Arreglo[k] )
 imprimir = Estado.NO;
 }

 if ( Estado.SI == imprimir )
 {
 System.out.printf("\n%d", Arreglo[j]);
 }
 }  // Cierra for
 }     // Cierra metodo Imprime

 }  // Cierra clase Deitel_7_12

Deitel_Java_7.10 ( Comisión por Ventas)

_____________________________________________________________________________________
7.10 (Comisión por ventas) Utilicele un arreglo unidimensional para resolver el siguiente problema: una compañía paga a sus vendedores por comisión. Los vendedores reciben $200 por semana  más el 9% de sus ventas totales de esa semana. Por ejemplo, un vendedor que acumule $5000 en ventas en una semana recibirá $200 más el 9% de $5000, o un total de $650.00 Escriba una aplicación (utilizando un arreglo de contadores) que determine cuántos vendedores recibieron salarios en cada uno de los siguientes rangos. (Suponga que el salario de cada vendedor su trunca a una cantidad entera):

a) $200-299
b) $300-399
c) $400-499
d) $500-599
e) $600-699
f) $700-799
g) $800-899
h) $900-999
i) $1000
_______________________________________________________________________________________
SOLUCIÓN:
Este archivo debe guardarse con el nombre
public class UsaTrabajadores

public class UsaDeitel_7_10

{  // Abre clase publica UsaDeitel_7_10
public static void main(String args[])
{  //Abre main
Deitel_7_10 miObjeto = new Deitel_7_10();
miObjeto.Recibe();
}  // cierra main
}   //Cierra clase publica UsaDeitel_7_10

Éste código debe guardarse con el nombre Deitel_7_10.java

import java.util.Scanner;
public class Deitel_7_10
{  // Abre clase
private int Trabajadores = 10;  
float ArregloA[] = new float[Trabajadores + 1];
int ArregloB[] = new int[Trabajadores + 1];
int ArregloC[] = new int[11];

public void Recibe()
{  // Abre metodo Recibe
Scanner entrada = new Scanner(System.in);
System.out.printf("\nEste programa recibe los rangos en los que estan");
System.out.printf("\nlos salarios de los %d empleados.\n", Trabajadores);
float ventas;
  
for ( int j = 0; j < Trabajadores; j++ )
{  // Abre for
ArregloC[j] = 0;
}  // Cierra for
for ( int i = 1; i <= Trabajadores; i++ )
{  // Abre for
System.out.printf("\n\n\nIntroduzca las ventas del empleado numero %d  ", i);
ventas = entrada.nextFloat();
ArregloA[i] = ((float)(9)/100)*ventas + 200;
System.out.printf("\nEl salario del empleado %d es: %.2f\n ", i, ArregloA[i]);
ArregloB[i] = (int)(ArregloA[i])/100;
} 
  
for (int k = 1; k <= Trabajadores; k++ )
{
if (ArregloB[k] < 10)
ArregloC[ArregloB[k]]++;
else
ArregloC[Trabajadores]++;
}
for (int j = 2; j < Trabajadores; j++ )
{
System.out.printf("\nHay %d empleados que cobran entre %d", ArregloC[j], (j * 100));
System.out.printf(" y %d pesos.\n", (( j + 1 ) * 100 ) - 1 );
}

System.out.printf("Hay %d empleados que cobran 1000 o mas.\n\n", ArregloC[Trabajadores]);
  
}   // Cierra metodo Recibe

}   // Cierra clase

Convertir de tipo int a tipo double en Java

Para convertir una variable de tipo double a tipo int basta con colocar la instrucción (int) justo antes del tipo double, como en:

 x = (int)Math.pow(10,x - 1);

que es parte del siguiente programa que genera números aleatorios entre 1 y 9. Hay que tener en cuenta que la parte decimal será truncada.

 import java.util.Random;

 public class Convertir
 {        // Abre clase convertir

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

 Random Aleatorios = new Random();
 int x = 1;
 x = (int)Math.pow(10,x - 1) + Aleatorios.nextInt((int)Math.pow(10, x) - (int)Math.pow(10, x -1)); 

 System.out.printf("\nEl numero x es: %d\n", x);

 }    // Cierra main  
 }        // Cierra clase convertir

De igual manera se procede para convertir un tipo int a tipo double, hay que colocar la orden (double) junto a la variable int. Como en la instrucción:

 System.out.printf("x = %.2f\n", (double)x); 

Que es parte del programa

 public class Convertir
 {  // Abre Convertir
 public static void main(String args[])
 {   // Abre main
 int x = 0;
 System.out.printf("x = %.2f\n", (double)x); 
 }   // Cierra main
 }  // Cierra Convertir

Deitel_Java_6.35 ( Instrucción Asistida por Computadora, Versión Final)

El programa ayuda a practicar operaciones aritméticas.

6.35 En los ejercicios 6.30
al 6.32 se desarrolló un programa de instrucción asistida por computadora para enseñar a un estudiante de escuela primaria cómo multiplicar. Realice las siguientes mejoras:

a) Modifique el programa para que permita al usuario introducir un nivel de capacidad escolar. Un nivel de 1 significa que el programa debe usar sólo números de un dígito en los problemas, un nivel 2 significa que el programa debe utilizar dos dígitos máximo, etcétera.

b) Modifique el programa para permitir al usuario que elija el tipo de problemas aritméticos que desea estudiar. Una opción de 1 significa problemas de suma solamente, 2 significa un problema de resta, 3 significa problemas de multiplicación, 4 significa problemas de división y 5 significa una mezcla aleatoria de problemas de todos estos tipos.
_____________________________________________________________________________________
Solución:
El siguiente código debe guardarse con el nombre UsaDeitel_6_35.java

public class UsaDeitel_6_35
{         // Abre clase publica UsaDeitel_6_35

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

miObjeto.Especificar();
}         // Cierra main

}         // Cierra clase publica UsaDeitel_6_35 

Éste programa debe guardarse con el nombre Deitel_6_35.java

import java.util.Random;
import java.util.Scanner;

enum Estado {SI, NO};
// Las variables de enumeracion llevan el control de si
// el estudiante quiere o no realiza mas ejercicios

public class Deitel_6_35

{         // Abre clase Deitel_6_35

Scanner entrada = new Scanner(System.in);
private int x = 6; // la variable x recibira el numero de cifras
// las posibilidades van de 1 a 5. Se inicializa en 6 para
// entrar al while que aparece para recibirla
private int y = 6; // La variable y recibira el tipo de operacion
/*Los posibles valores van del 1 al 5, y se inicializa
en 6 para entrar en el while en el que se recibe el valor
de esta variable */
private Random Aleatorios = new Random();
private int numero1; //Estos dos numeros son las variables que se sumaran
private int numero2;  // restaran, etc.
private int intentos = 0;
private int aciertos = 0;

///////////////////////////////////////////
// METODO ESPECIFICAR
///////////////////////////////////////////
/*En este metodo se pregunta al alumno si quiere jugar
o seguir jugando, el numero de cifras
que tendran las cantidades con las que trabajara
( 1, 1 cifra; 2, 2 cifras; 3, 3cifras; etc, hasta 5)
y el tipo de operacion aritmetica que se realizara
(1, suma; 2, resta; 3, multiplicacion; 4, division;
5, mezcla aleatoria de todas las anteriores)
El metodo Especificar no recibe parametros, desde aqui se
invoca Generar_Ejercicios */

public void Especificar()
  
{             // Abre metodo Especificar
int i;  // variable auxiliar
Estado continuar = Estado.SI;
// La variable tipo Estado se declara como continuar,
// en el entendido de que si el alumno corre el programa
// es porque quiere practicar por lo menos una vez

System.out.println("\nBienvenido! Este programa te ayudara a realizar ejercicios");
System.out.print(" de aritmetica de acuerdo a tu nivel escolar.\n");
   
while (Estado.SI == continuar)
// Este while se ejecuta mientras el alumno quiera seguir practicando
{          // Abre while
x = 6;
y = 6;

while( 5  < x || 1 > x )
{
System.out.print("\nPor favor introduce el numero de cifras para los numeros(1 a 5): ");
x = entrada.nextInt();
}

while( 5  < y || 1 > y )
{
System.out.print("\nPor favor introduce un numero (1 a 5) ");
System.out.print(" para elegir la operacion: 1 suma, 2 resta, 3 multiplicacion");
System.out.print(" 4 suma y 5 una combinacion aleatoria de las anteriores.\n");
y = entrada.nextInt();
}
   
/*Despues de haber establecido los valores de x & y se invoca el metodo
generar_Ejercicios */

Generar_Ejercicios();

System.out.println("\nQuiere seguir jugando? (1 para Si, otro numero para No)");
i = entrada.nextInt();

if ( 1 == i)
continuar = Estado.SI;

else
continuar = Estado.NO; 
   
}          // Cierra while

System.out.printf("\nEn esta sesión hizo %d intentos,", intentos);
System.out.printf(" de los cuales %d fueron correctos\n", aciertos); 
System.out.printf("\nSu porcentaje de efectividad es: %f\n", (double) aciertos/intentos);
System.out.printf("\nRegrese pronto!\n");
}             // Cierra metodo Especificar

//////////////////////////////////////////////////
// METODO GENERAR_EJERCICIOS
//////////////////////////////////////////////////
/* Este metodo utiliza los dos parametros recibidos
en el metodo Especificacion para  generar el adecuado
ejercicio. Para esto invoca a los metodos Suma, Resta,
Multiplicacion y Division
*/

public void Generar_Ejercicios()
{           // Abre metodo Generar_Ejercicios
int dado;

switch (y)
{   // Abre switch
case 1: 
Suma();
break;
case 2: 
Resta();
break;
case 3:
Multiplicacion();
break;
case 4:
Division();
break;
case 5:
dado = 1 +  Aleatorios.nextInt(4);
switch (dado)
{  // Abre switch anidado
case 1:
Suma();
break;
case 2:
Resta();
break;
case 3:
Multiplicacion();
break;
case 4:
Division();
break;
default:
System.out.println("\nRevise este metodo!");
break;
}  // Cierra switch anidado

break; 
default: 
System.out.println("\nRevise este metodo!");
break;
   
}   // Cierra switch
}           // Cierra metodo Generar_Ejercicios

////////////////////////////////////////////////////
// SUMA
////////////////////////////////////////////////////

public void Suma()
{  // Abre metodo Suma
int auxiliars = 0;
int suma = -1;
numero1 = (int)Math.pow(10,x - 1) + Aleatorios.nextInt((int)Math.pow(10, x) - (int)Math.pow(10, x -1));  
numero2 = (int)Math.pow(10,x - 1) + Aleatorios.nextInt((int)Math.pow(10, x) - (int)Math.pow(10, x -1));  

do 
{   // Abre do
if (0 != auxiliars)
Anima();
  
intentos++;
System.out.printf("\nCuanto es %d + %d?\n", numero1, numero2);
suma = entrada.nextInt();
auxiliars++;
} while (( numero1 + numero2 != suma ) && (10 > auxiliars));

if ( numero1 + numero2 == suma)
{
Felicita();
aciertos++;
}
else
System.out.println("\nDeberias pedir ayuda a tu profesor con este tipo de problemas.");
}   // Cierra metodo Suma

////////////////////////////////////////////////////
// RESTA
////////////////////////////////////////////////////

public void Resta()
{  // Abre metodo Resta
int auxiliarr = 0;
int resta;
numero1 = (int)Math.pow(10,x - 1) + Aleatorios.nextInt((int)Math.pow(10, x) - (int)Math.pow(10, x -1));  
numero2 = (int)Math.pow(10,x - 1) + Aleatorios.nextInt((int)Math.pow(10, x) - (int)Math.pow(10, x -1));  

do
{   // Abre while
if (0 != auxiliarr)
Anima();
intentos++;
System.out.printf("\nCuanto es %d - %d?\n", numero1, numero2);
resta = entrada.nextInt();
auxiliarr++;

}while (( numero1 - numero2 != resta) && (10 > auxiliarr));
if ( numero1 - numero2 == resta)
{ 
Felicita();
aciertos++;
}
else
  
System.out.println("\nDeberias pedir ayuda a tu profesor con este tipo de problemas.");

}   // Cierra metodo Resta

////////////////////////////////////////////////////
// MULTIPLICACION
/////////////////////////////////////////////////////

public void Multiplicacion()
{  // Abre metodo Multiplicacion
  
int auxiliarm = 0;
int multiplicacion;
numero1 = (int)Math.pow(10,x - 1) + Aleatorios.nextInt((int)Math.pow(10, x) - (int)Math.pow(10, x -1));  
numero2 = (int)Math.pow(10,x - 1) + Aleatorios.nextInt((int)Math.pow(10, x) - (int)Math.pow(10, x -1));  

do
{   // Abre while
if ( 0 != auxiliarm)
Anima();
intentos++;
System.out.printf("\nCuanto es %d * %d?\n", numero1, numero2);
multiplicacion = entrada.nextInt();
auxiliarm++;
  
}while( ( numero1 * numero2 != multiplicacion) && (10 > auxiliarm) );

if (numero1 * numero2 == multiplicacion)
{
Felicita();
aciertos++;
}
else
System.out.println("\nDeberias pedir ayuda a tu profesor con este tipo de problemas.");
}     // Cierra metodo multiplicacion

/////////////////////////////////////////////////////
// DIVISION
/////////////////////////////////////////////////////

public void Division()
{       // Abre metodo Division
int division;
int auxiliard = 0;
numero1 = (int)Math.pow(10,x - 1) + Aleatorios.nextInt((int)Math.pow(10, x) - (int)Math.pow(10, x -1));  
numero2 = (int)Math.pow(10,x - 1) + Aleatorios.nextInt((int)Math.pow(10, x) - (int)Math.pow(10, x -1));  

do
{   // Abre while
if ( 0 != auxiliard)
Anima();
intentos++;
System.out.printf("\nCuanto es %d / %d? (introduzca solo la parte entera) \n", numero1, numero2);
division = entrada.nextInt();
auxiliard++;
}while (( numero1 / numero2 != division) && (10 > auxiliard));
  
if (numero1/numero2 == division)
{
Felicita();
aciertos++;
}
else
System.out.println("\nDeberias pedir ayuda a tu profesor con este tipo de problemas.");
}      // Cierra metodo Division  

/*Este metodo felicita al usuario cuando da una respuesta
correcta*/

///////////////////////////////////////////////
// Metodo Felicita
///////////////////////////////////////////////

void Felicita()
{        // Abre metodo Felicita
int auxiliar; 
auxiliar = 1 + Aleatorios.nextInt(4);
switch (auxiliar) 
{     // Abre switch
case 1:
System.out.println("\nMuy bien!");
break;
case 2:
System.out.println("\nExcelente!");
break;
case 3:
System.out.println("\nBuen trabajo!");
break;
case 4:
System.out.println("\nSigue asi!");
break;
default:
System.out.println("\nRevise el Metodo Felicita!");
break;
}     // Cierra switch
}               // Cierra metodo Felicita

/*El siguiente metodo sirve para "animar" al estudiante
cada vez que cometa un error*/
///////////////////////////////////////////////////
// Metod Anima
///////////////////////////////////////////////////
public void Anima()
{         // Abre Anima
int auxiliar;
auxiliar = 1 + Aleatorios.nextInt(4);

switch (auxiliar) 
{     // Abre switch
case 1:
System.out.println("\nNo. Por favor intenta de nuevo!");
break;
case 2:
System.out.println("\nIncorrecto. Intenta una vez mas!");
break;
case 3:
System.out.println("\nNo te rindas!");
break;
case 4:
System.out.println("\nNo. Sigue intentando!");
break;
default:
System.out.println("\nRevise el Metodo Anima!");
break;
}
}       // Cierra Anima
}         // Cierra clase Deitel_6_35