Segunda Vuelta

DIVISIÓ N DE INGENIERIA EN SISTEMAS COMPUTACIONALES
Entrega de segunda vuelta de la 2da evaluación

Asignatura: Estructura de datos
Elaborado por:
Lozano Guerrero Javier Alejandro
Docente:
Alfredo Valle Herná ndez
Grupo: 332-V
Período: 2023-1
Índice
Programas Estructurados.............................................................................................................4
1-. Que obtenga el promedio de tres números y escribir el resultado......................................4
2-. Que multiplique dos números enteros y presente el resultado.......................................................8
3-. Que obtenga el perímetro y el área de un cuadrilátero (cuadrado o rectángulo) dada su
base y su altura y escribir los resultados.....................................................................................14
4-. Que permita determinar el área y volumen de un cilindro dado su radio (R) y altura (H)
............................................................................................................................................................16
5-. Que dado un valor en metros, imprima su equivalente en yardas, pies, pulgadas,
centímetros.......................................................................................................................................19
6-. Para hallar el perímetro de un triangulo, el valor de los lados del triangulo se debe
ingresar por teclado.....................................................................................................................22
7-. Determinar la hipotenusa de un triángulo rectángulo conocidas las longitudes de sus
dos catetos. Desarrolle el programa correspondiente...............................................................25
8-. Realice un programa que a partir de proporcionarle la velocidad de un automóvil,
expresada en kilómetros por hora, proporcione la velocidad en metros por segundo........28
9-. Desarrolle un programa que lea la velocidad en metros por segundo y la convierta a
kilómetros por hora..........................................................................................................................31
10-. Para determinar si dos números enteros son iguales.......................................................33
11-. Que permita leer un valor cualquiera N y escriba si dicho número es par o impar......37
12-. Para determinar cual de dos números enteros es el mayor y escribirlo. Si son iguales,
enviar un mensaje al respecto.......................................................................................................40
13-. Que lea un número entero y escriba si dicho número es par o impar. Asuma que
cuenta con una función que puede obtener el residuo llamada MOD....................................41
14-. Que lea un número y determine si está entre 50 y 70.......................................................43
15- .Que permita leer tres valores: A, B y C respectivamente. Que muestre cuál es el
mayor y cuál es el menor. Como restricción considerar que los tres valores son distintos.
............................................................................................................................................................44
16-. Que permita convertir calificaciones numéricas, según la siguiente tabla:....................46
17-. Que permita leer un valor entero positivo N y determinar si es primo o no...................47
18-.Que determine cuantos segundos y minutos hay en N horas...........................................48
19-. Que ingrese el sueldo del trabajador y aplicar un aumento del 10% si su sueldo es
menor a 1000...................................................................................................................................50
20-. Que determine el pago a realizar por la entrada a un espectáculo donde se pueden
comprar solo hasta cuatro entradas, donde al costo de dos entradas se les descuenta el
10%, al de tres entrada el 15% y a la compra de cuatro tickets se le descuenta el 20 %.. 52
21-. Que escriba un numero del 1 al 10 y que muestre el resultado del numero con letra.54
22-. Dada la calificación de un alumno mostrar en la pantalla si esta aprobado siempre y
cuando tenga el 80% de asistencias, en caso de tener menos del 80% de asistencia se
mostrara en pantalla que esta reprobado a pesar de que tenga calificación aprobatoria...55
23-. Que capture un numero del 1 al 10 y mostrar en pantalla su equivalente en numero
romano..............................................................................................................................................57
24-. En un almacén se hace un 15% de descuento a aquellas personas que gasten mas
de 1000, cual será la cantidad que pagara la persona por su compra...................................59
25-. Que permita convertir una calificación en letra de acuerdo a la siguiente tabla:..........60
26-.Que permita calcular el sueldo de un empleado de manera semanal considerando los
siguientes datos:..............................................................................................................................62
27-. Que permita determinar si una calificación esta dentro de un rango esperado y
mostrar resultado:............................................................................................................................63
28-. Para calcular e imprimir el precio de un terreno del cual se tienen los siguientes
datos: largo, ancho y precio por metro cuadrado. Si el terreno tiene mas de 400 metros
cuadrados se hace un descuento del 10% ................................................................................64
Programas Estructurados
1-. Que obtenga el promedio de tres números y escribir el resultado.
import javax.swing.JOptionPane;
public class tresnumeros {
public static void main(String[] args) {
// Crear tres campos de entrada para los números

String num1 = JOptionPane.showInputDialog("Escribe el primer número:");
String num2 = JOptionPane.showInputDialog("Escribe el segundo número:");
String num3 = JOptionPane.showInputDialog("Escribe el tercer número");
// Convertir los valores ingresados a números

double numero1 = Double.parseDouble(num1);
// Calcular el promedio
double promedio = (numero1 + numero2 + numero3) / 3.0;
// Mostrar el resultado en una ventana emergente

JOptionPane.showMessageDialog(null, "Ru promedio es: " + promedio);
}
}
Funcionamiento:
2-. Que multiplique dos números enteros y presente el resultado.
package segundavueta;
public class Multiplicacion extends javax.swing.JFrame {
public Multiplicacion() {
initComponents();
}
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {
jScrollPane1 = new javax.swing.JScrollPane();
jTextArea1 = new javax.swing.JTextArea();
jLabel1 = new javax.swing.JLabel();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowOpened(java.awt.event.WindowEvent evt) {
formWindowOpened(evt);
}
});
jTextArea1.setColumns(20);
jTextArea1.setRows(5);
jScrollPane1.setViewportView(jTextArea1);
jLabel1.setText("Resultados:");
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment
.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()
.addContainerGap(46, Short.MAX_VALUE)
.addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE,
299, javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap(55, Short.MAX_VALUE))
.addGroup(layout.createSequentialGroup()
.addGap(66, 66, 66)
.addComponent(jLabel1, javax.swing.GroupLayout.PREFERRED_SIZE, 127,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE))
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()
.addGap(32, 32, 32)
.addComponent(jLabel1, javax.swing.GroupLayout.PREFERRED_SIZE, 28,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED,
37, Short.MAX_VALUE)
.addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE,
148, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(55, 55, 55))
);
pack();
}// </editor-fold>
private void formWindowOpened(java.awt.event.WindowEvent evt) {

// TODO add your handling code here:
String num1String = JOptionPane.showInputDialog("Ingrese el primer número:");
int num1 = Integer.parseInt(num1String);
String num2String = JOptionPane.showInputDialog("Ingrese el segundo número:");
int num2 = Integer.parseInt(num2String);
int resultado = num1 * num2;
jTextArea1.setText("El resultado de la multiplicación es: " + resultado);
}
/**
* @param args the command line arguments
*/
public static void main(String args[]) {
/* Set the Nimbus look and feel */
//<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
/* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and
feel.
* For details see
http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
*/
try {
for (javax.swing.UIManager.LookAndFeelInfo info :
javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {
java.util.logging.Logger.getLogger(Multiplicacion.class.getName()).log(java.util.logging.Lev
el.SEVERE, null, ex);
} catch (InstantiationException ex) {
} catch (IllegalAccessException ex) {
} catch (javax.swing.UnsupportedLookAndFeelException ex) {
}
//</editor-fold>
/* Create and display the form */
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Multiplicacion().setVisible(true);
}
});
}
// Variables declaration - do not modify
private javax.swing.JLabel jLabel1;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JTextArea jTextArea1;
// End of variables declaration
}
3-. Que obtenga el perímetro y el área de un cuadrilátero (cuadrado o rectángulo) dada su
base y su altura y escribir los resultados.
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class CalculadoraCuadrilatero extends JFrame implements ActionListener {

private JTextField baseField, alturaField, resultadoArea, resultadoPerimetro;
public CalculadoraCuadrilatero() {
// Configuración de la ventana
setTitle("Calculadora de Cuadrilátero");
setSize(300, 200);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLayout(new GridLayout(3, 2));
// Etiquetas y campos de entrada

add(new JLabel("Base:"));
baseField = new JTextField();
add(baseField);
add(new JLabel("Altura:"));
alturaField = new JTextField();
add(alturaField);
// Botón para calcular

JButton calcularButton = new JButton("Calcular");
calcularButton.addActionListener(this);
add(calcularButton);
// Resultados
add(new JLabel("Área:"));
resultadoArea = new JTextField();
resultadoArea.setEditable(false);
add(resultadoArea);
add(new JLabel("Perímetro:"));
resultadoPerimetro = new JTextField();

resultadoPerimetro.setEditable(false);
add(resultadoPerimetro);
}
@Override
public void actionPerformed(ActionEvent e) {
if (e.getActionCommand().equals("Calcular")) {
// Obtener los valores de base y altura
double base = Double.parseDouble(baseField.getText());
double altura = Double.parseDouble(alturaField.getText());
// Calcular el área y el perímetro

double area = base * altura;
double perimetro = 2 * (base + altura);
// Mostrar los resultados en los campos de texto

resultadoArea.setText(String.format("%.2f", area));
resultadoPerimetro.setText(String.format("%.2f", perimetro));
}
}

SwingUtilities.invokeLater(() -> {
CalculadoraCuadrilatero frame = new CalculadoraCuadrilatero();
frame.setVisible(true);
});
}
}
4-. Que permita determinar el área y volumen de un cilindro dado su radio (R) y altura (H)
import java.awt.*;
public class CalculadoraCilindro {

JFrame frame = new JFrame("Calculadora de Cilindro");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLayout(new FlowLayout());
JLabel lblRadio = new JLabel("Radio (R):");

JTextField txtRadio = new JTextField(10);
JLabel lblAltura = new JLabel("Altura (H):");

JTextField txtAltura = new JTextField(10);
JButton btnCalcular = new JButton("Calcular");

JTextArea resultado = new JTextArea(5, 30);
resultado.setEditable(false);
btnCalcular.addActionListener(new ActionListener() {
@Override
try {
double radio = Double.parseDouble(txtRadio.getText());
double altura = Double.parseDouble(txtAltura.getText());
if (radio <= 0 || altura <= 0) {

JOptionPane.showMessageDialog(frame, "El radio y la altura deben ser
valores positivos.");
} else {
double area = 2 * Math.PI * radio * (radio + altura);
double volumen = Math.PI * radio * radio * altura;
resultado.setText("Área del cilindro: " + area + "\nVolumen del cilindro: " +

volumen);
}
} catch (NumberFormatException ex) {
JOptionPane.showMessageDialog(frame, "Por favor, ingrese valores válidos
para el radio y la altura.");
}
}
});
frame.add(lblRadio);
frame.add(txtRadio);
frame.add(lblAltura);
frame.add(txtAltura);
frame.add(btnCalcular);
frame.add(resultado);
frame.pack();
}
}
5-. Que dado un valor en metros, imprima su equivalente en yardas, pies, pulgadas,
centímetros.
public class ConversorMetros extends JFrame implements ActionListener {
private JLabel metrosLabel;

private JTextField metrosTextField;
private JButton convertirButton;
private JTextArea resultadoTextArea;
public ConversorMetros() {
// Configurar la ventana
setTitle("Conversor de Metros");
setSize(300, 200);
setLayout(null);
// Crear componentes
metrosLabel = new JLabel("Metros:");
metrosLabel.setBounds(10, 10, 80, 20);
add(metrosLabel);
metrosTextField = new JTextField();

metrosTextField.setBounds(100, 10, 80, 20);
add(metrosTextField);
convertirButton = new JButton("Convertir");

convertirButton.setBounds(10, 40, 100, 30);
convertirButton.addActionListener(this);
add(convertirButton);
resultadoTextArea = new JTextArea();

resultadoTextArea.setBounds(10, 80, 260, 80);
resultadoTextArea.setEditable(false);
add(resultadoTextArea);
}
@Override
if (e.getSource() == convertirButton) {
try {
double metros = Double.parseDouble(metrosTextField.getText());
// Realizar las conversiones

double yardas = metros * 1.09361;
double pies = metros * 3.28084;
double pulgadas = metros * 39.3701;
double centimetros = metros * 100;
// Mostrar el resultado en el área de texto

resultadoTextArea.setText("Yardas: " + yardas + "\n" +
"Pies: " + pies + "\n" +
"Pulgadas: " + pulgadas + "\n" +
"Centímetros: " + centimetros);
JOptionPane.showMessageDialog(this, "Ingrese un valor válido en metros.");
}
}
}

