08 enero, 2019

Estructuras repetitivas del lenguaje Java


Muchas veces al diseñar un programa se requiere repetir un conjunto de instrucciones u procesos para mostrar algún resultado u obtenerlos de algún lugar, ya sea leyendo información de algún archivo, una tabla de base de datos, en fin, cualquier proceso en la que la solución requiera una iteración.

Así, utilizando estructuras de repetición simple y anidada y los demás conceptos aprendidos en este curso básico de algoritmos, diseñaremos programas en Java que permitan resolver problemas que involucren instrucciones repetitivas.




En el tema anterior, vimos como diseñar programas que resuelvan problemas de conteo y acumulación, el cual nos servirá de base para aplicar los conceptos que veremos en este tema de estructuras repetitivas.


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!

¿Qué es una estructura repetitiva?


Las estructuras de repetición o también conocidas como bucles o iterativas, son aquellas estructuras en las que se puede repetir innumerables veces una o más instrucciones. Dicho de otro modo, nos va a permitir repetir una línea de código muchas veces. De esta manera, a las instrucciones a repetir se le conoce com+o el cuerpo del bucle y el hecho de repetir dichas instrucciones se le denomina iteración.

A continuación, conoceremos las estructuras while, do while y for del lenguaje Java.

La estructura while


La estructura while (mientras) permite repetir una acción, la cual puede ser una acción simple (una sola acción) o una acción compuesta (bloque de acciones encerradas entre llaves) siempre y cuando sea verdadera una determinada condición. En la siguiente imagen se puede ver el diagrama de flujo de la estructura. Recuerda que primero verifica la condición y después ejecuta la acción.

Diagrama de flujo de la estructura de repetición while
Código y pseudocódigo de la estructura de repetición while

La estructura do while


La estructura do while (hacer… mientras) permite repetir una acción, la cual puede ser una acción simple (es decir una sola acción) o una acción compuesta (bloque de acciones encerradas entre llaves), para lo cual primero ejecuta la acción y después verifica la condición. En la siguiente imagen se puede ver el diagrama de flujo de la estructura. Recuerda que primero se ejecuta la acción y después se verifica la condición por lo que siempre se ejecutará por lo menos una vez.

Diagrama de flujo de la estructura de repetición while

Código y pseudocódigo de la estructura de repetición do while

La estructura for


La estructura de repetición for contempla todos los elementos de la repetición controlada por contador (repetición en la que se conoce el número de veces que se repetirá el cuerpo del bucle) al incluir un contador como parte de la propia estructura.

Diagrama de flujo de la estructura de repetición for

Código y pseudocódigo de la estructura de repetición for

El contador del for puede ser declarado dentro del mismo for, en cuyo caso se considera como variable local al for, no siendo accesible fuera de él. De esta manera, en un mismo método dos o más for, no anidados, pueden declarar contadores con el mismo nombre. Cada contador existe dentro del for en el que fue declarado.

Número aleatorios enteros


Para generar un número aleatorio entero en el intervalo de min a max se usa la siguiente expresión:

n =(int)((max-min+1)*Math.random() + min);


A continuación, aplicaremos los conceptos vistos mediante un par de ejemplos y al finalizar les dejare un link para que puedan descargar un pack de ejercicios resueltos y puedan practicar en sus casas.

Problemas


Problema 1

Diseñe un programa que imprima la siguiente serie usando while, do while y for

1, 2, 3, ..., n

Programa


Usando while

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
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
// Sólución 01 - Usando while
public class Problema01a extends JApplet implements ActionListener {
 
