Está en la página 1de 24

Ingeniera de Sistemas

Lenguaje de
Programacin

Jhon Saavedra Castaeda
UNIVERSIDAD NACIONAL PEDRO RUIZ GALLO
LENGUAJE DE PROGRAMACIN
pg. 1
1.- Defina una Clase con un mtodo pblico que permite dibujar el tringulo
de Floyd, adems el mtodo tendr que recibir como argumento la altura del
tringulo:
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
--------------------------------------------------------------------------------------------------------------------
public class Floyd {
public void hacerTriangulo(int altura){
String triangulo="";
for (int i = 1; i < altura+1; i++) {
triangulo= triangulo+Integer.toString(i);
System.out.println(triangulo);
}
}
}
--------------------------------------------------------------------------------------------------------------------
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class TestFloyd {
public static void main(String[] args)throws IOException {
BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
Floyd ofloyd=new Floyd();
int altura;
System.out.print("Ingrese altura: ");
altura=Integer.parseInt(br.readLine());
System.out.println("");
ofloyd.hacerTriangulo(altura);
}
}
LENGUAJE DE PROGRAMACIN
pg. 2
2.- Implementar el siguiente ejercicio con POO
1
2 2
3 3 3
4 4 4 4
3 3 3
2 2
1
--------------------------------------------------------------------------------------------------------------------
public class Triangulo {
public void imprimir(){

int cont=0;
for (int i = 1; i < 5; i++) {
cont=i;
while(i>0){
System.out.print(cont+"");
i--;
}
i=cont;
System.out.println("");
}
for (int i = 3; i >0; i--) {
cont=i;
while(i>0){
System.out.print(cont+"");
i--;
}
i=cont;
System.out.println("");
}
}
}
--------------------------------------------------------------------------------------------------------------------
public class TestTriangulo {
public static void main(String[] args) {
Triangulo otriangulo=new Triangulo();
otriangulo.imprimir();
}
}







LENGUAJE DE PROGRAMACIN
pg. 3
3.- Defina una Clase y dos mtodos para convertir un nmero decimal a
nmero binario y de binario a decimal.
public class Conversion {

public String decimaltoBinario(String numero){
int n;
n=Integer.parseInt(numero);
numero="";
while(n>=1){
numero= Integer.toString(n%2)+ numero;
n = n/2;
}
return numero;

}

public String binariotoDecimal (String numero){
int contador=numero.length(),n1,n2=0;
n1=Integer.parseInt(numero);

for (int i = 0; i < contador; i++) {
n2= n2+(int)( (n1%10)*Math.pow(2,i));
n1 = n1/10;

}
numero = Integer.toString(n2);
return numero;
}

public void menu(){
System.out.println("");

System.out.println("1. Convertir numero binario a decimal");
System.out.println("2. Convertir numero decimal a binario");
System.out.println("0. SALIR");
System.out.print("Ingrese opcion: ");
}
}
--------------------------------------------------------------------------------------------------------------------
public class TestConversion {
public static void main(String[] args)throws IOException {
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
Conversion oconversion=new Conversion();
String numero;
int opcion=-1;


LENGUAJE DE PROGRAMACIN
pg. 4
while(opcion!=0){
System.out.print("Ingrese numero: ");
numero=br.readLine();
oconversion.menu();
opcion=Integer.parseInt(br.readLine());
switch(opcion){
case 1:
numero=oconversion.binariotoDecimal(numero);
System.out.println("El numero en decimal es: "+numero);
break;
case 2:
numero=oconversion.decimaltoBinario(numero);
System.out.println("El numero en binario es: "+numero);
break;
case 0:
System.out.println("HA SALIDO DEL MENU");
break;
default:
System.out.println("INGRESE UNA DE LAS OPCIONES");
break;


}
System.out.print("Desea ingresar otro numero (1->Si,0->No): ");
opcion=Integer.parseInt(br.readLine());

}
System.out.println("FIN DEL ALGORITMO");
}
}
