ConversorMetros conversor = new ConversorMetros();
conversor.setVisible(true);
}
}
Funcionamiento:
6-. Para hallar el perímetro de un triangulo, el valor de los lados del triangulo se
debe ingresar por teclado.
public class CalculadoraPerimetroTriangulo {

// Crear una ventana
JFrame frame = new JFrame("Calculadora de Perímetro de Triángulo");
frame.setSize(400, 300);
// Crear paneles
JPanel panel = new JPanel();
frame.add(panel);
// Crear etiquetas y campos de texto para ingresar los lados del triángulo
JLabel labelA = new JLabel("Lado A:");
JTextField textFieldA = new JTextField(10);
JLabel labelB = new JLabel("Lado B:");

JTextField textFieldB = new JTextField(10);
JLabel labelC = new JLabel("Lado C:");

JTextField textFieldC = new JTextField(10);
// Crear botón para calcular el perímetro

JButton calcularButton = new JButton("Calcular Perímetro");
// Crear etiqueta para mostrar el resultado

JLabel resultadoLabel = new JLabel("Perímetro: ");
// Agregar componentes al panel

panel.add(labelA);
panel.add(textFieldA);
panel.add(labelB);
panel.add(textFieldB);
panel.add(labelC);
panel.add(textFieldC);
panel.add(calcularButton);
panel.add(resultadoLabel);
// Acción del botón

calcularButton.addActionListener(new ActionListener() {
@Override
try {
// Obtener los valores de los lados desde los campos de texto
double ladoA = Double.parseDouble(textFieldA.getText());
double ladoB = Double.parseDouble(textFieldB.getText());
double ladoC = Double.parseDouble(textFieldC.getText());
// Calcular el perímetro
double perimetro = ladoA + ladoB + ladoC;
// Mostrar el resultado en la etiqueta

resultadoLabel.setText("Perímetro: " + perimetro);
JOptionPane.showMessageDialog(frame, "Por favor, ingrese valores válidos
para los lados del triángulo.");
}
}
});
// Hacer visible la ventana

}
}
7-. Determinar la hipotenusa de un triángulo rectángulo conocidas las longitudes de sus
dos catetos. Desarrolle el programa correspondiente.
import java.awt.*;
public class CalculadoraHipotenusa extends JFrame {

private JTextField cateto1Field;
private JTextField cateto2Field;
private JButton calcularButton;
public CalculadoraHipotenusa() {
setTitle("Calculadora de Hipotenusa");
setSize(300, 150);
JLabel cateto1Label = new JLabel("Cateto 1:");

JLabel cateto2Label = new JLabel("Cateto 2:");
JLabel resultadoLabel = new JLabel("Hipotenusa:");
cateto1Field = new JTextField();

cateto2Field = new JTextField();
JTextField resultadoField = new JTextField();
resultadoField.setEditable(false);
calcularButton = new JButton("Calcular");
@Override
calcularHipotenusa();
cateto1Field.setText("");
cateto2Field.setText("");
}
});
add(cateto1Label);
add(cateto1Field);
add(cateto2Label);
add(cateto2Field);
add(resultadoLabel);
add(resultadoField);
add(calcularButton);
setVisible(true);
}
private void calcularHipotenusa() {

try {
double cateto1 = Double.parseDouble(cateto1Field.getText());
double cateto2 = Double.parseDouble(cateto2Field.getText());
double hipotenusa = Math.sqrt(cateto1 * cateto1 + cateto2 * cateto2);
JOptionPane.showMessageDialog(this, "La hipotenusa es: " + hipotenusa,
"Resultado", JOptionPane.INFORMATION_MESSAGE);
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(this, "Ingrese números válidos en los campos de
los catetos", "Error", JOptionPane.ERROR_MESSAGE);
}
}

new CalculadoraHipotenusa();
});
}
}
8-. Realice un programa que a partir de proporcionarle la velocidad de un automóvil,
expresada en kilómetros por hora, proporcione la velocidad en metros por segundo.
public class ConversorVelocidad {

JFrame frame = new JFrame("Conversor de Velocidad");
frame.setLayout(null);
JLabel label1 = new JLabel("Velocidad (km/h):");

label1.setBounds(20, 20, 120, 20);
frame.add(label1);
JTextField textField = new JTextField();

textField.setBounds(150, 20, 100, 20);
frame.add(textField);
JButton convertButton = new JButton("Convertir");

convertButton.setBounds(100, 50, 100, 30);
frame.add(convertButton);
JLabel resultLabel = new JLabel("");

resultLabel.setBounds(20, 80, 260, 20);
frame.add(resultLabel);
convertButton.addActionListener(new ActionListener() {
@Override
try {
double velocidadKmH = Double.parseDouble(textField.getText());
double velocidadMS = velocidadKmH * 1000 / 3600; // Conversión de km/h a
m/s
resultLabel.setText("Velocidad en m/s: " + velocidadMS + " m/s");
resultLabel.setText("Por favor, ingrese una velocidad válida.");
}
}
});
}
}
Funcionamiento:
9-. Desarrolle un programa que lea la velocidad en metros por segundo y la convierta a
kilómetros por hora.
public class ConversionVelocidad {

JFrame frame = new JFrame("Conversión de Velocidad");
JLabel label1 = new JLabel("Velocidad (m/s):");

JTextField inputField = new JTextField(10);
JLabel resultLabel = new JLabel("Velocidad (km/h):");
@Override
try {
double mps = Double.parseDouble(inputField.getText());
double kph = mps * 3.6; // Conversión de m/s a km/h
resultLabel.setText("Velocidad (km/h): " + kph);
resultLabel.setText("Ingrese una velocidad válida en m/s");
}
}
});
panel.add(label1);
panel.add(inputField);
panel.add(convertButton);
panel.add(resultLabel);
frame.add(panel);
}
}
Funcionamiento
Programas con condicional
10-. Para determinar si dos números enteros son iguales.

