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.

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

Métodos con valor de retorno

Cuando comenzábamos a diseñar nuestros primeros programas, normalmente toda la tarea lo hacíamos en un solo método, sin embargo, al encontrarnos con tareas cada vez más complejas o grandes se hace engorroso tener que trabajarlo todo en un solo método, para lo cual debemos de aplicar la técnica de descomposición modular.

Asi, en el tema de hoy utilizando descomposición en módulos mediante métodos con valor de retorno y las estructuras básicas y de selección, diseñaremos programas en Java que resuelvan problemas planteados.

Métodos tipo void

Cuando comenzábamos a diseñar nuestros primeros programas, normalmente toda la tarea lo hacíamos en un solo método, sin embargo, al encontrarnos con tareas cada vez más complejas o grandes se hace engorroso tener que trabajarlo todo en un solo método, para lo cual debemos de aplicar la técnica de descomposición modular.

Asi, en el tema de hoy utilizando descomposición en módulos mediante métodos tipo void y las estructuras básicas y de selección, diseñaremos programas en Java que resuelvan problemas planteados.

¿Qué son las variables locales y globales?

Hola amigos, en esta publicación como parte del tema de programación modular, también es importante saber el concepto de variables locales y globales. En la publicación anterior, habíamos dicho que en el lenguaje Java los módulos o subprogramas se le denominaban métodos, mientras que en el lenguaje algorítmico se le denominaban subalgoritmos. 

Los métodos pueden utilizar sus propias variables denominadas variables locales o variables de uso compartido, comunes a todos los métodos, denominadas variables globales. 

Variables Locales 

Una variable local es una variable que se declara en el interior de un método por lo que su ámbito es el interior del método, es decir, sólo puede ser utilizada dentro del método donde fue declarada. Este tipo de variable se crea al iniciar la ejecución del método y se destruye al finalizar. Por otro lado, una variable local se crea vacía, es decir no recibe ninguna inicialización automática. 

Variables Globales 

Una variable global es una variable que se declara dentro del programa, pero en el exterior de todos los métodos, por lo que su ámbito es el interior de todo el programa, es decir, puede ser utilizada desde cualquier parte del programa. Este tipo de variable se crea al iniciar la ejecución del programa y se destruye al finalizar. Por otro lado, una variable global se inicializa automáticamente: 0 si es de tipo int, 0.0 si es de tipo double, false si es de tipo bolean, ‘\0’ si es de tipo char y null si es de tipo String. 

Entendiendo el concepto de programación modular y los conceptos de variables locales y globales es que en la siguiente publicación hablaremos sobre el uso del método tipo void y el método com valor de retorno como parte del tema de programación modular.

Cualquier consulta pueden dejarla en la sección de comentarios.

Programación modular

Cuando comenzamos a crear nuestros primeros programas debemos tener en cuenta que no podemos sobrecargar nuestro programa de tareas, por lo cual existe una técnica en programación que consiste en dividir un programa grande y sus tareas en pequeños subprogramas.

Así, en el tema de hoy hablaremos sobre la programación modular o también conocida como la técnica de divide y vencerás.

En los temas anteriores habíamos visto el uso de las estructuras secuenciales y de las estructuras de selección: if, if...else, if…else…if y switch, y también habíamos resuelto muchos ejercicios que ustedes pueden descargar de manera gratuita.

Estructura de Selección Múltiple switch

Continuando con las estructuras algorítmicas de selección. Hoy veremos el uso de la estructura de selección múltiples switch, el cual nos va a permitir crear programas que resuelvan problemas que involucren tomas de decisiones.

Así, en el tema de hoy vamos a diseñar algoritmos en pseudocódigo y en Java que permitan resolver problemas que involucren tomas de decisión haciendo uso de la estructura de selección múltiple switch.

La estructura de selección doble encadenada if...else...if

Continuando con las estructuras algorítmicas de selección. Hoy veremos el uso de la estructura de selección doble encadenada If...else...if, el cual nos va a permitir crear programas que resuelvan problemas que involucren tomas de decisiones.

Así, en el tema de hoy vamos a diseñar algoritmos en pseudocódigo y en Java que permitan resolver problemas que involucren tomas de decisión haciendo uso de la estructura de selección doble encadenada if else if.

Ejercicios Resueltos de Estructura de Selección Doble IF...ELSE en Java

PROBLEMAS RESUELTOS

Problema 1

Una tienda han puesto en oferta la venta por docenas de cierto tipo de producto ofreciendo un descuento del 15% por la compra de no menos de 6 docenas y 10% en caso contrario. Adicionalmente la empresa ofrece un obsequio de 2 lapiceros por cada 3 docenas por la compra de no menos 30 docenas del producto; en caso contrario, no efectúa ningún obsequio. Diseñe un programa que determine el monto de la compra, el monto del descuento, el monto a pagar y la cantidad de lapiceros de obsequio por la compra de cierta cantidad de docenas del producto.

Algoritmo

Inicio
// Declaración de variables
entero docenas, obsequio
real montocom, montodes, montopag, precio
// Entrada de datos
Leer docenas, precio
// Calcula el monto de la compra
montocom = docenas*precio
// Calcula el monto del descuento
si(docenas >= 6)
montodes = 0.15*montocom
sino
montodes = 0.10*montocom
// Calcula el monto a pagar
montopag = montocom - montodes
// Calcula el número de lapiceros de obsequio
si(docenas >= 30)
obsequio = 2*(docenas/3)
sino
obsequio = 0
// Salida de resultados
Imprimir montocom, montodes, montopag, obsequio
Fin