LENGUAJE DE PROGRAMACIN
pg. 5
4.- Defina una Clase con sus respectivos mtodos que permita determinar la
suma de los N primero trminos de la serie de Fibonacci, y mostrar sus valores
considerando que N sea mayor que 1. La secuencia de la serie es la siguiente:
0, 1, 1, 2, 3, 5, 8, 13,...

public class Fibonacci {

public void serieFibo(int numero){
int n1=1,n2=1,suma=0;
if(numero>1){
while(numero>0){
n1=n2-n1;
n2=n2+n1;
System.out.print(n1+" ");
suma=suma+n1;
numero--;
}
System.out.println("");
System.out.println("La suma es: "+suma);
}else{
System.out.println("N debe ser mayor a 1");
}
}
}
--------------------------------------------------------------------------------------------------------------------
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class TestFibonacci {
public static void main(String[] args)throws IOException {
BufferedReader br=new BufferedReader(new InputStreamReader
(System.in));
int numero;
Fibonacci ofibonacci=new Fibonacci();
System.out.print("Ingrese N: ");
numero=Integer.parseInt(br.readLine());
ofibonacci.serieFibo(numero);

}
}






LENGUAJE DE PROGRAMACIN
pg. 6
5.- Defina una Clase con sus respectivos mtodos que permita determinar la
cantidad de dgitos que tiene un nmero entero y adems mostrar la suma de
los dgitos pares e impares. Considerar al cero como dgito par.

public class Digito {
public void descomponerNumero(int numero){
int par=0,impar=0,cantidad=0,auxiliar;
while(numero>0){
auxiliar=numero%10;
if (auxiliar==0 || auxiliar%2==0) {
par = par + auxiliar;

}else{
impar= impar + auxiliar;
}
cantidad++;
numero=numero/10;
}

System.out.println("Cantidad de digitos: "+cantidad);
System.out.println("Suma de digitos pares: "+par);
System.out.println("Suma de digitos impares: "+impar);
}
}
--------------------------------------------------------------------------------------------------------------------
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class TestDigito {
public static void main(String[] args)throws IOException {
BufferedReader br=new BufferedReader(new InputStreamReader
(System.in));
int numero;
Digito odigito=new Digito();
System.out.print("Ingrese numero: ");
numero=Integer.parseInt(br.readLine());
odigito.descomponerNumero(numero);
}
}







6.- Implementar el siguiente ejercicio con POO
LENGUAJE DE PROGRAMACIN
pg. 7
Mostrar los N primeros trminos de la serie: 7, 6, 8, 5, 9, 4, 10, 3,.
Mostrar los K primeros trminos de la serie: 5, 7, 10, 14, 19,

public class Serie {
public void nSerie(int n){
int n1=7,n2=6;
while(n>0){
if (n>0) {
System.out.print(n1+" ");
n1++;
n--;
}
if (n>0) {
System.out.print(n2+" ");
n2--;
n--;
}
}
}
public void kSerie(int n){
for (int i = 1; i <= n; i++) {
System.out.print(((i*i+i+8)/2)+" ");
}
}
}
--------------------------------------------------------------------------------------------------------------------
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class TestSerie {
public static void main(String[] args)throws IOException {
BufferedReader br=new BufferedReader(new InputStreamReader
(System.in));
int opcion;
Serie oserie=new Serie();
System.out.println("Ingrese N: ");
opcion=Integer.parseInt(br.readLine());
oserie.nSerie(opcion);
System.out.println("");
System.out.println("Ingrese K: ");
opcion=Integer.parseInt(br.readLine());
oserie.kSerie(opcion);
System.out.println("");
}
}
7.- Defina una Clase que simule el apagn de un edificio que tiene 30
bombillas de luz y todas estn encendidas, la clase debe tener los siguientes
LENGUAJE DE PROGRAMACIN
pg. 8
mtodos mostrarEstado, mostrarTotalMalogradas (debe mostrar el nmero
total de bombillas malogradas para su reposicin), MostrarTotalIntactas (debe
mostrar el nmero total de bombillas buenas).

