03 enero, 2019

Contadores y Acumuladores en Java


Muchas veces un programa requiere que pueda acumular el número de veces que se cumple una determinada condición y en otras totalizar cantidades de una misma especie como por ejemplo, determinar el número de notas aprobadas o el monto total vendido del día.

Así, en el tema de hoy diseñaremos programas en Java que permitan resolver problemas que involucren conteo y acumulación




Anteriormente, en otras publicaciones como parte del tema de programación modular habíamos resueltos problemas usando descomposición modular mediante métodos tipo void y métodos con valor de retorno.


Así como las estructuras de selección if, if else, if else if, switch aprendidas en el curso.


Estos posts te servirán tanto si estás empezando de cero en el mundo de la programación, si eres estudiante de primer año y necesitas reforzar algunos temas, o si eres un curioso que le entró la duda y las ganas de aprender a programar. Sea el motivo que fuese por lo que estás aquí, te invito a seguir esta serie de publicaciones que estaré realizando, en donde aprenderás con los temas que te vaya enseñando lo básico de la programación para que puedas realizar tú mismo tus propios programas.

¡Comencemos!

Así como en C++, C# que son lenguajes de programación tipo C. Java ofrece operadores para incrementar una variable en una cantidad dada.

¿Qué son los operadores de incremento y decremento?


Son operadores que permiten incrementar o decrementar en una unidad el valor de una variable numérica como se puede apreciar en el siguiente cuadro.

Operadores de incremento y decremento

Ejemplo

1
2
3
4
5
6
7
8
// Incrementa en uno el valor de x (Forma 1)
x = x + 1;
// Incrementa en uno el valor de x (Forma 2)
x++;
// Decrementa en 1 el valor de la variable z (Forma 1)
z = z - 1;
// Decrementa en 1 el valor de la variable z (Forma 2)
z--;

Ejemplos de operadores de incremento y decremento

Los operadores de incremento y decremento se pueden usar de manera aislada, tanto en sus variantes posfija o prefija, pero si se usan dentro de alguna expresión, las variaciones postfijas y prefijas tiene un resultado distinto.

Así, en la forma posfija o pos-incremento (a++), el valor de la variable en cuestión dentro de la expresión no cambia, y una vez la expresión se ha evaluado, se aplica el operador sobre ella. Por el contrario, en la notación prefija o pre-incremento (++a), la variable se incrementa previamente a la evaluación de la expresión donde se encuentra.

¿Qué son los operadores de asignación compleja?


Son operadores que permiten asignar a una variable el valor de la variable más, menos, por, entre, porcentaje el valor de otra variable como se puede apreciar en el siguiente cuadro.

Operadores de asignación compleja

Ejemplo

1
2
3
4
5
6
7
8
// Incrementa en 2 el valor de la variable z (Forma 1)
z = z + 2;
// Incrementa en 2 el valor de la variable z (Forma 2)
z += 2;
// Decrementa en 5 el valor de la variable m (Forma 1)
m = m - 5;
// Decrementa en 5 el valor de la variable m (Forma 2)
m -= 5;

Ya sabiendo para que sirven los operadores de incremento-decremento y los operadores de asignación compleja, pasaremos a definir los conceptos de contadores y acumuladores.

¿Qué es un contador?


Un contador es una variable que se utiliza para contar el número de ocurrencias de un suceso o el número de veces que se cumple una determinada condición.

Por ejemplo, se necesita un contador para determinar:

- El número de veces que se hizo clic en un botón.
- El número de notas ingresadas.
- El número de notas aprobatorias.
- El número de notas desaprobatorias.
- Cuantos números mayores a 15 hay en una lista.
- Etc.

Una instrucción de conteo tiene la siguiente forma:

contador = contador +1;


Que puede escribirse también como:

contador++;


Ejemplo

1
2
3
4
// Incrementa el número de alumnos aprobados de una sección
aprobados++;
// Incrementa el número de ventas efectuadas en un día
numeroVentasDia++;

¿Qué es un acumulador?


Un acumulador es una variable que se utiliza para acumular o totalizar cantidades de una misma especie.

Por ejemplo, se necesita un acumulador para determinar:

- El sueldo total de los empleados de una empresa.
- La edad total de un conjunto de personas.
- La suma de las notas de un alumno.
- Etc.

Una instrucción de acumulación tiene la siguiente forma:

