PROGRAMA 01

// Clase base abstracta para representar una figura

abstract class Figura {
public abstract void dibujar();
}

// Clase derivada para representar un triángulo

import javax.swing.JOptionPane;
class Triangulo extends Figura {
public void dibujar() {
String mensaje = "Triangulo\n\n";
for(int altura = 1; altura<=(17/2); altura++){
for(int asteriscos = 0; asteriscos<altura; asteriscos++){
mensaje = mensaje + "*";
}
mensaje = mensaje + "\n";
}
for(int altura = (17/2)+1; altura>0; altura--){
for(int asteriscos = 0; asteriscos<altura; asteriscos++){
mensaje = mensaje + "*";
}
mensaje = mensaje + "\n";
}
JOptionPane.showMessageDialog(null, mensaje);
}
}

public class P01 {

public static void main(String[] args) {
 Figura figura = new Triangulo();
figura.dibujar();
}
}
 PROGRAMA 02
// Clase base abstracta para representar una figura
abstract class Figura {
public abstract void dibujar();
}

// Clase derivada para representar un triángulo de números

class TrianguloNumeros extends Figura {
private int n;

public TrianguloNumeros(int n) {
this.n = n;
}

public void dibujar() {

import javax.swing.JOptionPane;
String mensaje = "Triángulo de números\n\n";
for (int altura = 1; altura <= n; altura++) {
int numero = n;
for (int i = 0; i < altura; i++) {
mensaje = mensaje + " " + numero;
numero--;
}
mensaje = mensaje + "\n";
}
JOptionPane.showMessageDialog(null, mensaje);
}
}
public class P02 {
public static void main(String[] args) {
String datos = JOptionPane.showInputDialog("Escriba un número entero: ");
int n = Integer.parseInt(datos);

Figura figura = new TrianguloNumeros(n);

figura.dibujar();
}
}
 PROGRAMA 03
// Clase base abstracta para representar un autenticador
abstract class Autenticador {
public abstract boolean autenticar(String password);
}

// Clase derivada para representar un autenticador de contraseña

class AutenticadorContraseña extends Autenticador {
private final String passwordCorrecta;

public AutenticadorContraseña(String passwordCorrecta) {

this.passwordCorrecta = passwordCorrecta;
}
public boolean autenticar(String password) {
return password.equals(passwordCorrecta);
}
}

public class P03 {

import javax.swing.JOptionPane;
public static void main(String[] args) {
String mensaje = "";
String password;
password = "MalumaBeibi";

Autenticador autenticador = new AutenticadorContraseña(password);

do {
String datos = JOptionPane.showInputDialog("Password: ");
 if (autenticador.autenticar(datos)) {
mensaje = "Usted ha ingresado correctamente";
break;
} else {
mensaje = "No ha podido ingresar";
}
} while (true);

JOptionPane.showMessageDialog(null, mensaje);
}
}
 PROGRAMA 04
// Clase base abstracta para representar una transacción
abstract class Transaccion {
public abstract void realizarTransaccion();
}

// Clase derivada para representar una compra de refrescos

