Deitel_Java_7.16

7.16 Escriba una aplicación que utilice una instrucción for mejorada para sumar los valores double que se pasan mediante los argumentos de linea de comandos. [Sugerencia: Use el método static parseDouble de la clase Double para convertir un String en un valor double).

Solución:

 import java.util.Scanner;

 public class Deitel_7_16
 {      // Abre clase Deitel_7_16

 //////////////////////////////////////////////////////////
 // Main
 //////////////////////////////////////////////////////////

 public static void main(String args[])
 {        // Abre main
 Scanner entrada = new Scanner(System.in);
 int numero;
 double Arreglo[];

 System.out.println("\nPor favor introduzca el tamanio del arreglo: ");
 numero = entrada.nextInt();

 Arreglo = new double[numero];

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

 System.out.printf("\nEl producto de los numeros es: %.2f\n", Multiplicar(Arreglo));
 
 }        // Cierra main

 /////////////////////////////////////////////////////////
 // Metodo Multiplicar
 /////////////////////////////////////////////////////////

 public static double Multiplicar( double A[] )
 {  // Abre metodo Multiplicar
 double producto = 1;
 for ( int i = 0; i < A.length; i++ )
 producto *= A[i];

 return producto;
 }  // Cierra metodo Multiplicar
 }      // Cierra clase Deitel_7_16

Deitel_Java_7.15 (Inicialización de un Arreglo)

7.15 Modifique la figura 7.2 de manera que el tamaño del arreglo se especifique mediante el primer argumento de línea de comandos. Si no se suministra un argumento de linea de comandos, use 10 como el valor predeterminado del arreglo.

solución:

Java tiene una característica que no tienen C ni C++. Permite definir el tamaño de los arreglos mediante linea de comandos. En C y C++ tiene que hacerse mediante variables globales. También son diferentes los valores de inicialización de un arreglo en Java. En tanto que en C y C++ tienen valores "basura", en Java se inicializan a 0 de manera automática. También en los arreglos de varias dimensiones el tamaño de cada índice no tiene por qué ser igual a los demás.

import java.util.Scanner;

 public class Deitel_7_15 
 
 {   // Abre clase Deitel_7_15 
 public static void main(String args[])
 {       // Abre main
 Scanner entrada = new Scanner(System.in);
 int arreglo[];
 int numero = 10;

 System.out.println("\nPor favor introduzca el tamanio del arreglo.");
 numero = entrada.nextInt();
 
 arreglo = new int[numero];
 System.out.printf("%s%8s\n", "Indice", "Valor");
 
 // Imprime el valor de cada elemento del arreglo 
 for ( int contador = 0; contador < arreglo.length; contador++ )
 System.out.printf("%5d%8d\n", contador, arreglo[contador]);
 
 }       // Cierra main
 }   // Cierra clase Deitel_7_15 

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