Programa 

Código Fuente

// Importamos librerías
import java.awt.event.*; // Implementar los eventos de acción del programa
import java.awt.*; // Implementar los widgets más usados
import javax.swing.*; // Mejora del paquete awt

// Creamos una clase que herede de JApplet e implementamos los tipos de escuchadores que ocupemos
public class Problema1 extends JApplet implements ActionListener {
 // Declaración de variables
 JLabel lblDocenas,lblPrecio;
 JTextField txtDocenas,txtPrecio;
 JButton btnProcesar,btnBorrar;
 JTextArea txtArea;
 JScrollPane scpScroll;
 //--------------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario 
 public void init() {
  getContentPane().setLayout(null); // Nosotros definimos la posición y el tamaño de los componentes
  
  lblDocenas = new JLabel("Docenas:");
  lblDocenas.setBounds(15,15,70,23);
  getContentPane().add(lblDocenas);
  
  txtDocenas = new JTextField();
  txtDocenas.setBounds(80,15,50,23);
  getContentPane().add(txtDocenas);
  
  lblPrecio = new JLabel("Precio:");
  lblPrecio.setBounds(15,39,70,23);
  getContentPane().add(lblPrecio);
  
  txtPrecio = new JTextField();
  txtPrecio.setBounds(80,39,50,23);
  getContentPane().add(txtPrecio);
  
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(305,15,101,23);
  btnProcesar.addActionListener(this); // Al presionar se disparadá el evento de acción (actionPerformed)
  getContentPane().add(btnProcesar);
  
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(305,39,101,23);
  btnBorrar.addActionListener(this); // Al presionar se disparadá el evento de acción (ActionPerformed)
  getContentPane().add(btnBorrar);
  
  txtArea = new JTextArea();
  txtArea.setFont(new Font("monospaced",0,12));
  
  scpScroll = new JScrollPane(txtArea);
  scpScroll.setBounds(15,70,394,130);
  getContentPane().add(scpScroll);
 }
 //--------------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed( ActionEvent e ){ // Recibe como parámetro el evento que tuvo lugar la acción
  if (e.getSource() == btnProcesar){
   /// Declaración de variables
   int docenas,obsequio;
   double precio,icompra,idescuento=0,ipagar;
   // Entrada de datos
   docenas = Integer.parseInt(txtDocenas.getText());
   precio = Double.parseDouble(txtPrecio.getText());
   // Cálculo del importe de la compra
   icompra = docenas * precio;
   // Cálculo del importe de descuento
   if (docenas >= 6)
    idescuento = 0.15 * icompra;
   else
    idescuento = 0.10 * icompra;
   // Cálculo del obsequio
   if (docenas >= 30)
    obsequio = docenas/3 * 2;
   else
    obsequio = 0;
   // Cálculo del importe a pagar
   ipagar = icompra - idescuento;
   // Salida de resultados
   txtArea.setText("-------------------" + "\n");
   txtArea.append("Monto de la compra:  " + "S/." + icompra + "\n");
   txtArea.append("Monto del descuento: " + "S/." + idescuento + "\n");
   txtArea.append("Monto a pagar:       " + "S/." +ipagar + "\n");
   txtArea.append("Obsequio:            " + obsequio + " lapiceros");
  }
  
  if (e.getSource() == btnBorrar){
   txtDocenas.setText("");
   txtPrecio.setText("");
   txtArea.setText("");
   txtDocenas.requestFocus();
  }

 }
}

Problema 2

Una institución benéfica recibe anualmente una donación proveniente de Europa y lo reparte entre un centro de salud, un comedor de niños y una parte lo invierte en la bolsa de  acuerdo a lo siguiente:

• Si el monto de la donación es de $10000 o más: 30% se destina al centro de salud, 50% al comedor de niños y el resto se invierte en la bolsa.
• Si el monto de la donación es menor que $10000: 25% se destina al centro de salud, 60% al comedor de niños y el resto se invierte en la bolsa.

La institución desea saber cuanto de dinero destinará a cada rubro anualmente.

Algoritmo

Inicio
// Declaración de variables
real donacion, comedor, salud, bolsa
// Entrada de datos
Leer donacion
// Reparte la donación
si( donacion >= 10000 ){
comedor = 0.30*donacion
salud = 0.50*donacion
bolsa = 0.20*donacion
}
sino{
comedor = 0.25*donacion
salud = 0.60*donacion
bolsa = 0.15*donacion
}
// Salida de resultados
Imprimir comedor, salud, bolsa
Fin

Programa 

Código Fuente

import java.awt.event.*;
import java.awt.*;
import javax.swing.*;

public class Problema2 extends JApplet implements ActionListener {
 /**
  * 
  */
 private static final long serialVersionUID = 8496579728313908763L;

 // Declaración de variables
 JLabel lblDonacion;
 JTextField txtDonacion;
 JButton btnProcesar, btnBorrar;
 JTextArea txtArea;
 JScrollPane scpScroll;