class CompraRefrescos extends Transaccion {
private final int costoRefresco = 25;

public void realizarTransaccion() {

import javax.swing.JoptionPane;
String mensaje = "";
int BI100 = 0;
int BI50 = 0;
int BI20 = 0;
int MO20 = 0;
int MO10 = 0;
int MO5 = 0;

String Refrescos = JOptionPane.showInputDialog("Ingrese el número de

refrescos a comprar (máximo 4): ");
int refrescos = Integer.parseInt(Refrescos);
if (refrescos > 4) {
JOptionPane.showMessageDialog(null, "Solo se permiten hasta 4 refrescos
por transacción.");
return;
}
 String TBilletesStr = JOptionPane.showInputDialog("Ingrese el total de pesos
en billetes: ");
int tbilletes = Integer.parseInt(TBilletesStr);

String TMonedasStr = JOptionPane.showInputDialog("Ingrese el total de pesos

en monedas: ");
int tmonedas = Integer.parseInt(TMonedasStr);

int TIngresado = tbilletes + tmonedas;

int TPagar = refrescos * costoRefresco;
int cambio = TIngresado - TPagar;

while (cambio >= 100) {

cambio -= 100;
BI100++;
}
while (cambio >= 50) {
cambio -= 50;
BI50++;
}
while (cambio >= 20) {
cambio -= 20;
BI20++;
}
while (cambio >= 10) {
cambio -= 10;
MO10++;
}
 while (cambio >= 5) {
cambio -= 5;
MO5++;
}
while (cambio >= 20) {
cambio -= 20;
MO20++;
}
mensaje = mensaje + "Compra realizada:\n";
mensaje = mensaje + "Total de Refrescos: " + refrescos + "\n";
mensaje = mensaje + "Total a Pagar: " + TPagar + "\n";
mensaje = mensaje + "Total Ingresado en Pesos: " + TIngresado + "\n";
mensaje = mensaje + "Billetes Ingresados en Pesos: " + tbilletes + "\n";
mensaje = mensaje + "Monedas Ingresadas en Pesos: " + tmonedas + "\n";
mensaje = mensaje + "Cambio devuelto en Pesos: " + (TIngresado - TPagar)
+ "\n";
mensaje = mensaje + "Billetes devueltos en Pesos: " + "\n";
mensaje = mensaje + "De $100: " + BI100 + "\n";
mensaje = mensaje + "De $50: " + BI50 + "\n";
mensaje = mensaje + "De $20: " + BI20 + "\n";
mensaje = mensaje + "Monedas devueltas en Pesos: " + "\n";
mensaje = mensaje + "De $20: " + MO20 + "\n";
mensaje = mensaje + "De $10: " + MO10 + "\n";
mensaje = mensaje + "De $5: " + MO5 + "\n";
JOptionPane.showMessageDialog(null, mensaje);
}
}

public class P04 {

 public static void main(String[] args) {
Transaccion transaccion = new CompraRefrescos();
transaccion.realizarTransaccion();
}
}
 PROGRAMA 05
// Clase base abstracta para representar un generador de valores únicos
abstract class GeneradorValoresUnicos {
public abstract void generarValoresUnicos(int[] conjunto);
}

// Clase derivada para representar un generador de valores únicos con

números aleatorios
class GeneradorValoresUnicosRandom extends GeneradorValoresUnicos {
public void generarValoresUnicos(int[] conjunto) {
Random random = new Random();
for (int i = 0; i < conjunto.length; i++) {
int valor = random.nextInt(1000) + 1;

boolean repetido = false;

for (int j = 0; j < i; j++) {
if (conjunto[j] == valor) {
repetido = true;
break;
}
}
if (!repetido) {
conjunto[i] = valor;
} else {
i--;
}
}
}
}
public class P05 {
import javax.swing.JOptionPane;
import java.util.Random;
public static void main(String[] args) {
int[] conjunto1 = new int[400];
int[] conjunto2 = new int[100];

GeneradorValoresUnicos generador1 = new

GeneradorValoresUnicosRandom();
generador1.generarValoresUnicos(conjunto1);

GeneradorValoresUnicos generador2 = new

GeneradorValoresUnicosRandom();
generador2.generarValoresUnicos(conjunto2);

JOptionPane.showMessageDialog(null, "Valores en el rango de 200 a 400 del

Conjunto 1:");
mostrarEnRango(conjunto1, 200, 400);

JOptionPane.showMessageDialog(null, "Valores en el rango de 200 a 400 del

Conjunto 2:");
mostrarEnRango(conjunto2, 200, 400);
}

public static void mostrarEnRango(int[] conjunto, int min, int max) {

for (int valor : conjunto) {
if (valor >= min && valor <= max) {
JOptionPane.showMessageDialog(null, valor);
}
 }
}
}
 PROGRAMA 06
// Clase base abstracta para representar un verificador de secuencia
abstract class VerificadorSecuencia {
public abstract boolean verificarSecuencia(int a, int b, int c);
}

// Clase derivada para representar un verificador de secuencia simple

class VerificadorSecuenciaSimple extends VerificadorSecuencia {
public boolean verificarSecuencia(int a, int b, int c) {
return (b == a + 1 && c == b + 1);
}
}

public class P06 {

import javax.swing.JOptionPane;
public static void main(String[] args) {
int numeroA, numeroB, numeroC;

JOptionPane.showMessageDialog(null, "Por favor, ingrese tres números seguidos:");

numeroA = Integer.parseInt(JOptionPane.showInputDialog("Número A:"));
numeroB = Integer.parseInt(JOptionPane.showInputDialog("Número B:"));
numeroC = Integer.parseInt(JOptionPane.showInputDialog("Número C:"));

VerificadorSecuencia verificador = new VerificadorSecuenciaSimple();

while (!verificador.verificarSecuencia(numeroA, numeroB, numeroC)) {

JOptionPane.showMessageDialog(null, "Los números no están en secuencia.
Intente de nuevo:");
numeroA = Integer.parseInt(JOptionPane.showInputDialog("Número A:"));
numeroB = Integer.parseInt(JOptionPane.showInputDialog("Número B:"));
 numeroC = Integer.parseInt(JOptionPane.showInputDialog("Número C:"));
}
JOptionPane.showMessageDialog(null, "¡Solicitud completada con éxito!");
}
}
 PROGRAMA 07
// Clase base abstracta para representar un comparador de secuencias
abstract class ComparadorSecuencias {
public abstract String compararSecuencias(int[] secuencia1, int[] secuencia2);
}

// Clase derivada para representar un comparador de secuencias simple

class ComparadorSecuenciasSimple extends ComparadorSecuencias {
public String compararSecuencias(int[] secuencia1, int[] secuencia2) {
int contador1 = 0;
int contador2 = 0;

for (int i = 0; i < 10; i++) {

if (secuencia1[i] > secuencia2[i]) {
contador1++;
} else if (secuencia2[i] > secuencia1[i]) {
contador2++;
}
}

if (contador1 > contador2) {

return "La primera secuencia tiene más números mayores que la segunda.";
} else if (contador2 > contador1) {
return "La segunda secuencia tiene más números mayores que la primera.";
} else {
return "Ambas secuencias tienen la misma cantidad de números mayores.";
}
}
}
public class P07 {

import javax.swing.JOptionPane;
public static void main(String[] args) {
ComparadorSecuencias comparador = new ComparadorSecuenciasSimple();

int[] secuencia1 = leerSecuencia("Ingrese la primera secuencia de números

enteros:");
int[] secuencia2 = leerSecuencia("Ingrese la segunda secuencia de números
enteros:");

String resultado = comparador.compararSecuencias(secuencia1, secuencia2);

JOptionPane.showMessageDialog(null, resultado);
}

public static int[] leerSecuencia(String mensaje) {

int[] secuencia = new int[10];

JOptionPane.showMessageDialog(null, mensaje);

for (int i = 0; i < 10; i++) {

boolean valid = false;
while (!valid) {
try {
String input = JOptionPane.showInputDialog("Ingrese el número " + (i + 1) +
":");
secuencia[i] = Integer.parseInt(input);
valid = true;
} catch (NumberFormatException e) {
 JOptionPane.showMessageDialog(null, "Por favor, ingrese un número entero
válido.");
}
}
}

return secuencia;
}
}