import javax.swing.JButton;
import javax.swing.JFrame;
public class CompararNumeros {

JFrame frame = new JFrame("Comparar Números");
JButton boton = new JButton("Comparar Números");

boton.setBounds(100, 100, 200, 40);
frame.add(boton);
boton.addActionListener(new ActionListener() {
@Override
String numero1Str = JOptionPane.showInputDialog("Introduce el primer número
entero:");
String numero2Str = JOptionPane.showInputDialog("Introduce el segundo
número entero:");
try {
int numero1 = Integer.parseInt(numero1Str);
if (numero1 == numero2) {
JOptionPane.showMessageDialog(null, "Los números son iguales.");
} else {
JOptionPane.showMessageDialog(null, "Los números no son iguales.");
}
JOptionPane.showMessageDialog(null, "Ingresa números enteros válidos.");
}
}
});
frame.setLayout(null);
}
}
Funcionamiento:
11-. Que permita leer un valor cualquiera N y escriba si dicho número es par o impar
import java.awt.*;
public class ParImparChecker extends JFrame {

private JTextField inputField;
private JButton checkButton;
public ParImparChecker() {
// Configura la ventana
setTitle("Par o Impar Checker");
setSize(300, 100);
setLocationRelativeTo(null);
// Crea componentes
inputField = new JTextField(10);
checkButton = new JButton("Verificar");
// Agrega ActionListener al botón

checkButton.addActionListener(new ActionListener() {
@Override
verificarParImpar();
}
});
// Crea el panel
panel.setLayout(new FlowLayout());
panel.add(new JLabel("Ingrese un número:"));
panel.add(checkButton);
// Agrega el panel a la ventana

add(panel);
// Muestra la ventana
setVisible(true);
}
private void verificarParImpar() {

String inputText = inputField.getText();
try {
int numero = Integer.parseInt(inputText);
if (numero % 2 == 0) {
JOptionPane.showMessageDialog(this, numero + " es un número PAR.");
} else {
JOptionPane.showMessageDialog(this, numero + " es un número IMPAR.");
}
JOptionPane.showMessageDialog(this, "Por favor, ingrese un número válido.");
}
}

SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
new ParImparChecker();
}
});
}
}
Funcionamiento:
12-. Para determinar cual de dos números enteros es el mayor y escribirlo. Si son iguales,
enviar un mensaje al respecto.
public class CompararNumeros {

String numero1Str = JOptionPane.showInputDialog("Introduce el primer número
entero:");
String numero2Str = JOptionPane.showInputDialog("Introduce el segundo número
entero:");
// Convertir las cadenas de entrada a números enteros

String mensaje;
if (numero1 > numero2) {

mensaje = "El primer número (" + numero1 + ") es mayor que el segundo número ("
+ numero2 + ").";
} else if (numero2 > numero1) {
mensaje = "El segundo número (" + numero2 + ") es mayor que el primer número ("
+ numero1 + ").";
} else {
mensaje = "Ambos números son iguales (" + numero1 + ").";
}
JOptionPane.showMessageDialog(null, mensaje, "Comparación de Números",

JOptionPane.INFORMATION_MESSAGE);
}
}
13-. Que lea un número entero y escriba si dicho número es par o impar. Asuma que
cuenta con una función que puede obtener el residuo llamada MOD.
import java.awt.*;
public class ParImparChecker {

JFrame frame = new JFrame("Par o Impar Checker");
JLabel label = new JLabel("Ingrese un número entero:");

JTextField textField = new JTextField(10);
JButton checkButton = new JButton("Verificar");
JLabel resultLabel = new JLabel();
frame.add(label);
frame.add(checkButton);
checkButton.addActionListener(new ActionListener() {
@Override
try {
int number = Integer.parseInt(textField.getText());
if (number % 2 == 0) {
resultLabel.setText(number + " es un número par.");
} else {
resultLabel.setText(number + " es un número impar.");
}
resultLabel.setText("Ingrese un número entero válido.");

}
}
});
}
}
14-. Que lea un número y determine si está entre 50 y 70.
import java.awt.*;
public class RangoNumero {

JFrame frame = new JFrame("Verificar Rango");
JLabel label = new JLabel("Introduce un número:");

JButton verificarButton = new JButton("Verificar");
frame.add(label);
frame.add(verificarButton);
verificarButton.addActionListener(new ActionListener() {
@Override
String input = textField.getText();
try {
int numero = Integer.parseInt(input);
if (numero >= 50 && numero <= 70) {
JOptionPane.showMessageDialog(frame, "El número está entre 50 y 70.");
} else {
JOptionPane.showMessageDialog(frame, "El número no está en el rango
entre 50 y 70.");
}
JOptionPane.showMessageDialog(frame, "Entrada no válida. Por favor, ingresa
un número válido.");
}
}
});
frame.pack();
}
}
15- .Que permita leer tres valores: A, B y C respectivamente. Que muestre cuál es el
mayor y cuál es el menor. Como restricción considerar que los tres valores son distintos.
public class MayorMenor {

String inputA, inputB, inputC;
double A, B, C;
// Leer el valor de A
inputA = JOptionPane.showInputDialog("Ingrese el valor de A:");
A = Double.parseDouble(inputA);
// Leer el valor de B
inputB = JOptionPane.showInputDialog("Ingrese el valor de B:");
B = Double.parseDouble(inputB);
// Leer el valor de C
inputC = JOptionPane.showInputDialog("Ingrese el valor de C:");
C = Double.parseDouble(inputC);
// Verificar que los valores son distintos

if (A != B && A != C && B != C) {
// Encontrar el mayor
double mayor = Math.max(Math.max(A, B), C);
// Encontrar el menor
double menor = Math.min(Math.min(A, B), C);
// Mostrar los resultados

String mensaje = "El mayor valor es: " + mayor + "\nEl menor valor es: " + menor;
JOptionPane.showMessageDialog(null, mensaje);
} else {
JOptionPane.showMessageDialog(null, "Los valores deben ser distintos. Por favor,
ingrese valores distintos.");
}
}
}
16-. Que permita convertir calificaciones numéricas, según la siguiente tabla:
a. A = 19 y 20,
b. B =16, 17 y 18,
c. C = 13, 14 y 15,
d. D = 10, 11 y 12,
e. E = 1 hasta el 9.
Se asume que la nota está comprendida entre 1 y 20.
public class ConvertidorCalificaciones {

String input = JOptionPane.showInputDialog("Ingrese la calificación numérica (1-
20):");
try {
int calificacion = Integer.parseInt(input);
if (calificacion >= 19 && calificacion <= 20) {

JOptionPane.showMessageDialog(null, "Calificación: A");
} else if (calificacion >= 16 && calificacion <= 18) {
JOptionPane.showMessageDialog(null, "Calificación: B");
JOptionPane.showMessageDialog(null, "Calificación: C");
JOptionPane.showMessageDialog(null, "Calificación: D");
JOptionPane.showMessageDialog(null, "Calificación: E");
} else {
JOptionPane.showMessageDialog(null, "La calificación ingresada no es válida.");
}
JOptionPane.showMessageDialog(null, "Por favor, ingrese una calificación válida
(número del 1 al 20).");
}
}
}
17-. Que permita leer un valor entero positivo N y determinar si es primo o no
public class PrimoChecker {

String input = JOptionPane.showInputDialog("Ingrese un número entero positivo N:");
int n = Integer.parseInt(input);
if (esPrimo(n)) {
JOptionPane.showMessageDialog(null, n + " es un número primo.");
} else {
JOptionPane.showMessageDialog(null, n + " no es un número primo.");
}
}
// Función para verificar si un número es primo