 // --------------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario
 public void init() {
  getContentPane().setLayout(null);

  lblDonacion = new JLabel("Donación:");
  lblDonacion.setBounds(15, 15, 70, 23);
  getContentPane().add(lblDonacion);

  txtDonacion = new JTextField();
  txtDonacion.setBounds(80, 15, 50, 23);
  getContentPane().add(txtDonacion);

  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);

  txtArea = new JTextArea();
  txtArea.setFont(new Font("monospaced", 0, 12));

  scpScroll = new JScrollPane(txtArea);
  scpScroll.setBounds(15, 70, 394, 130);
  getContentPane().add(scpScroll);
 }

 // --------------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  // Si hizo click en Procesar
  if (e.getSource() == btnProcesar) {
   // Declaración de variables
   double donacion, centrosalud, comedorniños, bolsa;
   // Entrada de datos
   donacion = Double.parseDouble(txtDonacion.getText());
   // Reparte la donación
   if (donacion >= 10000) {
    centrosalud = 0.30 * donacion;
    comedorniños = 0.50 * donacion;
    bolsa = 0.20 * donacion;
   } else {
    centrosalud = 0.25 * donacion;
    comedorniños = 0.60 * donacion;
    bolsa = 0.15 * donacion;
   }
   // Salida de resultados
   txtArea.setText("Centro de salud:  " + "S/." + centrosalud + "\n");
   txtArea.append("Comedor de niños: " + "S/." + comedorniños + "\n");
   txtArea.append("La bolsa:         " + "S/." + bolsa);
  }

  if (e.getSource() == btnBorrar) {
   txtDonacion.setText("");
   txtArea.setText("");
   txtDonacion.requestFocus();
  }
 }
}

Problema 3

En una oficina de empleos categorizan a los postulantes en función del sexo y de la edad de acuerdo a lo siguiente:

• Si la persona es de sexo femenino: categoría FA si tiene menos de 23 años y FB en caso contrario.
• Si la persona es de sexo masculino: categoría MA si tiene menos de 25 años y MB en caso contrario.

Diseñe un programa que determine la categoría de un postulante.

Algoritmo

Inicio
// Declaración de variables
entero sexo, edad
cadena categoria
// Entrada de datos
Leer sexo, edad
// Determina la categoría
si( sexo == 0 ){
si( edad < 23 )
 categoria = "FA"
sino
 categoria = "FB"
}
sino{
si( edad < 25 )
 categoria = "MA"
sino
 categoria = "MB"
}
// Salida de resultados
Imprimir categoria
Fin

Programa 

Código Fuente

import java.awt.event.*;
import java.awt.*;
import javax.swing.*;

public class Problema3 extends JApplet implements ActionListener {

 /**
  * 
  */
 private static final long serialVersionUID = 3780056368010462959L;

 // Declaración de variables
 JLabel lblSexo, lblEdad;
 JComboBox cboSexo;
 JTextField txtEdad;
 JButton btnProcesar, btnBorrar;
 JTextArea txtArea;
 JScrollPane scpScroll;

 // --------------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario
 public void init() {
  getContentPane().setLayout(null);

  lblSexo = new JLabel("Sexo:");
  lblSexo.setBounds(15, 15, 70, 23);
  getContentPane().add(lblSexo);

  cboSexo = new JComboBox();
  cboSexo.addItem("Femenino");
  cboSexo.addItem("Masculino");
  cboSexo.setBounds(80, 15, 100, 23);
  getContentPane().add(cboSexo);

  lblEdad = new JLabel("Edad:");
  lblEdad.setBounds(15, 39, 70, 23);
  getContentPane().add(lblEdad);

  txtEdad = new JTextField();
  txtEdad.setBounds(80, 39, 100, 23);
  getContentPane().add(txtEdad);

  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);

  txtArea = new JTextArea();
  txtArea.setFont(new Font("monospaced", 0, 12));

  scpScroll = new JScrollPane(txtArea);
  scpScroll.setBounds(15, 70, 394, 130);
  getContentPane().add(scpScroll);
 }

 // --------------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  // Si hizo clic en Procesar
  if (e.getSource() == btnProcesar) {
   // Declaración de variables
   int sexo, edad;
   String categoria, s;
   // Entrada de datos
   sexo = cboSexo.getSelectedIndex();
   edad = Integer.parseInt(txtEdad.getText());
   // Proceso de cálculo
   if (sexo == 0) {
    s = "Femenino";
    if (edad < 23)
     categoria = "FA";
    else
     categoria = "FB";
   } else {
    s = "Masculino";
    if (edad < 25)
     categoria = "FA";
    else
     categoria = "FB";
   }
   // Salida de resultados
   txtArea.setText("-------------------" + "\n");
   txtArea.append("Sexo: " + s + "\n");
   txtArea.append("Edad: " + edad + "\n");
   txtArea.append("Categoria: " + categoria);
  }
  // Si hizo clic en Borrar
  if (e.getSource() == btnBorrar) {
   txtEdad.setText("");
   txtArea.setText("");
   cboSexo.requestFocus();
  }

 }
}

Problema 4

Diseñe un algoritmo que lea un número entero positivo de tres cifras y determine si las cifras del número son o no consecutivas (en orden ascendente o en orden descendente). En caso que el número no cumpla con ser positivo de tres cifras, imprima el mensaje: "El número debe ser positivo de tres cifras".

Algoritmo