acumulador = acumulador + cantidad;

Qué puede escribirse también como:

acumulador += cantidad;

Ejemplo

1
2
3
4
// Incrementa el monto total vendido
montoTotalVendido += montoVenta;
// Incrementa el sueldo total de los empleados de una empresa
sueldoTotalEmpresa += sueldoEmpleado;

Ahora pasaremos a aplicar los conceptos vistos mediante la resolución de un par de problemas y al final del post como en todos los posts les compartiré un link que contiene un pack de ejercicios resueltos para que puedan descargarlo y así también puedan practicar en sus casas..

Problemas


Problema 1

Diseñe un programa que permita ingresar, mediante un botón y de uno en uno, los sueldos de los empleados de una empresa y muestre luego de cada ingreso la cantidad de sueldos ingresados, el mayor y el menor sueldo ingresado y, el sueldo promedio.

Programa


Código Fuente Modo 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
package problemas_resueltos;
 
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema01a extends JApplet implements ActionListener {
 
 // Declaración de variables globales para la GUI
 JButton btnIngresar, btnBorrar;
 JTextArea txtS;
 JLabel lblSueldo;
 JTextField txtSueldo;
 JScrollPane scpScroll;
 
 // Declaración de variables globales para el algoritmo
 int contaSuel = 0;
 double suelMay, suelMen, suelTot = 0, suelProm;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario
 public void init() {
  getContentPane().setLayout(null);
 
  txtSueldo = new JTextField();
  txtSueldo.setBounds(70, 15, 100, 23);
  getContentPane().add(txtSueldo);
 
  btnIngresar = new JButton("Ingresar");
  btnIngresar.setBounds(321, 15, 100, 23);
  btnIngresar.addActionListener(this);
  getContentPane().add(btnIngresar);
 
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(220, 15, 100, 23);
  btnBorrar.addActionListener(this);
  getContentPane().add(btnBorrar);
 
  lblSueldo = new JLabel("Sueldo");
  lblSueldo.setBounds(15, 15, 90, 23);
  getContentPane().add(lblSueldo);
 
  txtS = new JTextArea();
  txtS.setFont(new Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 53, 406, 110);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnIngresar)
   procesar();
  if (e.getSource() == btnBorrar)
   borrar();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Borrar
 void borrar() {
  txtSueldo.setText("");
  txtSueldo.requestFocus();
  txtS.setText("");
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar() {
  double sueldo;
  sueldo = getSueldo();
  registrarEmpleado(sueldo);
  mostrarReporte();
 }
 
 // -----------------------------------------------------------------------
 // Lee y retorna el sueldo
 double getSueldo() {
  return Double.parseDouble(txtSueldo.getText());
 }
 
 // -----------------------------------------------------------------------
 // Registra el sueldo de un empleado
 void registrarEmpleado(double sueldo) {
  // Cuenta el sueldo ingresado
  contaSuel++;
  // Acumula el sueldo ingresado
  suelTot += sueldo;
  // Promedia el sueldo
  suelProm = suelTot / contaSuel;
  // Determina el mayor y el menor sueldo ingresados
  if (contaSuel == 1) {
   suelMay = sueldo;
   suelMen = sueldo;
  } else {
   if (sueldo > suelMay)
    suelMay = sueldo;
   if (sueldo < suelMen)
    suelMen = sueldo;
  }
 }
 
 // -----------------------------------------------------------------------
 // Imprime una cadena con un salto de línea
 void imprimir(String cad) {
  txtS.append(cad + "\n");
 }
 
 // -----------------------------------------------------------------------
 // Muestra el reporte
 void mostrarReporte() {
  txtSueldo.setText("");
  txtSueldo.requestFocus();
  txtS.setText("");
  imprimir("Sueldos ingresados : " + contaSuel);
  imprimir("Sueldo mayor : " + suelMay);
  imprimir("Sueldo menor : " + suelMen);
  imprimir("Sueldo promedio : " + suelProm);
 }
}

Código Fuente Modo 2

Usando Double.MAX_VALUE

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
package problemas_resueltos;
 
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema01b extends JApplet implements ActionListener {
 
 // Declaración de variables globales para la GUI
 JButton btnIngresar, btnBorrar;
 JTextArea txtS;
 JLabel lblSueldo;
 JTextField txtSueldo;
 JScrollPane scpScroll;
 
 // Declaración de variables globales para el algoritmo
 int contaSuel = 0;
 double suelMay = 0, suelMen = Double.MAX_VALUE, suelTot = 0, suelProm;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario
 public void init() {
  getContentPane().setLayout(null);
 
  txtSueldo = new JTextField();
  txtSueldo.setBounds(70, 15, 100, 23);
  getContentPane().add(txtSueldo);
 
  btnIngresar = new JButton("Ingresar");
  btnIngresar.setBounds(321, 15, 100, 23);
  btnIngresar.addActionListener(this);
  getContentPane().add(btnIngresar);
 
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(220, 15, 100, 23);
  btnBorrar.addActionListener(this);
  getContentPane().add(btnBorrar);
 
  lblSueldo = new JLabel("Sueldo");
  lblSueldo.setBounds(15, 15, 90, 23);
  getContentPane().add(lblSueldo);
 
  txtS = new JTextArea();
  txtS.setFont(new Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 53, 406, 110);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnIngresar)
   procesar();
  if (e.getSource() == btnBorrar)
   borrar();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Borrar
 void borrar() {
  txtSueldo.setText("");
  txtSueldo.requestFocus();
  txtS.setText("");
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar() {
  double sueldo;
  sueldo = getSueldo();
  registrarEmpleado(sueldo);
  mostrarReporte();
 }
 
 // -----------------------------------------------------------------------
 // Lee y retorna el sueldo
 double getSueldo() {
  return Double.parseDouble(txtSueldo.getText());
 }
 
 // -----------------------------------------------------------------------
 // Registra el sueldo de un empleado
 void registrarEmpleado(double sueldo) {
  // Cuenta el sueldo ingresado
  contaSuel++;
  // Acumula el sueldo ingresado
  suelTot += sueldo;
  // Promedia el sueldo
  suelProm = suelTot / contaSuel;
  // Determina el mayor y el menor sueldo ingresados
  if (sueldo > suelMay)
   suelMay = sueldo;
  if (sueldo < suelMen)
   suelMen = sueldo;
 }
 
 // -----------------------------------------------------------------------
 // Imprime una cadena con un salto de línea
 void imprimir(String cad) {
  txtS.append(cad + "\n");
 }
 
 // -----------------------------------------------------------------------
 // Muestra el reporte
 void mostrarReporte() {
  txtS.setText("");
  txtSueldo.setText("");
  txtSueldo.requestFocus();
  imprimir("Sueldos ingresados : " + contaSuel);
  imprimir("Sueldo mayor : " + suelMay);
  imprimir("Sueldo menor : " + suelMen);
  imprimir("Sueldo promedio : " + suelProm);
 }
}

Problema 2

En un peaje se desea saber cuántos vehículos de cada tipo pasaron por el peaje y la cantidad total de pasajeros por tipo de vehículo. Los tipos de vehículos a considerar son: automóvil, camión, camioneta, ómnibus y otros.

Programa


Código Fuente

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
package problemas_resueltos;
 
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema02 extends JApplet implements ActionListener {
 
 // Declaración de variables globales para la GUI
 JButton btnRegistrar, btnBorrar;
 JTextArea txtS;
 JComboBox cboVehiculo;
 JLabel lblPasajeros, lblTipo;
 JTextField txtPasajeros;
 JScrollPane scpScroll;
 
 // Declaración de variables globales para el algoritmo
 int contaveh0 = 0, contaveh1 = 0, contaveh2 = 0, contaveh3 = 0, contaveh4 = 0;
 int totpasaj0 = 0, totpasaj1 = 0, totpasaj2 = 0, totpasaj3 = 0, totpasaj4 = 0;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario GUI
 public void init() {
  getContentPane().setLayout(null);
 
  lblPasajeros = new JLabel("Cantidad de pasajeros");
  lblPasajeros.setBounds(15, 39, 131, 23);
  getContentPane().add(lblPasajeros);
 
  lblTipo = new JLabel("Tipo de vehículo");
  lblTipo.setBounds(15, 15, 105, 23);
  getContentPane().add(lblTipo);
 
  txtPasajeros = new JTextField();
  txtPasajeros.setBounds(149, 39, 119, 23);
  getContentPane().add(txtPasajeros);
 
  cboVehiculo = new JComboBox();
  cboVehiculo.setBounds(149, 15, 119, 23);
  cboVehiculo.addItem("Automovil");
  cboVehiculo.addItem("Camión");
  cboVehiculo.addItem("Camioneta");
  cboVehiculo.addItem("Omnibus");
  cboVehiculo.addItem("Otros");
  getContentPane().add(cboVehiculo);
 
  btnRegistrar = new JButton("Registrar");
  btnRegistrar.setBounds(305, 15, 101, 23);
  btnRegistrar.addActionListener(this);
  getContentPane().add(btnRegistrar);
 
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(305, 39, 101, 23);
  btnBorrar.addActionListener(this);
  getContentPane().add(btnBorrar);
 
  txtS = new JTextArea();
  txtS.setFont(new Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 75, 394, 120);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnRegistrar)
   procesar();
  if (e.getSource() == btnBorrar)
   borrar();
 }
 
 // -----------------------------------------------------------------------
 // Método para el botón Borrar
 void borrar() {
  txtPasajeros.setText("");
  txtPasajeros.requestFocus();
 }
 
 // -----------------------------------------------------------------------
 // Método para el botón Procesar
 void procesar() {
  int tipoveh, cantpasaj;
  tipoveh = getVehiculo();
  cantpasaj = getPasajeros();
  borrar();
  registrarVehiculo(tipoveh, cantpasaj);
  mostrarReporte();
 }
 
 // -----------------------------------------------------------------------
 // Lee y retorna el tipo de vehículo
 int getVehiculo() {
  return cboVehiculo.getSelectedIndex();
 }
 
 // -----------------------------------------------------------------------
 // Lee y retorna la cantidad de pasajeros
 int getPasajeros() {
  return Integer.parseInt(txtPasajeros.getText());
 }
 
 // -----------------------------------------------------------------------
 // Registra un vehículo
 void registrarVehiculo(int tipoveh, int cantpasaj) {
  switch (tipoveh) {
  case 0:
   contaveh0++;
   totpasaj0 += cantpasaj;
   break;
  case 1:
   contaveh1++;
   totpasaj1 += cantpasaj;
   break;
  case 2:
   contaveh2++;
   totpasaj2 += cantpasaj;
   break;
  case 3:
   contaveh3++;
   totpasaj3 += cantpasaj;
   break;
  default:
   contaveh4++;
   totpasaj4 += cantpasaj;
  }
 }
 
 // -----------------------------------------------------------------------
 // Imprime una cadena con un salto de línea
 void imprimir(String cad) {
  txtS.append(cad + "\n");
 }
 
 // -----------------------------------------------------------------------
 // Muestra el reporte
 void mostrarReporte() {
  txtS.setText("Vehículo\tCantidad\tPasajeros\n");
  imprimir("Automóvil" + "\t" + contaveh0 + "\t\t" + totpasaj0);
  imprimir("Camión   " + "\t" + contaveh1 + "\t\t" + totpasaj1);
  imprimir("Camioneta" + "\t" + contaveh2 + "\t\t" + totpasaj2);
  imprimir("Ómnibus  " + "\t" + contaveh3 + "\t\t" + totpasaj3);
  imprimir("Otros    " + "\t" + contaveh4 + "\t\t" + totpasaj4);
 }
}

Problema 3

Diseñe un programa que permita ingresar, mediante un botón y de uno en uno, números enteros mayores o iguales que 100 y pero menores o iguales que 900 y determine:

Cuántos números pertenecen a cada uno de los siguientes intervalos: 100 a 300, 301 a 500, 501 a 700 y 701 a 900.

El mayor y el menor número ingresados.

Programa


Código Fuente

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
package problemas_resueltos;
 
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema03 extends JApplet implements ActionListener {
 
 // Declaración de variables globales para la GUI
 JButton btnIngresar, btnBorrar;
 JTextArea txtS;
 JLabel lblNumero;
 JTextField txtNumero;
 JScrollPane scpScroll;
 
 // Declaración de variables globales para el algoritmo
 int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
 int mayor = 99, menor = 901;
 
 // Crea la interfaz gráfica de usuario
 public void init() {
  getContentPane().setLayout(null);
 
  lblNumero = new JLabel("Numero");
  lblNumero.setBounds(15, 15, 90, 23);
  getContentPane().add(lblNumero);
 
  txtNumero = new JTextField();
  txtNumero.setBounds(70, 15, 100, 23);
  getContentPane().add(txtNumero);
 
  btnIngresar = new JButton("Ingresar");
  btnIngresar.setBounds(321, 15, 100, 23);
  btnIngresar.addActionListener(this);
  getContentPane().add(btnIngresar);
 
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(220, 15, 100, 23);
  btnBorrar.addActionListener(this);
  getContentPane().add(btnBorrar);
 
  txtS = new JTextArea();
  txtS.setFont(new Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 53, 406, 130);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnIngresar)
   ingresar();
  if (e.getSource() == btnBorrar)
   borrar();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Borrar
 void borrar() {
  txtNumero.setText("");
  txtNumero.requestFocus();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Ingresar
 void ingresar() {
  int numero;
  numero = getNumero();
  if (numero >= 100 && numero <= 900) {
   contarNumero(numero);
   determinarMenor(numero);
   determinarMayor(numero);
   mostrarReporte();
   borrar();
  } else
   JOptionPane.showMessageDialog(this, "Ingrese un número de 100 a 900");
 }
 
 // -----------------------------------------------------------------------
 // Lee y retorna el número
 int getNumero() {
  return Integer.parseInt(txtNumero.getText());
 }
 
 // -----------------------------------------------------------------------
 // Cuenta el número ingresado
 void contarNumero(int numero) {
  if (numero <= 300)
   c1++;
  else if (numero <= 500)
   c2++;
  else if (numero <= 700)
   c3++;
  else
   c4++;
 }
 
 // -----------------------------------------------------------------------
 // Determina el menor número ingresado
 void determinarMenor(int numero) {
  if (numero < menor)
   menor = numero;
 }
 
 // -----------------------------------------------------------------------
 // Determina el mayor número ingresado
 void determinarMayor(int numero) {
  if (numero > mayor)
   mayor = numero;
 }
 
 // -----------------------------------------------------------------------
 // Imprime una cadena con un salto de línea
 void imprimir(String cad) {
  txtS.append(cad + "\n");
 }
 
 // -----------------------------------------------------------------------
 // Muestra el reporte
 void mostrarReporte() {
  txtS.setText("");
  imprimir("Cantidad de números de 100 a 300 : " + c1);
  imprimir("Cantidad de números de 301 a 500 : " + c2);
  imprimir("Cantidad de números de 501 a 700 : " + c3);
  imprimir("Cantidad de números de 701 a 900 : " + c4);
  imprimir("Número menor.....................: " + menor);
  imprimir("Número mayor.....................: " + mayor);
 }
}

Problema 4

Diseñe un programa para simular el movimiento de un almacén de bolsas de cemento.

Al comenzar la ejecución del programa, inicializar el stock de bolsas de cemento en

2000 bolsas y la capacidad del almacén en 3500 bolsas. Luego, el programa permitirá efectuar operaciones de depósito y de retiro, mostrando en todo momento:

- El stock actual del almacén.
- La capacidad libre del almacén.
- El número de depósitos y de retiros efectuados.
- La cantidad total de bolsas depositadas y retiradas.
- La cantidad máxima de bolsas retiradas y depositadas.
- La cantidad mínima de bolsas retiradas y depositadas.

Programa


Código Fuente

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
package problemas_resueltos;
 
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema04 extends JApplet implements ActionListener {
  
 // Declaración de variables globales para la GUI
 JButton btnBorrar, btnOperar;
 JTextArea txtS;
 JLabel lblCantidad, lblOperacion;
 JComboBox cboOperacion;
 JTextField txtCantidad;
 JScrollPane scpScroll;
  
 // Declaración de variables para el algoritmo
 int stock = 2000, capacidad = 3500;
 int contaret, contadep;
 int bolret, boldep;
 int maxret, minret, maxdep, mindep;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario GUI
 public void init() {
  getContentPane().setLayout(null);
 
  lblCantidad = new JLabel("Cantidad");
  lblCantidad.setBounds(15, 39, 60, 23);
  getContentPane().add(lblCantidad);
 
  lblOperacion = new JLabel("Operación");
  lblOperacion.setBounds(15, 15, 62, 23);
  getContentPane().add(lblOperacion);
 
  txtCantidad = new JTextField();
  txtCantidad.setBounds(85, 39, 106, 23);
  getContentPane().add(txtCantidad);
 
  cboOperacion = new JComboBox();
  cboOperacion.setBounds(85, 15, 106, 23);
  cboOperacion.addItem("Depósito");
  cboOperacion.addItem("Retiro");
  getContentPane().add(cboOperacion);
 
  btnOperar = new JButton("Operar");
  btnOperar.setBounds(276, 15, 134, 23);
  btnOperar.addActionListener(this);
  getContentPane().add(btnOperar);
 
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(276, 39, 134, 23);
  btnBorrar.addActionListener(this);
  getContentPane().add(btnBorrar);
 
  txtS = new JTextArea();
  txtS.setFont(new Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 77, 395, 192);
  getContentPane().add(scpScroll);
 
  txtS.setEditable(false);
  mostrarReporte();
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnOperar)
   operar();
  if (e.getSource() == btnBorrar)
   borrar();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Borrar
 void borrar() {
  txtCantidad.setText("");
  txtCantidad.requestFocus();
 }
 
 // -----------------------------------------------------------------------
 // Lee y retorna el tipo de operación
 int getOperacion() {
  return cboOperacion.getSelectedIndex();
 }
 
 // -----------------------------------------------------------------------
 // Lee y retorna la cantidad de bolsas
 int getCantidad() {
  return Integer.parseInt(txtCantidad.getText());
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Operar
 void operar() {
  int operacion, cantidad, caplibre;
  operacion = getOperacion();
  cantidad = getCantidad();
  limpiarEntrada();
  if (operacion == 0)
   depositar(cantidad);
  else
   retirar(cantidad);
  mostrarReporte();
 }
 
 // -----------------------------------------------------------------------
 // Retira una cantidad de bolsas del almacén
 void depositar(int cantidad) {
  if (cantidad <= capacidad - stock) {
   stock += cantidad;
   contadep++;
   boldep += cantidad;
   if (contadep == 1) {
    maxdep = cantidad;
    mindep = cantidad;
   } else {
    if (cantidad > maxdep)
     maxdep = cantidad;
    if (cantidad < mindep)
     mindep = cantidad;
   }
  } else
   JOptionPane.showMessageDialog(this, "Espacio libre insuficiente");
 }
 
 // -----------------------------------------------------------------------
 // Deposita una cantidad de bolsas al almacén
 void retirar(int cantidad) {
  if (cantidad <= stock) {
   stock -= cantidad;
   contaret++;
   bolret += cantidad;
   if (contaret == 1) {
    maxret = cantidad;
    minret = cantidad;
   } else {
    if (cantidad > maxret)
     maxret = cantidad;
    if (cantidad < minret)
     minret = cantidad;
   }
  } else
   JOptionPane.showMessageDialog(this, "Stock insuficiente");
 }
 
 // -----------------------------------------------------------------------
 // Muestra el reporte
 void mostrarReporte() {
  txtS.setText("");
  imprimir("Stock actual del almacén : " + stock);
  imprimir("Capacidad libre : " + (capacidad - stock));
  imprimir("Número de depósitos efectuados : " + contadep);
  imprimir("Número de retiros efectuados : " + contaret);
  imprimir("Cantidad de bolsas depositadas : " + boldep);
  imprimir("Cantidad de bolsas retiradas : " + bolret);
  imprimir("Cantidad máxima depositada : " + maxdep);
  imprimir("Cantidad mínima depositada : " + mindep);
  imprimir("Cantidad máxima retirada : " + maxret);
  imprimir("Cantidad mínima retirada : " + minret);
 }
 
 // -----------------------------------------------------------------------
 // Imprime una cadena con un salto de línea
 void imprimir(String cad) {
  txtS.append(cad + "\n");
 }
 
 // -----------------------------------------------------------------------
 // Limpia la caja de texto
 void limpiarEntrada() {
  txtCantidad.setText("");
  txtCantidad.requestFocus();
 }
}

Problema 5

Una empresa desarrolladora de software ha puesto a la venta licencias de su programa de edición de video Video Edit 2.0 a los siguientes costos unitarios:


Diseñe un programa que permita ingresar por cada venta el tipo de licencia y el número de licencias y muestre luego de cada venta:

- El importe a pagar para la venta efectuada.
- El importe total recaudado de cada tipo de licencia.
- El número de licencias vendidas de cada tipo de licencia.
- El número de ventas efectuadas de cada tipo de licencia.

Programa


Código Fuente

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
package problemas_resueltos;
 
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema05 extends JApplet implements ActionListener {
  
 // Declaración de variables globales para la GUI
 JButton btnProcesar, btnBorrar;
 JTextArea txtS1, txtS2;
 JScrollPane scpScroll1, scpScroll2;
 JLabel lblTipoLicencia, lblNumeroLicencias, lblActual, lblHistorico;
 JTextField txtNumeroLicencias;
 JComboBox cboTipo;
  
 // Declaración de variables globales para el algoritmo
 double imptot1 = 0, imptot2 = 0, imptot3 = 0, imptot4 = 0;
 int nlic1 = 0, nlic2 = 0, nlic3 = 0, nlic4 = 0;
 int nven1 = 0, nven2 = 0, nven3 = 0, nven4 = 0;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario
 public void init() {
  setLayout(null);
  setBackground(new Color(214, 211, 206));
 
  cboTipo = new JComboBox();
  cboTipo.setBounds(155, 15, 170, 23);
  cboTipo.addItem("Cobre");
  cboTipo.addItem("Bronze");
  cboTipo.addItem("Silver");
  cboTipo.addItem("Gold");
  add(cboTipo);
 
  txtNumeroLicencias = new JTextField();
  txtNumeroLicencias.setBounds(155, 39, 170, 23);
  add(txtNumeroLicencias);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(356, 15, 100, 23);
  btnProcesar.addActionListener(this);
  add(btnProcesar);
 
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(356, 39, 100, 23);
  btnBorrar.addActionListener(this);
  add(btnBorrar);
 
  lblTipoLicencia = new JLabel("Tipo de licencia");
  lblTipoLicencia.setBounds(15, 15, 140, 23);
  add(lblTipoLicencia);
 
  lblNumeroLicencias = new JLabel("Numero de licencias");
  lblNumeroLicencias.setBounds(15, 39, 140, 23);
  add(lblNumeroLicencias);
 
  lblActual = new JLabel("Venta Actual", JLabel.CENTER);
  lblActual.setBounds(15, 77, 441, 23);
  lblActual.setOpaque(true);
  lblActual.setFont(new Font("Dialog", Font.BOLD, 12));
  lblActual.setBackground(new Color(163, 184, 204));
  lblActual.setForeground(Color.black);
  add(lblActual);
 
  lblHistorico = new JLabel("Reporte Histórico", JLabel.CENTER);
  lblHistorico.setBounds(15, 215, 441, 23);
  lblHistorico.setOpaque(true);
  lblHistorico.setFont(new Font("Dialog", Font.BOLD, 12));
  lblHistorico.setBackground(new Color(163, 184, 204));
  lblHistorico.setForeground(Color.black);
  add(lblHistorico);
 
  txtS1 = new JTextArea();
  txtS1.setFont(new Font("monospaced", Font.PLAIN, 12));
 
  scpScroll1 = new JScrollPane(txtS1);
  scpScroll1.setBounds(15, 100, 441, 100);
  add(scpScroll1);
 
  txtS2 = new JTextArea();
  txtS2.setFont(new Font("monospaced", Font.PLAIN, 12));
 
  scpScroll2 = new JScrollPane(txtS2);
  scpScroll2.setBounds(15, 238, 441, 200);
  add(scpScroll2);
 }
 
 // ------------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnProcesar)
   procesar();
  if (e.getSource() == btnBorrar)
   borrar();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Borrar
 void borrar() {
  txtNumeroLicencias.setText("");
  txtS1.setText("");
  cboTipo.setSelectedIndex(0);
  txtNumeroLicencias.requestFocus();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar() {
  int tipo, numero;
  double imppag;
  tipo = getTipo();
  numero = getNumero();
  imppag = calcularImportePagar(tipo, numero);
  actualizarDatosHistoricos(tipo, numero, imppag);
  reportarVentaActual(tipo, numero, imppag);
  reportarDatosHistoricos();
 }
 
 // -----------------------------------------------------------------------
 // Lee y retorna el tipo de licencia
 int getTipo() {
  return cboTipo.getSelectedIndex();
 }
 
 // -----------------------------------------------------------------------
 // Lee y retorna el número de licencias
 int getNumero() {
  return Integer.parseInt(txtNumeroLicencias.getText());
 }
 
 // -----------------------------------------------------------------------
 // Calcula y retorna el importe a pagar
 double calcularImportePagar(int tipo, int numero) {
  switch (tipo) {
  case 0:
   return 510 * numero;
  case 1:
   return 1500 * numero;
  case 2:
   return 3100 * numero;
  default:
   return 4500 * numero;
  }
 }
 
 // -----------------------------------------------------------------------
 // Actualiza los datos históricos
 void actualizarDatosHistoricos(int tipo, int numero, double imppag) {
  switch (tipo) {
  case 0:
   imptot1 += imppag;
   nlic1 += numero;
   nven1++;
   break;
  case 1:
   imptot2 += imppag;
   nlic2 += numero;
   nven2++;
   break;
  case 2:
   imptot3 += imppag;
   nlic3 += numero;
   nven3++;
   break;
  default:
   imptot4 += imppag;
   nlic4 += numero;
   nven4++;
  }
 }
 
 // -----------------------------------------------------------------------
 // Muestra el reporte de la venta actual
 void reportarVentaActual(int tipo, int numero, double imppag) {
  String strTipo = (String) cboTipo.getItemAt(tipo);
  txtS1.setText("");
  imprimir1("Tipo de licencia..........: " + strTipo);
  imprimir1("Número de licencias.......: " + numero);
  imprimir1("Importe a pagar...........: " + imppag);
 }
 
 // -----------------------------------------------------------------------
 // Muestra el reporte de los datos histórico
 void reportarDatosHistoricos() {
  txtS2.setText("");
  imprimir2("Importe total recaudado");
  imprimir2(" Por licencias Cobre....: " + imptot1);
  imprimir2(" Por licencias Bronze...: " + imptot2);
  imprimir2(" Por licencias Silver...: " + imptot3);
  imprimir2(" Por licencias Gold.....: " + imptot4);
  imprimir2("");
  imprimir2("Número de licencias vendidas");
  imprimir2(" Por licencias Cobre....: " + nlic1);
  imprimir2(" Por licencias Bronze...: " + nlic2);
  imprimir2(" Por licencias Silver...: " + nlic3);
  imprimir2(" Por licencias Gold.....: " + nlic4);
  imprimir2("");
  imprimir2("Número de ventas efectuadas");
  imprimir2(" Por licencias Cobre....: " + nven1);
  imprimir2(" Por licencias Bronze...: " + nven2);
  imprimir2(" Por licencias Silver...: " + nven3);
  imprimir2(" Por licencias Gold.....: " + nven4);
 }
 
 // -----------------------------------------------------------------------
 // Imprime una cadena con un salto de línea en txtS1
 void imprimir1(String cad) {
  txtS1.append(cad + "\n");
 }
 
 // -----------------------------------------------------------------------
 // Imprime una cadena con un salto de línea en txtS2
 void imprimir2(String cad) {
  txtS2.append(cad + "\n");
 }
}

Para recordar


- Los operadores de incremento y decremento en lenguajes tipo C como C++, C#, Java tienen 2 variantes prefija y posfija el cual dependiendo del uso en una expresión tendrá un resultado diferente.
- Los operadores de asignación compleja permiten asignar a una variable el valor de la variable +, -, *, /, % el valor de otra variable.
- Los contadores y los acumuladores se utilizan para contar el número de ocurrencias de un suceso y totalizar cantidades de una misma especie.

Descargar ejercicios resueltos


 Descargar archivo

Puedes completar lo aprendido asistiendo el material en video.

   Clic aquí

¡Acabas de ver el tema número 23 del curso de Introducción a la Algoritmia y a la programación en Java! ¡Fácil verdad! Ir al índice
¡Qué pases un buen día!

Corre la voz

3 comentarios:

  1. milena5 de junio de 2020, 10:19 a.m.

    Gracias me ayudaron bastante <3

    ResponderBorrar
    Respuestas
    1. Josel Toro28 de junio de 2020, 12:57 p.m.

      ¡Muchas gracias! Te invito a seguir el blog, cada semana se sube nuevo contenido y material gratuito que te pueden ser de gran utilidad. Saludos.

      Borrar
  2. max28 de octubre de 2020, 5:17 p.m.

    disculpa amigo gracias por el tutorial.
    hay alguna manera de ejecutarlo desde consola?

    ResponderBorrar

Suscribirse a: Comentarios de la entrada (Atom)
joseltoro© 2019 Todos los derechos reservados