public static boolean esPrimo(int numero) {
if (numero <= 1) {
return false;
}
if (numero <= 3) {
return true;
}
if (numero % 2 == 0 || numero % 3 == 0) {
return false;
}
for (int i = 5; i * i <= numero; i += 6) {
if (numero % i == 0 || numero % (i + 2) == 0) {
return false;
}
}
return true;
}
}
18-.Que determine cuantos segundos y minutos hay en N horas
import java.awt.*;
public class CalculadoraTiempo {

JFrame frame = new JFrame("Calculadora de Tiempo");
JLabel inputLabel = new JLabel("Ingrese las horas:");

JButton calculateButton = new JButton("Calcular");

JLabel resultLabel = new JLabel("Resultado:");
frame.add(inputLabel);
frame.add(inputField);
frame.add(calculateButton);
calculateButton.addActionListener(new ActionListener() {
@Override
try {
double horas = Double.parseDouble(inputField.getText());
int minutos = (int) (horas * 60);
int segundos = minutos * 60;
resultLabel.setText("En " + horas + " horas hay " + minutos + " minutos y " +
segundos + " segundos.");
resultLabel.setText("Por favor, ingrese un número válido.");
}
}
});
}
}
19-. Que ingrese el sueldo del trabajador y aplicar un aumento del 10% si su sueldo es
menor a 1000
public class AumentoSueldoApp {

JFrame frame = new JFrame("Aumento de Sueldo");
JLabel label = new JLabel("Ingrese el sueldo del trabajador:");

JTextField sueldoTextField = new JTextField(10);
JButton calcularButton = new JButton("Calcular Aumento");
panel.add(label);
panel.add(sueldoTextField);
@Override
try {
double sueldo = Double.parseDouble(sueldoTextField.getText());
if (sueldo < 1000) {
sueldo += sueldo * 0.10; // Aplicar un aumento del 10%
JOptionPane.showMessageDialog(frame, "El nuevo sueldo con aumento es:
$" + sueldo);
} else {
JOptionPane.showMessageDialog(frame, "El sueldo no es elegible para un
aumento.");
}
JOptionPane.showMessageDialog(frame, "Ingrese un valor numérico válido.");
}
}
});
frame.add(panel);
}
}
20-. Que determine el pago a realizar por la entrada a un espectáculo donde se pueden
comprar solo hasta cuatro entradas, donde al costo de dos entradas se les descuenta el
10%, al de tres entrada el 15% y a la compra de cuatro tickets se le descuenta el 20 %.
import java.text.DecimalFormat;
public class CalculadoraEntradas extends JFrame {

private JLabel label;
private JTextField inputField;
public CalculadoraEntradas() {
setTitle("Calculadora de Entradas");
setSize(300, 150);
label = new JLabel("Número de entradas:");

inputField = new JTextField(10);
calcularButton = new JButton("Calcular Precio");
@Override
calcularPrecioEntradas();
}
});

panel.add(label);
add(panel);
setVisible(true);
}
public void calcularPrecioEntradas() {

try {
int numEntradas = Integer.parseInt(inputField.getText());
double precioTotal = 0;
if (numEntradas >= 1 && numEntradas <= 4) {

double precioUnitario = 10.0; // Precio base por entrada
switch (numEntradas) {
case 2:
precioTotal = numEntradas * precioUnitario * 0.9; // Descuento del 10%
break;
case 3:
break;
case 4:
break;
default:
precioTotal = numEntradas * precioUnitario; // Sin descuento
break;
}
DecimalFormat df = new DecimalFormat("#.##");

JOptionPane.showMessageDialog(this, "El precio total es: $" +
df.format(precioTotal));
} else {
JOptionPane.showMessageDialog(this, "Ingrese un número válido de entradas (1-
4).");
}
JOptionPane.showMessageDialog(this, "Por favor, ingrese un número válido.");
}
}