public class Bombilla {
private int[] bombilla;
public Bombilla(){
bombilla=new int[30];
}
public void simularEstado(){
for (int i = 0; i < 30; i++) {
bombilla[i]=(int)(Math.random()*2);

}
}
public void mostrarEstado(){
for (int i = 0; i < 30; i++) {
System.out.println("Bombilla ["+(i+1)+"]"+".-"+bombilla[i]);

}
}

public void mostrarTotalMalogradas(){
int contador1=0;
for (int i = 0; i < 30; i++) {
if(bombilla[i]==0){
contador1++;
}
}
System.out.println("Total de Bombillas Malogradas: "+contador1);
}

public void mostrarTotalIntactas(){
int contador2=0;
for (int i = 0; i < 30; i++) {
if(bombilla[i]==1){
contador2++;
}
}
System.out.println("Total de Bombillas Intactas: "+contador2);
}
public void menu(){

System.out.println("MENU");
System.out.println("====");
System.out.println("1.- Mostrar Estado");
System.out.println("2.- Total Bombillas Malogradas");
System.out.println("3.- Total Bombillas Intactas");
LENGUAJE DE PROGRAMACIN
pg. 9
System.out.println("0.- SALIR");
System.out.print("Ingrese opcion: ");
}
}

--------------------------------------------------------------------------------------------------------------------
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class TestBombilla {
public static void main(String[] args)throws IOException {
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
Bombilla obombilla=new Bombilla();
int opcion=-1;
obombilla.simularEstado();
System.out.println("SIMULACION DE BOMBILLAS");
System.out.println("=======================");
System.out.println("Nota* Bombilla Malograda->0,BombillaIntacta->1");
while(opcion!=0){
obombilla.menu();
opcion=Integer.parseInt(br.readLine());
switch(opcion){
case 1:
obombilla.mostrarEstado();
break;
case 2:
obombilla.mostrarTotalMalogradas();
break;
case 3:
obombilla.mostrarTotalIntactas();
break;

case 0:
System.out.println("FIN DEL ALGORITMO");
break;
default:
System.out.println("INGRESE OPCION CORRECTAMENTE");
break;
}
}
}
}
8.- Implemente una Clase Registro con los siguientes atributos y mtodos.
LENGUAJE DE PROGRAMACIN
pg. 10

