UNIVERSIDAD NACIONAL DE INGENIERÍA 

FACULTAD DE INGENIERIA ELECTRICA Y

ELECTRONICA

INFORME PC3
GRUPO 3
INTEGRANTES

1. Anampa Bendezu Adrian 20211246D 

11. De la Cruz Diaz Luis Andres 20211069E 

20. Malpartida Antezana David Anderson 20214519A

DOCENTE

Msc. Ing. Castillo Belsuzarri, Trini

CICLO 23-I

Lima, Perú
 Universidad Nacional de Ingeniería
Facultad de Ingeniería Eléctrica y Electrónica

LABORATORIO 1

Nombre: De la Cruz Diaz luis Andres

Código: 20211069E
Curso: Programación Orientado a Objetos
Profesor: Trini Castillo Belsuzarri
2023
problema: crear una aplicación en lenguaje java, que utilice un método generico
llamado maximo para determinar y devolver el mayor de sus tres argumentos del
mismo tipo

codificación

package com.mycompany.maximo;

/**
*
* @author user
* @param <T>
*/
public class Maximo<T extends Comparable<T>> {
public T maximo(T a, T b, T c) {
T max = a;
if (b.compareTo(max) > 0) {
max = b;
}
if (c.compareTo(max) > 0) {
max = c;
}
return max;
}

public static void main(String[] args) {

Maximo<Integer> maximoInt = new Maximo<>();
System.out.println("El máximo de 3, 7 y 2 es: " + maximoInt.maximo(3, 7, 2));

Maximo<Double> maximoDouble = new Maximo<>();

System.out.println("El máximo de 1.5, 4.2 y 2.8 es: " + maximoDouble.maximo(1.5, 4.2,
2.8));

Maximo<String> maximoString = new Maximo<>();

System.out.println("El máximo de 'manzana', 'naranja' y 'plátano' es: " +
maximoString.maximo("manzana", "naranja", "plátano"));
}
}
run del código
Ejercicio: algoritmo de ordenamiento de burbujas. Toma un arreglo de enteros como
par for anidados para comparar print Array sencillo.

CODIFICACION

public class BubbleSort {

public static void main(String[] args) {
int[] arr = {5, 2, 8, 12, 1};
System.out.println("Array antes de ordenar:");
printArray(arr);

bubbleSort(arr);

System.out.println("Array después de ordenar:");

printArray(arr);
}

public static void bubbleSort(int[] arr) {

int n = arr.length;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// Intercambiar los elementos arr[j] y arr[j + 1]
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}

public static void printArray(int[] arr) {

for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}

RUN DEL CÓDIGO

 Universidad Nacional de Ingeniería
Facultad de Ingeniería Eléctrica y Electrónica

LABORATORIO 2

Nombre: De la Cruz Diaz luis Andres

Código: 20211069E
Curso: Programación Orientado a Objetos
Profesor: Trini Castillo Belsuzarri
2023
1. problema de pila con herencia (extends)

codificación

import java.util.ArrayList;

// Clase base Pila

class Pila {
protected ArrayList<Integer> elementos;

public Pila() {
elementos = new ArrayList<>();
}

public void apilar(int elemento) {

elementos.add(elemento);
}

public int desapilar() {

if (!elementos.isEmpty()) {
int elementoDesapilado = elementos.remove(elementos.size() - 1);
return elementoDesapilado;
} else {
throw new IndexOutOfBoundsException("La pila está vacía");
}
}

public boolean estaVacia() {

return elementos.isEmpty();
}
}

// Clase PilaEspecializada hereda de Pila

class PilaEspecializada extends Pila {
public void apilarDoble(int elemento) {
apilar(elemento * 2);
}

public int desapilarMitad() {

int elementoDesapilado = desapilar();
return elementoDesapilado / 2;
}
}

// Ejemplo de uso
public class EjemploPila {
public static void main(String[] args) {
 PilaEspecializada pila = new PilaEspecializada();
pila.apilar(5);
pila.apilarDoble(8);

System.out.println("Elemento desapilado: " + pila.desapilar());

System.out.println("Elemento desapilado y dividido por 2: " +
pila.desapilarMitad());
}
}

ejecución

Elemento desapilado: 16
Elemento desapilado y dividido por 2: 4

2. problema de pila que contiene una referencia a una lista

codificación

import java.util.ArrayList;
import java.util.List;

// Clase Pila que contiene una referencia a una lista

class Pila {
private List<Integer> elementos;

public Pila() {
elementos = new ArrayList<>();
}

public void apilar(int elemento) {

elementos.add(elemento);
}

public int desapilar() {

if (!estaVacia()) {
int elementoDesapilado = elementos.remove(elementos.size() - 1);
return elementoDesapilado;
} else {
throw new IndexOutOfBoundsException("La pila está vacía");
}
}

public boolean estaVacia() {

return elementos.isEmpty();
 }
}

// Ejemplo de uso
public class EjemploPila {
public static void main(String[] args) {
Pila pila = new Pila();
pila.apilar(5);
pila.apilar(8);

System.out.println("Elemento desapilado: " + pila.desapilar());

System.out.println("Elemento desapilado: " + pila.desapilar());
}
}

ejecución

Elemento desapilado: 8
Elemento desapilado: 5

3. problema de colas

codificación

import java.util.LinkedList;

// Clase Cola
class Cola {
private LinkedList<Integer> elementos;

public Cola() {
elementos = new LinkedList<>();
}

public void encolar(int elemento) {

elementos.add(elemento);
}

public int desencolar() {

if (!estaVacia()) {
int elementoDesencolado = elementos.removeFirst();
return elementoDesencolado;
} else {
throw new IndexOutOfBoundsException("La cola está vacía");
}
}
 public boolean estaVacia() {
return elementos.isEmpty();
}
}

// Ejemplo de uso
public class EjemploCola {
public static void main(String[] args) {
Cola cola = new Cola();
cola.encolar(5);
cola.encolar(8);

System.out.println("Elemento desencolado: " + cola.desencolar());

System.out.println("Elemento desencolado: " + cola.desencolar());
}
}
 Universidad Nacional de Ingeniería
Facultad de Ingeniería Eléctrica y Electrónica

LABORATORIO 1

Nombre: Malpartida Antezana David Anderson

Código: 20214519A
Curso: Programación Orientado a Objetos
Profesor: Trini Castillo Belsuzarri
2023
EJERCICIO 1
crear una aplicación en lenguaje java, que utilice un método genérico llamado máximo para
determinar y devolver el mayor de sus tres argumentos del mismo tipo.

CODIFICACIÓN

package programacion_parcial1;
public class PruebaMetodoGenerico{

public static < E > void imprimirArreglo( E[] arregloEntrada ){

for ( E elemento : arregloEntrada )
System.out.printf( "%s ", elemento );
System.out.println();
}

public static void main( String args[] ){

Integer[] arregloInteger = { 1, 2, 3, 4, 5, 6 };
Double[] arregloDouble = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7 };
Character[] arregloCharacter = { 'H', 'O', 'L', 'A' };
System.out.println( "El arreglo arregloInteger contiene:" );
imprimirArreglo( arregloInteger );
System.out.println( "\nEl arreglo arregloDouble contiene:" );
imprimirArreglo( arregloDouble );
System.out.println( "\nEl arreglo arregloCharacter contiene:" );
imprimirArreglo( arregloCharacter );
}
}