 // Declaración de variables globales
 JButton btnProcesar, btnBorrar;
 JTextArea txtS;
 JLabel lblNumero;
 JTextField txtNumero;
 JScrollPane scpScroll;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario GUI
 public void init() {
  getContentPane().setLayout(null);
 
  txtNumero = new JTextField();
  txtNumero.setBounds(76, 15, 92, 23);
  getContentPane().add(txtNumero);
 
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(308, 15, 101, 23);
  btnBorrar.addActionListener(this);
  getContentPane().add(btnBorrar);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(205, 15, 101, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  lblNumero = new JLabel("Número");
  lblNumero.setBounds(15, 15, 56, 23);
  getContentPane().add(lblNumero);
 
  txtS = new JTextArea();
  txtS.setFont(new Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 53, 394, 143);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // 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() {
  txtNumero.setText("");
  txtS.setText("");
  txtNumero.requestFocus();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar() {
  // Declaración e inicialización de variables locales
  int n, termino = 1;
  // Lee el número n
  n = Integer.parseInt(txtNumero.getText());
  // Borra la pantalla
  txtS.setText("");
  // Bucle while
  while (termino <= n) {
   // Imprime el término actual
   txtS.append(termino + "\n");
   // Genera el siguiente término
   termino++;
  }
 }
}

Usando do while

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void procesar() {
 // Declaración e inicialización de variables locales
 int n, termino = 1;
 // Lee el número n
 n = Integer.parseInt(txtNumero.getText());
 // Borrar la pantalla
 txtS.setText("");
 // Bucle do...while
 do {
  // Imprime el término actual
  txtS.append(termino + "\n");
  // Genera el siguiente término
  termino++;
 } while (termino <= n);
}

Usando for

1
2
3
4
5
6
7
8
9
10
11
12
void procesar() {
 // Declaración de variables locales
 int n;
 // Lee el número n
 n = Integer.parseInt(txtNumero.getText());
 // Borra la pantalla
 txtS.setText("");
 // Bucle for
 for (int termino = 1; termino <= n; termino++)
  // Imprime el término actual
  txtS.append(termino + "\n");
}

Problema 2

Diseñe un programa que imprima una tabla de valores de x e y, para valores de x en el intervalo de 0 a 5 cada 0.25, siendo:



Programa


Usando while

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
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
import java.util.*;
 
// solución con while
public class Problema02a extends JApplet implements ActionListener {
 
 // Declaración de variables globales
 JButton btnProcesar;
 JTextArea txtS;
 JScrollPane scpScroll;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario GUI
 public void init() {
  getContentPane().setLayout(null);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(162, 15, 101, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  txtS = new JTextArea();
  txtS.setFont(new java.awt.Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 53, 394, 143);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnProcesar)
   procesar();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar() {
  // Declaración e inicialización de variables
  double x = 0, y;
  // Imprime la cabecera
  txtS.append(String.format(Locale.US, "%-15.2s%-15.2s\n", "x", "y"));
  // Imprime la tabla
  while (x <= 5) {
   // Calcula el valor de y para el valor actual de x
   y = (x * x * x + 3 * x + 1) / (x * x + 2);
   // Imprime la pareja de valores x e y
   txtS.append(String.format(Locale.US, "%-15.2f%-15.2f\n", x, y));
   // Incrementa x en 0.25
   x += 0.25;
  }
 }
}

Usando do while

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void procesar() {
 // Declaración e inicialización de variables
 double x = 0, y;
 // Imprime la cabecera
 txtS.append(String.format(Locale.US, "%-15.2s%-15.2s\n", "x", "y"));
 // Imprime la tabla
 do {
  // Calcula el valor de y para el valor actual de x
  y = (x * x * x + 3 * x + 1) / (x * x + 2);
  // Imprime la pareja de valores x e y
  txtS.append(String.format(Locale.US, "%-15.2f%-15.2f\n", x, y));
  // Incrementa x en 0.25
  x += 0.25;
 } while (x <= 5);
}

Usando for

1
2
3
4
5
6
7
8
9
10
11
12
13
void procesar() {
 // Declaración e inicialización de variables
 double y;
 // Imprime la cabecera
 txtS.append(String.format(Locale.US, "%-15.2s%-15.2s\n", "x", "y"));
 // Imprime la tabla
 for (double x = 0; x <= 5; x += 0.25) {
  // Calcula el valor de y para el valor actual de x
  y = (x * x * x + 3 * x + 1) / (x * x + 2);
  // Imprime la pareja de valores x e y
  txtS.append(String.format(Locale.US, "%-15.2f%-15.2f\n", x, y));
 }
}

Problema 3

Diseñe un programa que imprima la siguiente serie y halle su suma:
1/2 + 3/5 + 5/8 + 7/11 + ... (100 términos)

Programa


Usando while

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
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
// Solución con while
public class Problema03a extends JApplet implements ActionListener {
  
 // Declaración de variables globales
 JButton btnProcesar;
 JTextArea txtS;
 JScrollPane scpScroll;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario GUI
 public void init() {
  getContentPane().setLayout(null);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(162, 15, 101, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  txtS = new JTextArea();
  txtS.setFont(new java.awt.Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 53, 394, 143);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnProcesar)
   procesar();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar() {
  // Declaración de variables locales
  int numerador = 1, denominador = 2, contador = 0;
  double suma = 0;
  // Genera e imprime la serie
  while (contador < 100) {
   // Imprime el término actual de la serie
   txtS.append(numerador + "/" + denominador + "\n");
   // Suma el término actual
   suma += numerador * 1.0 / denominador;
   // Genera el numerador y el denominador de un nuevo término
   numerador += 2;
   denominador += 3;
   // Incrementa el contador de términos
   contador++;
  }
  // Imprime la suma
  txtS.append("\nSuma : " + suma);
 }
}

Usando do while
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void procesar() {
 // Declaración de variables locales
 int numerador = 1, denominador = 2, contador = 0;
 double suma = 0;
 // Genera e imprime la serie
 do {
  // Imprime el término actual de la serie
  txtS.append(numerador + "/" + denominador + "\n");
  // Suma el término actual
  suma += numerador * 1.0 / denominador;
  // Genera el numerador y el denominador de un nuevo término
  numerador += 2;
  denominador += 3;
  // Incrementa el contador de términos
  contador++;
 } while (contador < 100);
 // Imprime la suma
 txtS.append("\nSuma : " + suma);
}


Usando for

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void procesar() {
 // Declaración de variables locales
 int numerador = 1, denominador = 2;
 double suma = 0;
 // Genera e imprime la serie
 for (int contador = 0; contador < 100; contador++) {
  // Imprime el término actual de la serie
  txtS.append(numerador + "/" + denominador + "\n");
  // Suma el término actual
  suma += numerador * 1.0 / denominador;
  // Genera el numerador y el denominador de un nuevo término
  numerador += 2;
  denominador += 3;
 }
 // Imprime la suma
 txtS.append("\nSuma : " + suma);
}

Problema 4

Diseñe un programa que genere 6000 números aleatorios en el intervalo de 1000 a 9999 y determine cuántos números están en cada uno de los siguientes intervalos: 1000 a 1999, 2000 a 2999, 3000 a 3999, ..., 8000 a 8999, 9000 a 9999.

Programa


Usando for

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
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema04 extends JApplet implements ActionListener {
  
 // Declaración de variables globales
 JButton btnProcesar;
 JTextArea txtS;
 JScrollPane scpScroll;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario GUI
 public void init() {
  getContentPane().setLayout(null);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(162, 15, 101, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  txtS = new JTextArea();
  txtS.setFont(new java.awt.Font("monospaced", 0, 12));
 
  // scpScroll
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 53, 394, 143);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnProcesar)
   procesar();
 }
 
 // -----------------------------------------------------------------------
 // Imprime una línea de texto con un salto de línea
 void imprimir(String cad) {
  txtS.append(cad + "\n");
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar() {
  // Declaraciones locales
  int numero, c1 = 0, c2 = 0, c3 = 0, c4 = 0, c5 = 0, c6 = 0, c7 = 0, c8 = 0, c9 = 0;
  // Genera los 600 números aleatorios
  for (int i = 0; i < 6000; i++) {
   // Genera un número de 1000 a 9999
   numero = (int) ((9999 - 1000 + 1) * Math.random() + 1000);
   // Cuenta el número según el intervalo
   if (numero < 2000)
    c1++;
   else if (numero < 3000)
    c2++;
   else if (numero < 4000)
    c3++;
   else if (numero < 5000)
    c4++;
   else if (numero < 6000)
    c5++;
   else if (numero < 7000)
    c6++;
   else if (numero < 8000)
    c7++;
   else if (numero < 9000)
    c8++;
   else
    c9++;
  }
  // Imprime los contadores
  txtS.setText("");
  imprimir("1000 a 1999 : \t" + c1);
  imprimir("2000 a 2999 : \t" + c2);
  imprimir("3000 a 3999 : \t" + c3);
  imprimir("4000 a 4999 : \t" + c4);
  imprimir("5000 a 5999 : \t" + c5);
  imprimir("6000 a 6999 : \t" + c6);
  imprimir("7000 a 7999 : \t" + c7);
  imprimir("8000 a 8999 : \t" + c8);
  imprimir("9000 a 9999 : \t" + c9);
 }
}

Problema 5

Diseñe un programa que genere 6000 números aleatorios en el intervalo de 1000 a 9999 y determine cuántos números están en cada uno de los siguientes intervalos: 1000 a 1999, 2000 a 2999, 3000 a 3999, ..., 8000 a 8999, 9000 a 9999.

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
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema05 extends JApplet implements ActionListener {
 
 // Declaración de variables globales
 JButton btnProcesar;
 JTextArea txtS;
 JScrollPane scpScroll;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario GUI
 public void init() {
  getContentPane().setLayout(null);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(162, 15, 101, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  txtS = new JTextArea();
  txtS.setFont(new java.awt.Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 53, 394, 143);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnProcesar)
   procesar();
 }
 
 // -----------------------------------------------------------------------
 // Imprime una línea de texto con un salto de línea
 void imprimir(String cad) {
  txtS.append(cad + "\n");
 }
 
 // -----------------------------------------------------------------------
 // Método del botón procesar
 void procesar() {
  // Declaración de variables locales
  int dado1, dado2, conta = 0;
  // Simula el lanzamiento de los dados
  txtS.setText("");
  do {
   dado1 = (int) (6 * Math.random() + 1);
   dado2 = (int) (6 * Math.random() + 1);
   imprimir("Dado 1 : " + dado1 + "\tDado 2: " + dado2);
   conta++;
  } while (dado1 != 6 || dado2 != 6);
  // Imprime la cantidad de lanzamientos efectuados
  imprimir("Fueron necesarios " + conta + " lanzamientos");
 }
}

Problema 6

Diseñe un programa que genere números aleatorios en el intervalo de -1000 a 1000 hasta obtener un número par menor que 500 pero mayor que -500. ¿Cuántos números fueron necesarios generar y cuáles fueron el mayor y el menor número generados?

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
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema06 extends JApplet implements ActionListener {
 // Declaración de variables globales
 JButton btnProcesar;
 JTextArea txtS;
 JScrollPane scpScroll;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario GUI
 public void init() {
  getContentPane().setLayout(null);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(162, 15, 101, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  txtS = new JTextArea();
  txtS.setFont(new java.awt.Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 53, 394, 143);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnProcesar)
   procesar();
 }
 
 // -----------------------------------------------------------------------
 // Imprime una línea de texto con un salto de línea
 void imprimir(String cad) {
  txtS.append(cad + "\n");
 }
 
 // -----------------------------------------------------------------------
 // Método para el botón Procesar
 void procesar() {
  // Declaración de variables locales
  int numero, mayor = -1000, menor = 1000, conta = 1;
  // Generación de números
  txtS.setText("");
  do {
   // Genera un número aleatorio en el intervalo de -1000 y 1000
   numero = (int) (2001 * Math.random() - 1000);
   // Muestra y cuenta el número generado
   imprimir("Número " + conta + " : " + numero);
   conta++;
   // Actualiza el mayor y el menor
   if (numero > mayor)
    mayor = numero;
   if (numero < menor)
    menor = numero;
  } while (numero % 2 != 0 || numero <= -500 || numero >= 500);
  // Imprime resultados
  imprimir("Cantidad de números generados : " + conta);
  imprimir("Mayor número generado : " + mayor);
  imprimir("Menor número generado : " + menor);
 }
}

Problema 7

Un método para obtener el cociente y el resto de dos números enteros es por restas sucesivas. El método consiste en restar sucesivamente el divisor del dividendo hasta obtener un resultado menor que el divisor, que será el resto de la división; el número de restas efectuadas será el cociente. Diseñe un algoritmo que determine el cociente y el resto de dos números enteros.

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
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema07 extends JApplet implements ActionListener {
 // Declaración de variables globales
 JButton btnProcesar;
 JButton btnBorrar;
 JTextArea txtS;
 JLabel lblDivisor;
 JLabel lblDividendo;
 JTextField txtDivisor;
 JTextField txtDividendo;
 JScrollPane scpScroll;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario GUI
 public void init() {
  getContentPane().setLayout(null);
 
  lblDivisor = new JLabel("Divisor");
  lblDivisor.setBounds(15, 39, 58, 23);
  getContentPane().add(lblDivisor);
 
  lblDividendo = new JLabel("Dividendo");
  lblDividendo.setBounds(15, 15, 58, 23);
  getContentPane().add(lblDividendo);
 
  txtDividendo = new JTextField();
  txtDividendo.setBounds(80, 15, 107, 23);
  getContentPane().add(txtDividendo);
 
  txtDivisor = new JTextField();
  txtDivisor.setBounds(80, 39, 107, 23);
  getContentPane().add(txtDivisor);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(305, 15, 101, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  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, 100);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnProcesar)
   procesar();
  if (e.getSource() == btnBorrar)
   borrar();
 }
 
 // -----------------------------------------------------------------------
 // Método para el botón Borrar
 void borrar() {
  txtDivisor.setText("");
  txtDividendo.setText("");
  txtDivisor.requestFocus();
 }
 
 // -----------------------------------------------------------------------
 // Imprime una línea de texto con un salto de línea
 void imprimir(String cad) {
  txtS.append(cad + "\n");
 }
 
 // -----------------------------------------------------------------------
 // Método para el botón Procesar
 void procesar() {
  // Declaración de variables locales
  int dividendo, divisor, cociente, resto;
  // Ingreso del Divisor y del Dividendo
  divisor = Integer.parseInt(txtDivisor.getText());
  dividendo = Integer.parseInt(txtDividendo.getText());
  // Inicializa el resto y el cociente
  resto = dividendo;
  cociente = 0;
  // Determina el resto y el cociente
  while (resto >= divisor) {
   resto -= divisor;
   cociente++;
  }
  // Imprime el resto y el cociente
  txtS.setText("");
  imprimir("El cociente es : " + cociente);
  imprimir("El resto es : " + resto);
 }
}

Problema 8

Diseñe un programa que lea un número entero positivo n mayor que 10 e imprima todos los puntos del plano cartesiano que cumplan con la condición: x + y < n.

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
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema08 extends JApplet implements ActionListener {
 // Declaración de variables globales
 JButton btnProcesar, btnBorrar;
 JTextArea txtS;
 JLabel lblNumero;
 JTextField txtNumero;
 JScrollPane scpScroll;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario GUI
 public void init() {
  getContentPane().setLayout(null);
 
  txtNumero = new JTextField();
  txtNumero.setBounds(76, 15, 92, 23);
  getContentPane().add(txtNumero);
 
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(308, 15, 101, 23);
  btnBorrar.addActionListener(this);
  getContentPane().add(btnBorrar);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(205, 15, 101, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  lblNumero = new JLabel("Número");
  lblNumero.setBounds(15, 15, 56, 23);
  getContentPane().add(lblNumero);
 
  txtS = new JTextArea();
  txtS.setFont(new Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 53, 394, 143);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // 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() {
  txtNumero.setText("");
  txtS.setText("");
  txtNumero.requestFocus();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar() {
  // Declaración de variables locales
  int n;
  // Lee el número n
  n = Integer.parseInt(txtNumero.getText());
  // Si n es correcto
  if (n > 10) {
   txtS.setText("");
   // Imprime los puntos del plano que cumplen: x + y < n
   for (int x = 1; x < n; x++)
    for (int y = 1; x + y < n; y++)
     txtS.append(x + "\t" + y + "\t" + (x + y) + "\n");
  } else
   txtS.setText("El número tiene que ser mayor que 10");
 }
}

Problema 9

Imprime un rectángulo de altura n y ancho 2n relleno de asteriscos. Así, para n igual a 5, el programa deberá imprimir un rectángulo de 10 asteriscos de ancho por 5 asteriscos de alto como el que se muestra a continuación:

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

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
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema09 extends JApplet implements ActionListener {
 // Declaración de variables globales
 JButton btnProcesar, btnBorrar;
 JTextArea txtS;
 JLabel lblNumero;
 JTextField txtNumero;
 JScrollPane scpScroll;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario GUI
 public void init() {
  getContentPane().setLayout(null);
 
  txtNumero = new JTextField();
  txtNumero.setBounds(76, 15, 92, 23);
  getContentPane().add(txtNumero);
 
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(308, 15, 101, 23);
  btnBorrar.addActionListener(this);
  getContentPane().add(btnBorrar);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(205, 15, 101, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  lblNumero = new JLabel("Número");
  lblNumero.setBounds(15, 15, 56, 23);
  getContentPane().add(lblNumero);
 
  txtS = new JTextArea();
  txtS.setFont(new Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 53, 394, 143);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // 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() {
  txtNumero.setText("");
  txtS.setText("");
  txtNumero.requestFocus();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar() {
  // Declaración de variables locales
  int n;
  // Lee el número n
  n = Integer.parseInt(txtNumero.getText());
  // Borra el JTextArea por si no fue borrado
  txtS.setText("");
  // Imprime el rectángulo
  for (int i = 0; i < n; i++) {
   for (int j = 0; j < 2 * n; j++)
    txtS.append("*");
   txtS.append("\n");
  }
 }
}

Problema 10

Diseñe un programa que muestre por pantalla todos los números de 4 cifras que cumplen con la condición de que la suma de las cifras pares es igual a la suma de las cifras impares. Muestre también la cantidad de números encontrados.

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
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema10 extends JApplet implements ActionListener {
 // Declaración de variables miembro
 JButton btnProcesar;
 JTextArea txtS;
 JScrollPane scpScroll;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario
 public void init() {
  getContentPane().setLayout(null);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(168, 15, 100, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  txtS = new JTextArea();
  txtS.setFont(new Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 53, 406, 150);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnProcesar)
   procesar();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar() {
  // Declaración de variables
  int sumaCifPares, sumaCifImpares, cifra, copiaNumero, cantidad = 0;
   
  // Muestra los números solicitados
  txtS.setText("");
  for (int numero = 1000; numero <= 1005; numero++) {
   copiaNumero = numero;
   sumaCifImpares = 0;
   sumaCifPares = 0;
   do {
    cifra = copiaNumero % 10;
    if (cifra % 2 == 0)
     sumaCifPares += cifra;
    else
     sumaCifImpares += cifra;
    copiaNumero /= 10;
   } while (copiaNumero != 0);
   if (sumaCifPares == sumaCifImpares) {
    txtS.append(numero + "\n");
    cantidad++;
   }
  }
  txtS.append("Cantidad de números : " + cantidad);
 }
}

Problema 11

Diseñe un algoritmo que determine la cantidad de divisores pares de un número natural.

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
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema11 extends JApplet implements ActionListener {
 // Declaración de variables globales
 JButton btnProcesar, btnBorrar;
 JTextArea txtS;
 JLabel lblNumero;
 JTextField txtNumero;
 JScrollPane scpScroll;
 
 // -----------------------------------------------------------------------
 // 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(105, 15, 100, 23);
  getContentPane().add(txtNumero);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(365, 15, 100, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(265, 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, 450, 150);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // 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() {
  txtNumero.setText("");
  txtS.setText("");
  txtNumero.requestFocus();
 }
 
 // -----------------------------------------------------------------------
 // Imprime una línea de texto con un salto de línea
 void imprimir(String cad) {
  txtS.append(cad + "\n");
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar() {
  // Declaración e inicialización de variables locales
  int contadiv = 0, numero;
  // Ingresa el número
  numero = Integer.parseInt(txtNumero.getText());
  // Determina la cantidad de divisores pares
  for (int divisor = 2; divisor <= numero; divisor += 2)
   if (numero % divisor == 0) {
    contadiv++;
    imprimir(divisor + "");
   }
  // Imprime la cantidad de divisores pares
  imprimir("Cantidad de divisores pares : " + contadiv);
 }
}

Problema 12

Diseñe un algoritmo que genere 200 números aleatorios en el intervalo de 100 a 999 y determine la cantidad de números capicúas generados. Un número es capicúa si lee igual de derecha a izquierda que de derecha a izquierda. Así, por ejemplo, 343 es capícua; pero, 367 no lo es.

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
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
 
public class Problema12 extends JApplet implements ActionListener {
 // Declaración de variables globales
 JButton btnProcesar;
 JTextArea txtS;
 JScrollPane scpScroll;
 
 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario
 public void init() {
  getContentPane().setLayout(null);
 
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(190, 15, 100, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
 
  txtS = new JTextArea();
  txtS.setFont(new Font("monospaced", 0, 12));
 
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 53, 450, 150);
  getContentPane().add(scpScroll);
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  if (e.getSource() == btnProcesar)
   procesar();
 }
 
 // -----------------------------------------------------------------------
 // Imprime una línea de texto con un salto de línea
 void imprimir(String cad) {
  txtS.append(cad + "\n");
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar() {
  // Declaración e inicialización de variables locales
  int conta = 0, numero, unidades, millares;
  // Borra la pantalla
  txtS.setText("");
  // Genera 200 números de 100 a 999 y cuenta cuantos son capicúas
  for (int i = 0; i < 200; i++) {
   // Genera un número aleatorio en el intervalo de 100 a 999
   numero = (int) (900 * Math.random() + 100);
   // Muestra el número generado
   imprimir(numero + "");
   // Obtiene las cifras de las unidades y de los millares
   unidades = numero % 10;
   millares = numero / 1000;
   // Como el número tiene tres cifras, si la cifra de las unidades
   // es igual a la de los millares, entonces es capícua
   if (unidades == millares)
    conta++;
  }
  // Imprime la cantidad de capicúas
  imprimir("Cantidad de números capicuas : " + conta);
 }
}

Problema 13

for que imprime la siguiente tabla:

10 30
11 29
12 28
13 27
14 26
15 25
16 24
17 23
18 22
19 21
20 20

Código Fuente

1
2
3
for( int i = 10, j = 30; i <= 20; i++, j-- )
 
       txtS.append( i + "\t" + j + "\n" );

Descargar ejercicios resueltos


 Descargar archivo

Puedes completar lo aprendido asistiendo el material en video.

   Clic aquí

¡Acabas de ver el tema número 24 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

2 comentarios:

  1. theluiguimex15 de marzo de 2021, 1:09 p.m.

    Esto me ayudo mucho para mi tarea, pero algunas imágenes no se ven, como las de diagrama de flujo y pseudocodigos, aun así muchas gracias :D

    ResponderBorrar
  2. Unknown20 de octubre de 2021, 1:26 p.m.

    Tengo una duda con el problema 10, al momento de ejecutar me sale que la cantidad de numeros es 0 y los numeros de 4 cifras de forma aleatoria tampoco aparece

    ResponderBorrar

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