Inicio
// Declaración de variables
entero numero, u, d, c
cadena resultado
// Entrada de datos
Leer numero
// Prosigue si el número es correcto, sino pone un mensaje de error
si( numero >= 100 && numero <= 999 ){
// Determina las cifras del número
c = numero/100
d = (numero%100)/10
u = numero%10
// Determina si las cifras del número son o no consecutivas
si((d == c+1 && u == d+1) || (d == c-1 && u == d-1))
resultado = "Las cifras del número son consecutivas"
sino
resultado = "Las cifras del número no son consecutivas"
// Salida de resultados
Imprimir resultado
}
sino
Imprimir "El número debe ser positivo de tres cifras"
Fin

Programa 

Código Fuente

import java.awt.event.*;
import java.awt.*;
import javax.swing.*;

public class Problema4 extends JApplet implements ActionListener {
 
 /**
  * 
  */
 private static final long serialVersionUID = -5060432096041258527L;
 
 // Declaración de variables
 JLabel lblNumero;
 JTextField txtNumero;
 JButton btnProcesar, btnBorrar;
 JTextArea txtArea;
 JScrollPane scpScroll;

 // --------------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario
 public void init() {
  getContentPane().setLayout(null);

  lblNumero = new JLabel("Número:");
  lblNumero.setBounds(15, 15, 70, 23);
  getContentPane().add(lblNumero);

  txtNumero = new JTextField();
  txtNumero.setBounds(80, 15, 50, 23);
  getContentPane().add(txtNumero);

  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);

  txtArea = new JTextArea();
  txtArea.setFont(new Font("monospaced", 0, 12));

  scpScroll = new JScrollPane(txtArea);
  scpScroll.setBounds(15, 70, 394, 130);
  getContentPane().add(scpScroll);
 }

 // --------------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  // Si hizo clic en Procesar
  if (e.getSource() == btnProcesar) {
   // Declaración de variables
   int numero, c, d, u;
   String resultado = "";
   // Entrada de datos
   numero = Integer.parseInt(txtNumero.getText());
   // Validamos que el número ingresado sea de 3 cifras
   if (numero >= 100 && numero <= 999) {
    // Descomponer en cifras el número
    c = numero / 100;
    d = numero % 100 / 10;
    u = numero % 100 % 10;
    // Proceos de cálculo

    // Determina si las cifras del número son o no consecutivas
    if ((d == c + 1 && u == d + 1) || (d == c - 1 && u == d - 1))
     resultado = "Las cifras del número son consecutivas";
    else
     resultado = "Las cifras del número no son consecutivas";
    
    /*if ((c < d && d < u) || (c > d && d > u))
     resultado = "Las cifras del número son consecutivas";
    else
     resultado = "Las cifras del número no son consecutivas";*/
   } else
    resultado = "El numero debe ser positivo de 3 cifras";
   // Salida de resultados
   txtArea.setText("-------------------" + "\n");
   txtArea.append("Número: " + numero + "\n");
   txtArea.append("Resultado: " + resultado);
  }

  // Si hizo clic en Borrar
  if (e.getSource() == btnBorrar) {
   txtNumero.setText("");
   txtArea.setText("");
   txtNumero.requestFocus();
  }
 }
}

Problema 5

Una papelera ha puesto en oferta la venta al por mayor (en cientos) de papel bond de acuerdo a los siguientes criterios:

•  Para los primeros 5 cientos, se hace un descuento del 10% por cada ciento.
•  Para los cientos en exceso sobre 5, se hace un descuento del 15% por cada ciento.

Diseñe un algoritmo que determine el importe bruto, el importe del descuento y el importe a pagar por una compra de papel bond.

Algoritmo

Inicio
// Declaración de variables
real importebru, importedes, importepag, precio
entero cientos
// Entrada de datos
Leer precio, cientos
// Determina el importe bruto
importebru = precio*cientos
// Determina el importe del descuento
si( cientos <= 5 )
importedes = 0.10*precio*cientos
sino
importedes = 0.10*5*precio + 0.15*(cientos-5)*precio;
// Determina el importe a pagar
importepag = importebru - importedes
// Salida de resultados
Imprimir importebru, importedes, importepag
Fin

Programa 

Código Fuente

import java.awt.event.*;
import java.awt.*;
import javax.swing.*;

public class Problema5 extends JApplet implements ActionListener {

 /**
  * 
  */
 private static final long serialVersionUID = 1197438818426560210L;

 // Declaración de variables
 JLabel lblCientos, lblPrecio;
 JTextField txtCientos, txtPrecio;
 JButton btnProcesar, btnBorrar;
 JTextArea txtArea;
 JScrollPane scpScroll;

 // --------------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario
 public void init() {
  getContentPane().setLayout(null);

  lblCientos = new JLabel("Cientos:");
  lblCientos.setBounds(15, 15, 70, 23);
  getContentPane().add(lblCientos);

  txtCientos = new JTextField();
  txtCientos.setBounds(80, 15, 50, 23);
  getContentPane().add(txtCientos);

  lblPrecio = new JLabel("Precio:");
  lblPrecio.setBounds(15, 39, 70, 23);
  getContentPane().add(lblPrecio);

  txtPrecio = new JTextField();
  txtPrecio.setBounds(80, 39, 50, 23);
  getContentPane().add(txtPrecio);

  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);