public class Registro {
private int[] notas;

public void setNotas(int[] notas) {
this.notas = notas;
}
public Registro(){
notas =new int[10];
}

public void simularRegistro(){

for (int i = 0; i < notas.length; i++) {
notas[i]=(int)(Math.random()*20);
}
}
public int getNotaMenor(){
int menor=20;
for (int i = 0; i < notas.length; i++) {
if(notas[i]<menor){
menor = notas [i];
}
}
return menor;
}

public int getNotaMayor( ){
int mayor=0;
for (int i = 0; i < notas.length; i++) {
if (notas[i]>mayor) {
mayor = notas [i];
}
}
return mayor;
}

public int[] getAscendente(int notas[]){
int auxiliar=0;
for (int i = 1; i < notas.length; i++) {
LENGUAJE DE PROGRAMACIN
pg. 11
for (int j = 0; j < notas.length - i; j++) {
if(notas[j]>notas[j+1]){
auxiliar=notas[j];
notas[j]=notas[j+1];
notas[j+1]=auxiliar;
}
}
}
return notas;
}

public int getPorcentajeAprobados(){

int aprobados=0;
for (int i = 0; i < notas.length; i++) {
if(notas[i]>=10){
aprobados++;
}
}
return aprobados;
}

public int getPorcentajeDesaprobado(){
int desaprobados=0;
for (int i = 0; i < notas.length; i++) {
if (notas[i]<10) {
desaprobados++;

}
}
return desaprobados;

}
}
--------------------------------------------------------------------------------------------------------------------
public class TestRegistro {
public static void main(String[] args) {
int[] notas=new int[10];

Registro oregistro=new Registro();
oregistro.setNotas(notas);
System.out.println("SIMULANDO NOTAS...");
oregistro.simularRegistro();
System.out.println("Nota mayor: "+oregistro.getNotaMayor());
System.out.println("Nota menor: "+oregistro.getNotaMenor());
System.out.println("");
System.out.println("NOTAS EN FORMA ASCENDENTE");
notas=oregistro.getAscendente(notas);
LENGUAJE DE PROGRAMACIN
pg. 12
for (int i = 0; i < notas.length; i++) {
System.out.println("Nota["+(i+1)+"]: "+notas[i]);
}
System.out.println("");
System.out.println("Porcentaje de Aprobados:
"+oregistro.getPorcentajeAprobados()*100/notas.length+"%");
System.out.println("Porcentaje de Desaprobados:
"+oregistro.getPorcentajeDesaprobado()*100/notas.length+"%");
}
}



































9.- Implemente la siguiente clase que mediante un mtodo elimine los
elementos repetidos en un arreglo y adems a travs de un mtodo muestre
un detalle de la cantidad de un mismo nmero.
LENGUAJE DE PROGRAMACIN
pg. 13

public class Repeticion {
private int[] numero;
public Repeticion(){
numero=new int[10];
}

public void simularNumeros(){
for (int i = 0; i < numero.length; i++) {
numero[i]=(int)(Math.random()*20)+1;
}
}

public void contarRepeticiones(int n){
int contador=0;
for (int i = 0; i < numero.length; i++) {
if(numero[i]==n){
contador++;
}
}
System.out.println("N"+n+"->"+contador);

}

public void eliminarRepeticiones(int n){
int contador=0;
for (int i = 0; i < numero.length; i++) {
if(numero[i]==n){
contador++;
if (contador>1) {
numero[i]=0;
}
}


}
if(contador==0){
System.out.println("EL NUMERO NO SE ENCUENTRA EN EL ARREGLO");
}

}

public void mostrar(){
for (int i = 0; i < numero.length; i++) {
if(numero[i]!=0){
System.out.println(".- "+numero[i]);
}
}
LENGUAJE DE PROGRAMACIN
pg. 14
}

public void menu(){
System.out.println("1.- Mostrar numeros");
System.out.println("2.- Eliminar Repeticion");
System.out.println("3.- Simular numeros");
System.out.println("0.- Salir");
System.out.print("Ingrese opcion: ");
}
}
--------------------------------------------------------------------------------------------------------------------
public class TestRepeticion {
public static void main(String[] args)throws IOException {
BufferedReader br=new BufferedReader(new InputStreamReader
(System.in));
System.out.println("SIMULANDO NUMEROS...");
int opcion=-1,numero;
Repeticion orepeticion=new Repeticion();
orepeticion.simularNumeros();
while(opcion!=0){
orepeticion.menu();
opcion=Integer.parseInt(br.readLine());
switch(opcion){
case 1:
orepeticion.mostrar();
break;
case 2:
System.out.println("Ingrese numero: ");
numero=Integer.parseInt(br.readLine());
orepeticion.contarRepeticiones(numero);
orepeticion.eliminarRepeticiones(numero);
break;
case 3:
orepeticion.simularNumeros();
break;
}
}
}
}




10.- Crear una Clase que permita ingresar un nmero y desarrollar dos mtodos
numeroMayor y numeroMenor que lo conforma.
public class Numero {
public int numeroMayor(int n1){
int mayor=0,n2;
LENGUAJE DE PROGRAMACIN
pg. 15
while(n1>=1){
n2=n1%10;
if(n2>mayor){
mayor=n2;
}
n1 = n1/10;
}
return mayor;
}

public int numeroMenor(int n1){
int menor=9,n2;
while(n1>=1){
n2=n1%10;
if(n2<menor){
menor=n2;
}
n1=n1/10;
}
return menor;
}
}
--------------------------------------------------------------------------------------------------------------------
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class TestNumero {
public static void main(String[] args)throws IOException {
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
int numero;
Numero onumero=new Numero();
System.out.print("Ingrese numero: ");
numero=Integer.parseInt(br.readLine());

System.out.println("Digito mayor: "+onumero.numeroMayor(numero));
System.out.println("Digito menor: "+onumero.numeroMenor(numero));
}
}


11.- Implemente la clase Matematica con los siguientes Mtodos:
a. getNumeroPerfecto (se considera nmero perfecto cuando la suma de sus
divisores es igual al nmero. Por ejemplo 6 tiene como divisores 1, 2, 3 y la suma
es 6, el 28 tiene como divisores 1, 2, 4, 7, 14 y la suma es 28)
LENGUAJE DE PROGRAMACIN
pg. 16
b. getCubosPerfectos: Son aquellos que sumados los cubos de sus dgitos nos
dan el mismo nmero. Por ejemplo 153 es un cubo perfecto porque 13 + 53 +
33 = 153
public class Matematica {
public void getNumeroPerfecto(int n){
int contador=1,suma=0;
while(contador<n){
if (n%contador==0) {
suma=suma +contador;
}
contador++;
}
if (suma==n) {
System.out.println("El numero "+n+" es un numero perfecto.");
}
else{
System.out.println("El numero "+n+" no es un numero perfecto.");
}
}

public void getCubosPerfectos(int n){
int n2=n;
int suma=0,aux;
while(n>=1){
suma=(int)Math.pow((n%10), 3)+ suma;
n = n/10;
}
if (suma==n2) {
System.out.println("El numero "+n2+" es cubo perfecto.");
}else{
System.out.println("El numero "+n2+" no es cubo perfecto.");
}
}
}
--------------------------------------------------------------------------------------------------------------------









import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

LENGUAJE DE PROGRAMACIN
pg. 17
public class TestMatematica {
public static void main(String[] args)throws IOException {
BufferedReader br=new BufferedReader(new InputStreamReader
(System.in));
int a;
Matematica omatematica=new Matematica();
System.out.print("Ingrese numero: ");
a=Integer.parseInt(br.readLine());
omatematica.getNumeroPerfecto(a);
omatematica.getCubosPerfectos(a);

}

}




























12.- El gobierno ha implementado como parte de su programa social, un
subsidio familiar bajo la siguiente reglamentacin:
a. Las familias que tienen hasta 2 hijos reciben S/. 70.00, las que tienen entre
3 y 5 hijos reciben S/. 90.00 y las que tienen 6 hijos o ms reciben S/. 120.00
mensual.
b. Si la madre de familia fuera viuda, la familia recibe S/. 20.00 adicionales.
LENGUAJE DE PROGRAMACIN
pg. 18
Determinar el monto mensual que recibir una familia de acuerdo a su propia
realidad familiar.

public class Familia {
private int hijos,viuda;
public void simularFamilia(){
hijos=(int)(Math.random()*6)+1;
viuda=(int)(Math.random()*6)+1;

System.out.println("SIMULANDO FAMILIA...");
System.out.println("Cantidad de hijos: "+hijos);
if(viuda>3){
System.out.println("La madre es viuda.");
}else{
System.out.println("La madres no es viuda");
}
System.out.println("");
}

public void subsidioFamiliar(){
int subsidio=0;
if (hijos<3) {
subsidio= 70;
}

if(hijos>2 && hijos<=5){
subsidio= 90;
}
if(hijos>5){
subsidio=120;
}

if(viuda>3){
subsidio=subsidio+20;
}

System.out.println("El monto para la familia es: "+subsidio);
}
}
--------------------------------------------------------------------------------------------------------------------


public class TestFamilia {
public static void main(String[] args) {
Familia ofamilia=new Familia();
ofamilia.simularFamilia();
ofamilia.subsidioFamiliar();
}
LENGUAJE DE PROGRAMACIN
pg. 19
}







































13.- Simular la disponibilidad de asientos en un avin que consta de 15 filas, 2
lados y en cada lado 4 asientos por fila. Sugerencia: Para cada lado generar
un nmero de filas aleatorias, identificando su posicin aleatoriamente; hacer
lo mismo para los asientos en cada fila, asignado a cada posicin de asiento
la letra R de Reservado. Mostrar en pantalla el resultado de la simulacin
pudiendo ser la siguiente:
LENGUAJE DE PROGRAMACIN
pg. 20

public class Avion {
private int[][] asientos;
private String[][] asientos2;
public Avion(){
asientos=new int[15][8];
asientos2=new String[15][8];
}

public void simularAsientos(){
for (int i = 0; i < 15; i++) {
for (int j = 0; j < 8; j++) {
asientos[i][j]=(int)(Math.random()*6)+1;
if(asientos[i][j]>3){
asientos2[i][j]="R";
}else{
asientos2[i][j]="*";
}
}
}
}

public void mostrar(){
int j=0;
System.out.println(" RESERVACION DE ASIENTOS DE AVION");
System.out.println("Fila Lado Izquierdo Lado Derecho");
System.out.println(" 1 2 3 4 1 2 3 4");
for (int i = 0; i < 15; i++) {
if(i<9){
System.out.println("0"+(i+1)+" "+asientos2[i][j]+" "+asientos2[i][j+1]+"
"+asientos2[i][j+2]+" "+asientos2[i][j+3]+" "+asientos2[i][j+4]+"
"+asientos2[i][j+5]+" "+asientos2[i][j+6]+" "+asientos2[i][j+7]);
}else{
System.out.println((i+1)+" "+asientos2[i][j]+" "+asientos2[i][j+1]+"
"+asientos2[i][j+2]+" "+asientos2[i][j+3]+" "+asientos2[i][j+4]+"
"+asientos2[i][j+5]+" "+asientos2[i][j+6]+" "+asientos2[i][j+7]);
LENGUAJE DE PROGRAMACIN
pg. 21
}


}

}
}
--------------------------------------------------------------------------------------------------------------------
public class TestAvion {
public static void main(String[] args) {
Avion oavion=new Avion();
oavion.simularAsientos();
oavion.mostrar();
}
}

























14.- Implemente la clase Alumno con el atributo definidos en la clase (edad).
LENGUAJE DE PROGRAMACIN
pg. 22

public class Alumno {
private int[] edad;
public Alumno(){
edad=new int[10];
}

public void setEdad(int[] edad) {
this.edad = edad;
}
public void simularEdad(){

for (int i = 0; i < 10; i++) {
edad[i]=(int)(Math.random()*7)+16;

}
}
public int calcularSuma(){
int suma=0;
for (int i = 0; i < 10; i++) {
suma = suma + edad[i];
}
return suma;
}
public int calcularPromedio(){
int promedio=this.calcularSuma()/edad.length;
return promedio;

}

public int mostrarMenor(){
int menor=23;
for (int i = 0; i < 10; i++) {
if (edad[i]<menor) {
menor=edad[i];
}
}
return menor;
}
public int mostrarMayor(){
LENGUAJE DE PROGRAMACIN
pg. 23
int mayor=16;
for (int i = 0; i < 10; i++) {
if (edad[i]>mayor) {
mayor=edad[i];
}
}
return mayor;
}

public int[] orderAsc(){
int auxiliar=0;
for (int i = 1; i < 10; i++) {
for (int j = 0; j < edad.length -i; j++) {
if (edad[j]>edad[j+1]) {
auxiliar=edad[j];
edad[j]=edad[j+1];
edad[j+1]=auxiliar;
}
}
}
return edad;
}
}
--------------------------------------------------------------------------------------------------------------------
public class TestAlumno {
public static void main(String[] args) {
int[] edad=new int[10];
Alumno oalumno=new Alumno();
oalumno.setEdad(edad);
oalumno.simularEdad();

System.out.println("SIMULANDO EDADES...");
System.out.println("Suma : "+oalumno.calcularSuma());
System.out.println("Promedio: "+oalumno.calcularPromedio());
System.out.println("Edad Mayor: "+oalumno.mostrarMayor());
System.out.println("Edad Menor: "+oalumno.mostrarMenor());
edad = oalumno.orderAsc();
System.out.println("MOSTRANDO EDADES ASCENDENTEMENTE");
for (int i = 0; i < 10; i++) {
System.out.println("-. "+edad[i]);
}

}
}