new CalculadoraEntradas();
});
}
}
21-. Que escriba un numero del 1 al 10 y que muestre el resultado del numero con letra
public class NumeroALetra {

String numeroStr = JOptionPane.showInputDialog("Ingresa un número del 1 al 10:");
int numero = Integer.parseInt(numeroStr);

String numeroEnLetra = convertirNumeroALetra(numero);
JOptionPane.showMessageDialog(null, "El número " + numero + " en letra es: " +
numeroEnLetra);
} else {
JOptionPane.showMessageDialog(null, "Número fuera de rango. Ingresa un número
del 1 al 10.");
}
}
public static String convertirNumeroALetra(int numero) {

String[] letras = {"Uno", "Dos", "Tres", "Cuatro", "Cinco", "Seis", "Siete", "Ocho",
"Nueve", "Diez"};
return letras[numero - 1];
}
}
22-. Dada la calificación de un alumno mostrar en la pantalla si esta aprobado siempre y
cuando tenga el 80% de asistencias, en caso de tener menos del 80% de asistencia se
mostrara en pantalla que esta reprobado a pesar de que tenga calificación aprobatoria.
import java.awt.*;
public class CalificacionAsistenciaApp {

JFrame frame = new JFrame("Verificar Aprobación");
JLabel calificacionLabel = new JLabel("Calificación:");

JTextField calificacionField = new JTextField(10);
JLabel asistenciaLabel = new JLabel("Asistencia (%):");
JTextField asistenciaField = new JTextField(10);
JButton verificarButton = new JButton("Verificar Aprobación");
verificarButton.addActionListener(new ActionListener() {
@Override
try {
double calificacion = Double.parseDouble(calificacionField.getText());
int asistencia = Integer.parseInt(asistenciaField.getText());
if (calificacion >= 60 && asistencia >= 80) {

JOptionPane.showMessageDialog(null, "Aprobado");
} else {
JOptionPane.showMessageDialog(null, "Reprobado");
}
JOptionPane.showMessageDialog(null, "Ingresa una calificación y asistencia
válida.");
}
}
});
frame.add(calificacionLabel);
frame.add(calificacionField);
frame.add(asistenciaLabel);
frame.add(asistenciaField);
frame.add(verificarButton);
}
}
23-. Que capture un numero del 1 al 10 y mostrar en pantalla su equivalente en numero
romano
import java.awt.*;
public class ConvertidorNumerosRomanos extends JFrame {

private JButton convertirButton;
private JTextField numeroTextField;
private JLabel resultadoLabel;
public ConvertidorNumerosRomanos() {
setTitle("Convertidor de Números Romanos");
setSize(300, 150);

panel.setLayout(new FlowLayout());
numeroTextField = new JTextField(10);

convertirButton = new JButton("Convertir");
resultadoLabel = new JLabel("Resultado: ");
convertirButton.addActionListener(new ActionListener() {
@Override
String numeroTexto = numeroTextField.getText();
try {
int numero = Integer.parseInt(numeroTexto);
String numeroRomano = convertirANumeroRomano(numero);
resultadoLabel.setText("Resultado: " + numeroRomano);
} else {
resultadoLabel.setText("Número fuera de rango (1-10)");
}
resultadoLabel.setText("Entrada inválida. Ingrese un número del 1 al 10.");
}
}
});
panel.add(new JLabel("Ingrese un número del 1 al 10: "));

panel.add(numeroTextField);
panel.add(convertirButton);
panel.add(resultadoLabel);
add(panel);
}
private String convertirANumeroRomano(int numero) {

String[] romanos = {"I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X"};
return romanos[numero - 1];
}

ConvertidorNumerosRomanos convertidor = new ConvertidorNumerosRomanos();
convertidor.setVisible(true);
});
}
}
24-. En un almacén se hace un 15% de descuento a aquellas personas que gasten mas
de 1000, cual será la cantidad que pagara la persona por su compra
import java.awt.*;
public class DescuentoAlmacen {

JFrame frame = new JFrame("Calculadora de Descuento");

frame.add(panel);
JLabel label = new JLabel("Total de compra: ");

JButton calcularButton = new JButton("Calcular Descuento");
panel.add(label);
panel.add(textField);
@Override
try {
double totalCompra = Double.parseDouble(textField.getText());
double descuento = 0.15; // 15%
if (totalCompra > 1000) {
double descuentoAplicado = totalCompra * descuento;
double totalConDescuento = totalCompra - descuentoAplicado;
JOptionPane.showMessageDialog(null, "El descuento aplicado es: $" +
descuentoAplicado + "\nTotal a pagar: $" + totalConDescuento);
} else {
JOptionPane.showMessageDialog(null, "No se aplica descuento. Total a
pagar: $" + totalCompra);
}

JOptionPane.showMessageDialog(null, "Ingresa un valor válido para el total de
compra.");
}
}
});
}
}
25-. Que permita convertir una calificación en letra de acuerdo a la siguiente tabla:
 10-A
 9-B
 8-C
 7-D
 6-E
 5 o menos-F
import java.awt.*;
public class ConvertirCalificacion {

JFrame frame = new JFrame("Conversor de Calificaciones");
JLabel label = new JLabel("Ingrese la calificación numérica:");

JLabel resultLabel = new JLabel("");
@Override
try {
int calificacionNumerica = Integer.parseInt(inputField.getText());
String calificacionLetra = convertirCalificacion(calificacionNumerica);

resultLabel.setText("Calificación en letra: " + calificacionLetra);
JOptionPane.showMessageDialog(frame, "Ingrese una calificación numérica
válida.");
}
}
});
frame.add(label);
frame.add(inputField);
frame.add(convertButton);
frame.pack();
}
public static String convertirCalificacion(int calificacionNumerica) {

if (calificacionNumerica == 10) {
return "A";
} else if (calificacionNumerica == 9) {
return "B";
return "C";
return "D";
return "E";
} else if (calificacionNumerica <= 5) {
return "F";
} else {
return "Calificación no válida";
}
}
}
1.
26-.Que permita calcular el sueldo de un empleado de manera semanal considerando los