COMPILACIÓN
EJERCICIO 2
algoritmo de ordenamiento de burbujas. Toma un arreglo de enteros como par for anidados
para comparar print Array sencillo.
CODIFICACIÓN
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {5, 2, 8, 12, 1};
System.out.println("Array antes de ordenar:");
printArray(arr);
bubbleSort(arr);
System.out.println("Array después de ordenar:");
printArray(arr);
}
public static void bubbleSort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// Intercambiar los elementos arr[j] y arr[j + 1]
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}

COMPILACIÓN
 Universidad Nacional de Ingeniería
Facultad de Ingeniería Eléctrica y Electrónica

LABORATORIO 2

Nombre: Malpartida Antezana David Anderson

Código: 20214519A
Curso: Programación Orientado a Objetos
Profesor: Trini Castillo Belsuzarri
2023
EJERCICIO 1
PILAS
CODIFICACIÓN

public class ExcepcionPilaVacia extends RuntimeException {

public ExcepcionPilaVacia(String mensaje) {
super(mensaje);
}
}
public class ExcepcionPilaLlena extends RuntimeException {
public ExcepcionPilaLlena(String mensaje) {
super(mensaje);
}
}
public class Pila<E> {
private final int tamanio;
private int superior;
private E[] elementos;

public Pila() {
this(10); // tamaño predeterminado de la pila
}
public Pila(int s) {
tamanio = s > 0 ? s : 10; // establece el tamaño de la Pila
superior = -1; // al principio, la Pila está vacía
elementos = (E[]) new Object[tamanio]; // crea el arreglo
}
public void push(E valorAMeter) {
if (superior == tamanio - 1)
throw new ExcepcionPilaLlena(String.format(
"La Pila está llena, no se puede meter %s", valorAMeter));
elementos[++superior] = valorAMeter;
}

ExcepcionPilaVacia
public E pop() {
if (superior == -1)
throw new ExcepcionPilaVacia("La Pila está vacía, no se puede realizar pop.");
E elemento = elementos[superior];
elementos[superior] = null;
superior--;
return elemento;
}

public boolean estaVacia() {

return superior == -1;
}
 public boolean estaLlena() {
return superior == tamanio - 1;
}
public int contarElementos() {
return superior + 1;
}
public int obtenerTamanio() {
return tamanio;
}
}
public class Main {
public static void main(String[] args) {
Pila<Integer> pila = new Pila<>(5);

pila.push(10);
pila.push(20);
pila.push(30);
pila.push(40);
pila.push(50);

System.out.println("Elementos en la pila: " + pila.contarElementos());

System.out.println("¿La pila está vacía? " + pila.estaVacia());
System.out.println("¿La pila está llena? " + pila.estaLlena());
System.out.println("Elemento sacado: " + pila.pop());
System.out.println("Elemento sacado: " + pila.pop());
System.out.println("Elementos en la pila después de sacar: " + pila.contarElementos());
}
}
EJERCICIO 2
COMODÍN
CODIFICACIÓN
import java.util.ArrayList;

public class TotalNumeros {

public static void main(String args[]) {

Number[] numeros = { 5, 10.2, 7, 3.5 }; // objetos Integer y Double

ArrayList<Number> listaNumeros = new ArrayList<>();

for (Number elemento : numeros) {

listaNumeros.add(elemento);
}

System.out.printf("listaNumeros contiene: %s\n", listaNumeros);

System.out.printf("Total de los elementos en listaNumeros: %.1f\n",
sumar(listaNumeros));
}

public static double sumar(ArrayList<Number> lista) {

double total = 0; // inicializa el total

for (Number elemento : lista) {

total += elemento.doubleValue();
}

return total;
}
}

COMPILACIÓN