  txtArea = new JTextArea();
  txtArea.setFont(new Font("monospaced", 0, 12));

  scpScroll = new JScrollPane(txtArea);
  scpScroll.setBounds(15, 70, 394, 130);
  getContentPane().add(scpScroll);
 }

 // --------------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed(ActionEvent e) {
  // Si hizo clic en Procesar
  if (e.getSource() == btnProcesar) {
   // Declaración de variables
   int cientos;
   double precio, ibruto, idescuento, ipagar;
   // Entrada de datos
   cientos = Integer.parseInt(txtCientos.getText());
   precio = Double.parseDouble(txtPrecio.getText());
   // Determinar el importe bruto
   ibruto = cientos * precio;
   // Determinar el importe de descuento
   if (cientos <= 5)
    idescuento = 0.10 * precio * cientos;
   else
    idescuento = 0.10 * 5 * precio + 0.15 * (cientos - 5) * precio;
   // Determinar el importe a pagar
   ipagar = ibruto - idescuento;
   // Salida de resultados
   txtArea.setText("-------------------" + "\n");
   txtArea.append("Importe bruto: " + ibruto + "\n");
   txtArea.append("Importe de descuento: " + idescuento + "\n");
   txtArea.append("Importe a pagar: " + ipagar);
  }
  // Si hizo clic en Borrar
  if (e.getSource() == btnBorrar) {
   txtCientos.setText("");
   txtPrecio.setText("");
   txtArea.setText("");
   txtCientos.requestFocus();
  }
 }
}

PROBLEMAS PROPUESTOS

Problema 1

En un supermercado hay una promoción según la cual el cliente raspa una tarjeta que contiene un número oculto. Si el número de la tarjeta es par no menor que 100, el cliente obtiene un descuento del 15% sobre el importe de la compra; en caso contrario, sólo se le descuenta el 5%. Dado el número oculto de la tarjeta y el importe de una compra, diseñe un algoritmo que determine el importe del descuento y el importe a pagar para un cliente del supermercado.

Algoritmo

Inicio
// Declaración de variables
entero numero
real impcompra, impdescuento, imppagar
// Entrada de datos
Leer numero, impcompra
// Obtener el importe de descuento
si (numero % 2 == 0 && numero >= 100)
 impdescuento = 0.15 * impcompra
sino
 impdescuento = 0.05 * impcompra
// Obtener el importe a pagar
Imppagar = impcompra – impdescuento
// Salida de resultados
Imprimir impdescuento, imppagar
Fin

Problema 2

Una empresa paga a sus vendedores un sueldo bruto que es igual a la suma de un sueldo básico de S/. 250 más una comisión que es igual a un porcentaje del monto total vendido. El porcentaje por comisión depende de la categoría del vendedor de acuerdo a la siguiente tabla:

Por otro lado, si el sueldo bruto del vendedor es mayor a S/. 3500, se efectúa un descuento igual al 15% del sueldo bruto; en caso contrario, se efectúa un descuento igual al 10% del sueldo bruto.
Diseñe un algoritmo que determine el sueldo básico, la comisión, el sueldo bruto, el descuento y el sueldo neto de un vendedor de la empresa.

Algoritmo

Inicio
// Declaración de variables
real montoTotVen, sbasico=250, comision, sbruto, descuento, sneto
entero categoria
// Entrada de datos
Leer montoTotVend, categoría
// Calcular la comisión del vendedor
si (categoría == 1)
 comision = 0.1425 * monTotVen
si (categoría == 2)
 comision = 0.1300 * monTotVen
si (categoría == 3)
 comision = 0.1175 * monTotVen
// Calcular el sueldo bruto del vendedor
sbruto = sbasico + comision
// Calcular el descuento del vendedor
si (sbruto > 3500)
 descuento = 0.15 * sbruto
sino 
 descuento = 0.10 * sbruto
// Calcular el sueldo neto del vendedor
sneto = sbruto – descuento
// Salida de resultados
Imprimir sbasico, comisión, sbruto, descuento, sneto 
Fin

Problema 3

Una empresa de bienes raíces ofrece casas de interés social bajo las siguientes condiciones: si el ingreso mensual del comprador es menos de $1250 la cuota inicial será igual al 15% del costo de la casa y el resto se distribuirá en 120 cuotas mensuales; pero, si el ingreso mensual del comprador es mayor o igual a $1250 la cuota inicial será igual al 30% del costo de la casa y el resto se distribuirá en 75 cuotas mensuales. Diseñe un algoritmo que determine cuánto debe pagar un comprador por concepto de cuota inicial y cuánto, por cada cuota mensual.

Algoritmo