siguientes datos:
 horas trabajadas a la semana
 sueldo por hora
 horas extras(se pagaran el doble del sueldo por hora normal)
 bono o estimulo.
public class CalculoSueldoEmpleado {

// Solicita las entradas del usuario
String horasTrabajadasStr = JOptionPane.showInputDialog("Horas trabajadas a la
semana:");
String sueldoPorHoraStr = JOptionPane.showInputDialog("Sueldo por hora:");
String horasExtrasStr = JOptionPane.showInputDialog("Horas extras trabajadas:");
String bonoEstimuloStr = JOptionPane.showInputDialog("Bono o estímulo:");
try {
// Convierte las entradas del usuario a números
double horasTrabajadas = Double.parseDouble(horasTrabajadasStr);
double sueldoPorHora = Double.parseDouble(sueldoPorHoraStr);
double horasExtras = Double.parseDouble(horasExtrasStr);
double bonoEstimulo = Double.parseDouble(bonoEstimuloStr);
// Calcula el sueldo semanal

double sueldoSemanal = (horasTrabajadas * sueldoPorHora) + (horasExtras *
sueldoPorHora * 2) + bonoEstimulo;
// Muestra el resultado al usuario

JOptionPane.showMessageDialog(null, "Sueldo semanal: " + sueldoSemanal);
// En caso de entrada inválida
JOptionPane.showMessageDialog(null, "Por favor, ingrese números válidos.");
}
}
}
27-. Que permita determinar si una calificación esta dentro de un rango esperado y
mostrar resultado:
 100-excelente
 99-90-muy bien
 89-71-bien
 70-suficiente
 69 insuficiente
import java.awt.*;
public class CalificacionApp {

JFrame frame = new JFrame("Calificación App");
JLabel label = new JLabel("Ingrese la calificación:");

frame.add(label);
frame.add(calcularButton);
@Override
try {
String input = textField.getText();
int calificacion = Integer.parseInt(input);
String resultado = "";
if (calificacion == 100) {
resultado = "Excelente";
resultado = "Muy bien";
resultado = "Bien";
} else if (calificacion >= 70) {
resultado = "Suficiente";
} else {
resultado = "Insuficiente";
}
JOptionPane.showMessageDialog(frame, "Resultado: " + resultado);

JOptionPane.showMessageDialog(frame, "Ingrese una calificación válida.");
}
}
});
frame.pack();
}
}
28-. Para calcular e imprimir el precio de un terreno del cual se tienen los siguientes
datos: largo, ancho y precio por metro cuadrado. Si el terreno tiene mas de 400 metros
cuadrados se hace un descuento del 10% .
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
public class CalculadoraTerreno extends JFrame implements ActionListener {

private JTextField txtLargo, txtAncho, txtPrecioMetroCuadrado;
private JButton btnCalcular;
public CalculadoraTerreno() {
setTitle("Calculadora de Terreno");
setSize(300, 200);
setLayout(null);
JLabel lblLargo = new JLabel("Largo (metros):");

lblLargo.setBounds(10, 10, 120, 20);
add(lblLargo);
txtLargo = new JTextField();

txtLargo.setBounds(140, 10, 120, 20);
add(txtLargo);
JLabel lblAncho = new JLabel("Ancho (metros):");

lblAncho.setBounds(10, 40, 120, 20);
add(lblAncho);
txtAncho = new JTextField();

txtAncho.setBounds(140, 40, 120, 20);
add(txtAncho);
JLabel lblPrecioMetroCuadrado = new JLabel("Precio por metro cuadrado:");

lblPrecioMetroCuadrado.setBounds(10, 70, 180, 20);
add(lblPrecioMetroCuadrado);
txtPrecioMetroCuadrado = new JTextField();

txtPrecioMetroCuadrado.setBounds(190, 70, 70, 20);
add(txtPrecioMetroCuadrado);
btnCalcular = new JButton("Calcular Precio");

btnCalcular.setBounds(80, 100, 140, 30);
add(btnCalcular);
btnCalcular.addActionListener(this);
}

if (e.getSource() == btnCalcular) {
try {
double largo = Double.parseDouble(txtLargo.getText());
double ancho = Double.parseDouble(txtAncho.getText());
double precioMetroCuadrado =
Double.parseDouble(txtPrecioMetroCuadrado.getText());
double area = largo * ancho;

double precioTotal = area * precioMetroCuadrado;
if (area > 400) {

// Aplicar un descuento del 10% si el terreno tiene más de 400 metros
cuadrados.
precioTotal -= 0.10 * precioTotal;
}
JOptionPane.showMessageDialog(this, "El precio del terreno es: $" + precioTotal,

"Resultado", JOptionPane.INFORMATION_MESSAGE);
JOptionPane.showMessageDialog(this, "Por favor, ingrese valores numéricos
válidos en todos los campos.", "Error", JOptionPane.ERROR_MESSAGE);
}
}
}

CalculadoraTerreno calculator = new CalculadoraTerreno();
calculator.setVisible(true);
}
}
```
Este programa crea una ventana con campos de entrada para el largo, el ancho y el precio
por metro cuadrado del terreno, junto con un botón "Calcular Precio" que realiza los
cálculos y muestra el resultado en un cuadro de diálogo de JOptionPane. Si el área del
terreno es mayor a 400 metros cuadrados, se aplica un descuento del 10% en el precio
total.
2. Que determine cuantos segundos y minutos hay en N horas
import java.awt.*;
public class TiempoEnHoras {

SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
crearInterfaz();
}
});
}
public static void crearInterfaz() {

JFrame frame = new JFrame("Calculadora de Tiempo");
JLabel horasLabel = new JLabel("Horas:");

JTextField horasTextField = new JTextField(5);

JLabel resultadoLabel = new JLabel("Resultado:");
@Override
try {
double horas = Double.parseDouble(horasTextField.getText());
int minutos = (int) (horas * 60);
int segundos = minutos * 60;
resultadoLabel.setText("Resultado: " + minutos + " minutos y " + segundos + "

segundos");
resultadoLabel.setText("Resultado: ¡Entrada no válida!");
}
}
});
frame.add(horasLabel);
frame.add(horasTextField);
frame.add(calcularButton);
frame.add(resultadoLabel);
}
}
3. Dado un tiempo en minutos, convertirlo a horas y minutos
public class ConvertirTiempo {

JFrame frame = new JFrame("Conversor de Tiempo");

frame.add(panel);
JLabel label = new JLabel("Introduce el tiempo en minutos:");

panel.add(label);


panel.add(convertButton);
JLabel resultLabel = new JLabel("Resultado:");

panel.add(resultLabel);
@Override
try {
int minutos = Integer.parseInt(inputField.getText());
int horas = minutos / 60;
int minutosRestantes = minutos % 60;
String resultado = horas + " horas y " + minutosRestantes + " minutos.";

resultLabel.setText("Resultado: " + resultado);
resultLabel.setText("Por favor, introduce un número válido.");
}
}
});
}
}
4. Calcule exactamente el número de días vividos por una persona hasta la fecha.
Contemplar los años bisiestos.
import java.awt.*;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.GregorianCalendar;
public class CalcularDiasVividos extends JFrame {

private JTextField fechaNacimientoTextField;
private JLabel resultadoLabel;
public CalcularDiasVividos() {
super("Calculadora de Días Vividos");
calcularButton = new JButton("Calcular");

fechaNacimientoTextField = new JTextField(10);
resultadoLabel = new JLabel("");
@Override
calcularDiasVividos();
}
});
JPanel panel = new JPanel(new FlowLayout());

panel.add(new JLabel("Fecha de Nacimiento (dd/mm/aaaa):"));
panel.add(fechaNacimientoTextField);
JPanel resultadoPanel = new JPanel(new FlowLayout());

resultadoPanel.add(resultadoLabel);

add(panel);
add(resultadoPanel);
setSize(300, 150);
setLocationRelativeTo(null);
setVisible(true);
}
private void calcularDiasVividos() {

String fechaNacimientoStr = fechaNacimientoTextField.getText();
SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
try {
Date fechaNacimiento = dateFormat.parse(fechaNacimientoStr);
Date fechaActual = new Date();
long diferenciaEnMillis = fechaActual.getTime() - fechaNacimiento.getTime();

long diferenciaEnDias = diferenciaEnMillis / (24 * 60 * 60 * 1000);
int añosBisiestos = 0;
GregorianCalendar calendar = new GregorianCalendar();
for (int i = fechaNacimiento.getYear() + 1900; i <= fechaActual.getYear() + 1900; i++)
{
if (calendar.isLeapYear(i)) {
añosBisiestos++;
}
}
long diasVividos = diferenciaEnDias - añosBisiestos;

resultadoLabel.setText("Días vividos hasta la fecha: " + diasVividos);
} catch (ParseException e) {
JOptionPane.showMessageDialog(this, "Ingrese una fecha válida en el formato
dd/mm/aaaa", "Error", JOptionPane.ERROR_MESSAGE);
}
}

SwingUtilities.invokeLater(() -> new CalcularDiasVividos());
}
}

Segunda Vuelta

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Segunda Vuelta

Cargado por

Copyright:

Formatos disponibles

DIVISIÓ N DE INGENIERIA EN SISTEMAS COMPUTACIONALES

Entrega de segunda vuelta de la 2da evaluación

1-. Que obtenga el promedio de tres números y escribir el resultado.

public class tresnumeros {

public static void main(String[] args) {

// Crear tres campos de entrada para los números

// Convertir los valores ingresados a números

// Mostrar el resultado en una ventana emergente

private void formWindowOpened(java.awt.event.WindowEvent evt) {

public class CalculadoraCuadrilatero extends JFrame implements ActionListener {

// Etiquetas y campos de entrada

// Botón para calcular

resultadoPerimetro = new JTextField();

// Calcular el área y el perímetro

// Mostrar los resultados en los campos de texto

public static void main(String[] args) {

public class CalculadoraCilindro {

JLabel lblRadio = new JLabel("Radio (R):");

JLabel lblAltura = new JLabel("Altura (H):");

JButton btnCalcular = new JButton("Calcular");

if (radio <= 0 || altura <= 0) {

resultado.setText("Área del cilindro: " + area + "\nVolumen del cilindro: " +

public class ConversorMetros extends JFrame implements ActionListener {

private JLabel metrosLabel;

metrosTextField = new JTextField();

convertirButton = new JButton("Convertir");

resultadoTextArea = new JTextArea();

// Realizar las conversiones

// Mostrar el resultado en el área de texto

public static void main(String[] args) {

public class CalculadoraPerimetroTriangulo {

JLabel labelB = new JLabel("Lado B:");

JLabel labelC = new JLabel("Lado C:");

// Crear botón para calcular el perímetro

// Crear etiqueta para mostrar el resultado

// Agregar componentes al panel

// Acción del botón

// Mostrar el resultado en la etiqueta

// Hacer visible la ventana

public class CalculadoraHipotenusa extends JFrame {

JLabel cateto1Label = new JLabel("Cateto 1:");

cateto1Field = new JTextField();

calcularButton = new JButton("Calcular");

private void calcularHipotenusa() {

public static void main(String[] args) {

public class ConversorVelocidad {

JLabel label1 = new JLabel("Velocidad (km/h):");

JTextField textField = new JTextField();

JButton convertButton = new JButton("Convertir");

JLabel resultLabel = new JLabel("");

public class ConversionVelocidad {

JPanel panel = new JPanel();

JLabel label1 = new JLabel("Velocidad (m/s):");

10-. Para determinar si dos números enteros son iguales.

public class CompararNumeros {

JButton boton = new JButton("Comparar Números");

public class ParImparChecker extends JFrame {

// Agrega ActionListener al botón

// Agrega el panel a la ventana

private void verificarParImpar() {

public static void main(String[] args) {

public class CompararNumeros {

// Convertir las cadenas de entrada a números enteros