Inicio
// Declaración de variables
real ingresoMensual, costoCasa, cuotaInicial, cuotaMensual
// Entrada de datos
Leer ingresoMensual, costoCasa
// Determinar la cuota inicial
si (ingresoMensual < 1250) {
 cuotaInicial = 0.15 * costoCasa
 cuotaMensual = (costoCasa – cuotaInicial) / 120
} sino {
 cuotaInicial = 0.30 * costoCasa
 cuotaMensual = (costoCasa - cuotaInicial) / 75
| 
// Salida de resultados
Imprimir cuotaInicial, cuotaMensual
Fin

Problema 4

Un padre ha decidido dar una propina a su hijo en base a sus notas en los cursos de Matemáticas, Física e Historia del Perú.

• Si la nota de Matemática es mayor a 17, le dará S/. 3 de propina por cada punto; en caso contrario, sólo le dará S/. 1.0 por cada punto.
• Si la nota de Física es mayor a 15, le dará S/. 2.0 de propina por cada punto; en caso contrario, sólo le dará S/.0.5 por cada punto.
• Si la nota de Historia del Perú es mayor a 15, le dará S/. 1.5 por cada punto; en caso contrario, sólo le dará S/. 0.30 por cada punto.
• Además, si la nota de Matemática es mayor a 17, le obsequiará un reloj; en caso, contrario, le obsequiará un lapicero.

Diseñe un algoritmo que determine el monto total de la propina y el obsequio que le corresponde al hijo.

Algoritmo

Inicio
// Declaración de variables
real notaMate, notaFisica, notaHist
entero propina
cadena obsequio
// Entrada de datos
Leer notaMate, notaFisica, notaHit
// Calcular la propina por cada curso
si (notaMate > 17) {
 propina = propina + (3.0 * notaMate)
 obsequio = “1 reloj”
} sino {
 propina = propina + (1.0 * notaMate)
 obsequio = “1 lapicero”
} 
si (notaFisica > 15)
 propina = propina + (2.0 * notaFisica)
sino 
 propina = propina + (0.5 * notaFisica)
si (notaHist > 15)
 propina = propina + (1.5 * notaHist)
sino
 propina = propina + (0.30 * notaHist)
// Salida de resultados
Imprimir propina, obsequio
Fin

AUTOEVALUACIÓN

Problema 1

En un estacionamiento, se cobra S/. 2.5 por hora o fracción de hora. Dado el tiempo de estacionamiento de un vehículo expresado en el formato HH:MM, determine el importe a pagar por concepto de estacionamiento.

Diseñe un algoritmo que determine el monto total de la propina y el obsequio que le corresponde al hijo.

Algoritmo

Inicio
// Declaración de variables
entero hh, mm
real impPagar
// Entrada de datos
Leer hh, mm
// Proceso de cálculo
si (mm > 0)
 hh = hh + 1
impPagar = 2.5 * hh
Fin

Problema 2

En un estacionamiento, se cobra S/. 2.5 por hora o fracción de hora. Dado el tiempo de estacionamiento de un vehículo expresado en el formato HH:MM, determine el importe a pagar por concepto de estacionamiento.

Diseñe un algoritmo que determine el monto total de la propina y el obsequio que le corresponde al hijo.

Algoritmo

Inicio
// Declaración de variables
real montoTotVen, sueldo
// Entrada de datos
Leer montoTotVen
// Proceso de cálculo
si (montoTotVen > 5000)
 sueldo = 0.10 * montoTotVen + 25 * (montoTotVend / 500)
sino 
sueldo = 0.10 * montoTotVen
// Salida de resultados
Imprimir sueldo
Fin

Problema 3

Diseñe un programa que lea un número natural y determine si es o no positivo de tres cifras.

Algoritmo

Inicio
// Declaración de variables
entero numero
cadena resultado
// Entrada de datos
Leer numero
// Proceso de cálculo
si (numero > 0) {
si (numero >= 100 && numero <= 999)
resultado = "Positivo de 3 cifras";
sino 
resultado = "Es un número positivo";
} sino {
si (numero <= -100 && numero >= -999)
resultado = "Negativo de 3 cifras";
sino 
resultado = "Es un número negativo";
}
// Salida de resultados
Imprimir resultado
Fin

Problema 4

Una empresa ha decidido otorgar una bonificación por fiestas patrias a sus empleados. Si el empleado tiene más de un hijo, recibirá una bonificación igual al 12.5% de su sueldo bruto más S/. 40 por cada hijo; en caso contrario, solo recibirá el 12.5% de su sueldo bruto. Diseñe un programa que determine la bonificación por fiestas patrias que le corresponde a un empleado.

Algoritmo

Inicio
// Declaración de variables
entero nroHijos
real sbruto, bonificación
// Entrada de datos
Leer nroHijos. Sbruto
// Calcular la bonificación
si (nroHijos > 0)
 bonificación = 0.125 * sbruto + 40 * nroHijos
sino
 bonificación = 0.125 * sbruto
// Salida de resultados
Imprimir bonificacion
Fin

Problema 5

En un supermercado se hace una promoción, mediante la cual el cliente obtiene un descuento dependiendo de un número que se escoge al azar. Si el número escogido es menor que 74, el descuento es del 15% sobre el total de la compra; si es mayor o igual a 74, el descuento es del 20%. Diseñe un programa que determine cuando dinero se le debe descontar a un cliente.

Algoritmo

Inicio
// Declaración de variables
real totCompra, descuento
entero numero
// Entrada de datos
Leer totCompra, numero
// Obtener el descuento
si (numero < 74)
descuento = 0.5 * totCompra
sino
 descuento = 0.20 * totCompra
// Salida de resultados
Imprimir descuento
Fin

Problema 6

Una persona se encuentra indecisa entre comprar un automóvil o un terreno, los cuales cuestan exactamente lo mismo. Sabe que mientras el automóvil se devalúa, con el terreno sucede lo contrario. Esta persona comprará el automóvil, si al cabo de dos años la devaluación total de este no es mayor que la mitad del incremento total del valor del terreno. Diseñe un programa que le ayude a la persona a decidir que comprar. Considere los porcentajes de devaluación del automóvil y de incremento del terreno como porcentajes anuales constantes.

Algoritmo

Inicio
// Declaración de variables
real totCompra, descuento
entero numero
// Entrada de datos
Leer totCompra, numero
// Obtener el descuento
si (numero < 74)
descuento = 0.5 * totCompra
sino
 descuento = 0.20 * totCompra
// Salida de resultados
Imprimir descuento
Fin

Problema 7

Una empresa ha decidido adquirir varias piezas de la misma clase a una fábrica de refacciones. La empresa, dependiendo del monto total de la compra, decidirá qué hacer para pagar al fabricante. Si el monto total de la compra excede de $500000, la empresa pedirá prestado al banco el 30% e invertirá el resto de su propio dinero; en caso contrario, pedirá prestado al banco el 20% e invertirá el resto de su propio dinero. Diseñe un programa que determine cuanto tendrá que pagar la empresa de su propio dinero y cuanto deberá pedir prestado al banco.

Algoritmo

Inicio
// Declaración de variables
real montoTotCompra
// Entrada de datos
Leer montoTotCompra
// Proceso de cálculo
si (montoTotCompra > 500000)
 dineroPrestado = 0.30 * montoTotCompra
 dineroPropio = montoTotCompra – préstamo
sino 
 dineroPrestado = 0.20 * montoTotCompra
 dineroPropio = montoTotCompra – dineroPrestado
// Salida de resultados
Imprimir dineroPrestado, dineroPropio
Fin

Problema 8

Una empresa paga a sus vendedores un sueldo bruto igual a la suma de un sueldo básico de S/. 300 más una comisión igual al 15% del monto total vendido. Por otro lado, si el sueldo bruto del vendedor es mayor que S/. 1800, recibe un descuento del 15% del sueldo bruto; en caso contrario, recibe un descuento del 11% del sueldo bruto. Además, como incentivo, la empresa obsequia 3 polos si es que el monto vendido es mayor a S/. 500; en caso contrario, sólo obsequia 1 polo.

Diseñe un algoritmo que determine el sueldo bruto, el descuento, el sueldo neto y el número de polos de obsequio correspondiente a un vendedor de la empresa.

Algoritmo

Inicio
// Declaración de variables
real montoTotVen, sbruto, comision, descuento, sneto
cadena obsequio
// Entrada de datos
Leer montoTotVen
// Calcular la comisión
comision = 0.15 * montoTotVen
// Calcular el sueldo bruto
sbruto = 300 + comision
// Calcular el descuento
si (sbruto > 1800)
 descuento = 0.15 * sbruto
sino
 descuento = 0.11 * sbruto  
// Calcular el sueldo neto
sneto = sbruto - descuento
// Calcular obsequio
si (montoTotVen > 500)
 obsequio = “3 polos””
sino
 obsequio = “1 polo”
// Salida de resultados
Imprimir comision, sbruto, descuento, sneto, obsequio
Fin

Problema 9

Diseñe un programa que lea una hora del día en formato militar y lo imprima en formato estándar. Así, si se ingresa una hora igual a 15:45:30 el programa deberá imprimir 03:05:30 P.M. En caso de que se ingrese una hora inválida, imprima un mensaje de error.

Algoritmo

Inicio
// Declaración de variables
entero hhM, mmM, ssM
// Entrada de datos
Leer hhM, mmM, ssM,
// Proceso de cálculo
si ((hhM >= 1 && hhM <= 24) && (mmM >= 1 && mmM <= 60) 
&& (ssH >=1 && ssM <= 60)) { 
si (hhM == 12) {
 s = “PM”
 Imprimir hhM, mmM, ssM, s
}
si (hhM >= 13 &&  hhM <= 23) {
 s = “PM”
 hhM = hhM – 12
Imprimir hhM, mmM, ssM, s
}
si (hhM == 24) {
 s = “AM”
hhM = hhM – 24
 Imprimir hhM, mmM, ssM, s
}
 }
sino 
 Imprimir “Ingresó una hora invalida”
Fin

Problema 10

Una empresa calcula el sueldo bruto de sus trabajadores en base a las horas trabajadas. Hasta 48 horas, se paga una tarifa horaria normal. Para las horas en exceso sobre 48, se paga un recargo del 15% respecto a la tarifa horaria normal. Por otro lado, si el sueldo bruto es superior a S/. 1700, se aplica un descuento del 11%. Diseñe un programa que determine el sueldo bruto, el descuento y el sueldo neto de un trabajador.

Algoritmo

Inicio
// Declaración de variables
real tarifaHor, sbruto, descuetno, sneto
entero horasTrab
// Entrada de datos
Leer horasTrab, tarifaHor
// Proceso de cálculo
si (horasTrab <= 48)
 sbruto = horasTrab * tarifaHor
sino 
 sbruto = horasTrab * tarifaHor  + 0.15 * tarifaHor *  (horasTrab – 48)
// Calcular el descuento
si (sbruto > 1700)
 descuento = 0.11 * sbruto
sino
 descuento = 0
// Calcular el sueldo neto
sneto = sbruto – descuento
// Salida de resultados
Imprimir sbruto, dscuento, sneto
Fin

Problema 11

Dado un número natural de tres cifras, diseñe un algoritmo que determine si el número es o no capicúa. Un número es capicúa si se lee igual de derecha a izquierda que de izquierda a derecha. Así, por ejemplo, 363 es capicúa; pero, 356 no lo es.

Algoritmo

Inicio
// Declaración de variables
entero numero, c, d, u
// Entrada de datos
Leer numero
cadena mensaje
// Si ingreso un número de 3 cifras
si (numero >= 100 && numero <= 999)
 // Descomponemos el número en cifras
 c = numero / 100
 d = numero % 100 / 10
 u = numero % 100 % 10
 // Determinar si el número es capicúa
 si (c == u)
  mensaje = “El número es capicúa”
 sino
  mensaje = “El número no es capicúa”
sino
 mensaje “Ingrese un número de 3 cifras”
// Salida de resultados
Imprimir mensaje
Fin

Cualquier duda pueden dejarla en la sección de comentarios.

Descargar ejercicios resueltos
Descargar archivos

Cualquier duda o pregunta que tengan pueden compartirlas en la sección de comentarios.

-----------------

¡Usted acaba de ver el tema número 20 del curso de Introducción a la Algoritmia y a la programación en Java!

La estructura de selección doble if...else

Continuando con las estructuras algorítmicas de selección. Hoy veremos el uso de la estructura de selección doble If...else, el cual nos va a permitir crear programas que resuelvan problemas que involucren tomas de decisiones. 

Así, en el tema de hoy vamos a diseñar algoritmos en pseudocódigo y en Java que permitan resolver problemas que involucren tomas de decisión haciendo uso de la estructura de selección doble if else.

La estructura de selección simple if

Continuando con el tema de estructuras secuenciales en Java. Hoy veremos el uso de la estructura de selección simple If, el cual nos va a permitir crear programas que resuelvan problemas que involucren tomas de decisiones. 

Así, en el tema de hoy vamos a diseñar algoritmos en pseudocódigo y en Java que permitan resolver problemas que involucren tomas de decisión haciendo uso de la estructura de selección simple if.

Estructuras de Secuencia en Java

Un programa permite resolver muchos tipos de problemas, desde tareas relativamente sencillas a solucionar grandes problemas organizacionales y necesidades de las personas, sin embargo, debemos de empezar por lo básico creando programas que permitan resolver problemas que involucren instrucciones secuenciales.

Así, en el tema de hoy crearemos algoritmos en pseudocódigo y en Java que permitan resolver problemas que involucren instrucciones secuenciales.

¿Cuáles son las etapas de desarrollo de un algoritmo en Java?

A los algoritmos que pueden ser ejecutados por un computador se denominan algoritmos computacionales. Todo algoritmo computacional puede dividirse en cuatro etapas

Así, en el tema de hoy vamos a conocer la estructura de un algoritmo divido en 4 etapas: declaración de variables, entradas de datos, proceso de cálculo y la salida de resultados.

¿Qué es un pseudocódigo?

Para crear un programa existen diferentes lenguajes de programación, sin embargo, existe un lenguaje algorítmico que nos va a permitir concentrarnos en la lógica de programación más que en las reglas de un lenguaje especifico.

Así, en el tema de hoy vamos definir el concepto de pseudocódigo, qué es y para qué sirve.

Expresiones aritméticas en Java

Los valores asignados a las variables muchas veces son el resultado de una expresión que a su vez puede contener variables, literales y operadores aritméticos.

Así, en el tema de hoy vamos a hablar sobre la jerarquía de los operadores aritméticos y también vamos a conocer los métodos matemáticos más utilizados del lenguaje Java para crear nuestras expresiones aritméticas.

¿Qué es una sentencia de asignación en Java?

Para que podamos almacenar un valor a una variable, se requiere de una sentencia de asignación que permita asignar el valor de una expresión a una variable que tenga el mismo tipo de dato.

Así, en el tema de hoy vamos A ver en qué consiste una sentencia de asignación y cuales son aquellas advertencias que debemos de saber para no cometer ningún error.

¿Qué es un literal en Java?

La representación de un valor en el código fuente de un programa lleva el nombre de literal y en Java tenemos literales para cada uno de los tipos de datos que existen.

Así, en el tema de hoy vamos a definir el concepto de literales en programación, cuáles son los tipos de literales y cómo podemos utilizarlo de una manera rápida y sencilla.

¿Qué es una variable primitiva en Java?

Los tipos de datos primitivos son aquellos tipos de datos que forman parte del núcleo del lenguaje de programación Java (char, int, double, boolean, etc); por lo tanto, una variable primitiva será aquella variable que almacene un valor es estos tipos.

En el tema de hoy vamos a definir el concepto de variables primitivas en Java.

Tipos de datos primitivos en Java

Los tipos de datos primitivos son aquellos tipos de datos que forman parte del núcleo de un lenguaje de programación y con los cuales podemos comenzar a crear operaciones básicas.

Así, en el tema de hoy vamos a definir el concepto de los tipos de datos primitivos del lenguaje Java.

¿Qué es una palabra reservada en Java?

Como todo lenguaje de programación, Java posee palabras reservadas que forman parte de su núcleo y que nos van a servir para poder construir nuestro programa.

Así, en el tema de hoy vamos a definir el concepto de palabra reservada y cuáles conforman la lista de palabras reservadas del lenguaje Java.