Download Fundamentos de Programacion Java...
Italo Yaranga Vite
DISEÑO LOGICO DE PROGRAMAS
100 ALGORITMOS
Italo Yaranga Vite
[email protected]
JAVA
Página 0 de 237
Italo Yaranga Vite
GUIA PRÁCTICA ALGORITMOS ESTRUCTURADOS JAVA
Página 1 de 237
Italo Yaranga Vite
INDICE PAG Instalacion de Software a utilizar…………………...................................
3
SESION 01 :
Procesos
Secuenciales..............................................
6
SESION 02 :
Estructuras Condicionales............................................
41
SESION 03 :
Estructuras Selectivas
66
SESION 04 :
Estructuras Repetitivas Para........................................ 93
SESION 05 :
Estructuras Repetitivas Mientras...............................
113
SESION 06 :
Método no retorna valor(Procedimiento)….............
134
SESION 07 :
Método que retornar un valor(Función) ..................
158
SESION 08 :
Arreglos de datos
...................................................
185
SESION 09 :
Matrices de datos ....................................................
210
.............................................
Página 2 de 237
Italo Yaranga Vite
Instalacion de Software a utilizar Para trabajar con JAVA existen varias alternativas , algunas de ellas libres y otras propietarias. Descargar JDK de la pagina de: http://www.oracle.com Fig. 1
Fig. 2
Página 3 de 237
Italo Yaranga Vite Fig. 3
Fig. 4
Página 4 de 237
Italo Yaranga Vite Descargar NetBeans en la pagina de: http://www.netbeans.com Fig. 5
Fig. 6
Página 5 de 237
Italo Yaranga Vite
S SESION 01 Los procesos secuenciales Permiten realizar un proceso tras otro no dependiendo de alguna
condición
variar la secuencia.
Página 6 de 237
que
haga
Italo Yaranga Vite SESION 01 PROCESOS SECUENCIALES 1. Diseñar un algoritmo en donde un vendedor recibe un sueldo mensual más un 10% de comisión por ventas, el vendedor desea saber cuánto dinero obtendrá por las tres ventas que realiza en el mes. Determinar el pago total que recibirá a fin mes el vendedor. Solución: *Análisis de datos E: vendedor, sm, vt1, vt2 ,vt3. S: pt (pago total) *Algoritmo 1.-Inicio 2.-vendedor='', sm=0.0, vt1=0, vt2=0, vt3=0,pt=0.0,c=0.0 3.-Leer vendedor, sm, vt1, vt2, vt3. 4.-c=(vt1+vt2+vt3)*0.10 pt=sb + c 5.-Escribir pt 6.-fin *Prueba de escritorio vendedor='juan' sm=1800 vt1=200 vt2=400 vt3=600 pt=1920 *Implementación del algoritmo en JAVA. package procesos.secuenciales; /* Diseñar un algoritmo en donde un vendedor recibe un sueldo mensual más un 10% de comisión por ventas, el vendedor desea saber cuánto dinero obtendrá por las tres ventas que realiza en el mes. Determinar el pago total que recibirá a fin mes el vendedor. */ //Paquete de datos e/s de datos por consola import java.util.Scanner; //clase principal public class Ejercicio1_PS { //metodo principal public static void main(String args[]){ //declarar variables int vt1,vt2,vt3; double sm,pt,c; String vendedor =new String(); Scanner lectura=new Scanner(System.in);
Página 7 de 237
Italo Yaranga Vite //entrada de datos System.out.print("Nombre de Vendedor:"); vendedor=lectura.next(); System.out.print("Sueldo Mensual:"); sm=lectura.nextDouble(); System.out.print("Venta 1:"); vt1=lectura.nextInt(); System.out.print("Venta 2:"); vt2=lectura.nextInt(); System.out.print("Venta 3:"); vt3=lectura.nextInt(); //proceso de datos c=(vt1+vt2+vt3)*0.10; pt=sm+c; //salida de datos System.out.println("El sueldo mensual del vendedor es :"+pt); }//Fin del metodo }//Fin de la clase *Ejecución del programa(Menu Proyecto – Run File).
Página 8 de 237
Italo Yaranga Vite 2. Diseñar un algoritmo que permita determinar el sueldo neto de un empleado, al cual se le realiza un descuento del 13% (por planilla) de su sueldo bruto que se calcula en base a las horas trabajadas al mes y su tarifa por hora trabajada. Visualizar sueldo bruto, descuento y sueldo neto a pagar. Solución: *Análisis de datos E: e (empleado), ht (horas trabajadas), th (tarifa por hora) s: sb (sueldo bruto), d(descuento), sn (sueldo neto). *Algoritmo 1.-inicio 2.-e='', ht=0, th=0.0, sb=0.0, d=0.0, sn=0.0 3.-leer e, ht ,th. 4.-sb=ht * th d=sb * 0.13 sn=sb - d 5.-escribir sb, d, sn 6.-fin *Prueba de Escritorio e=’juan’ ht=160 th=20 sb=3200 d=416 sn=2784
Página 9 de 237
Italo Yaranga Vite *Implementación del algoritmo en JAVA. package procesos.secuenciales; /* Diseñar un algoritmo que permita determinar el sueldo neto de un empleado, al cual se le realiza un descuento del 13% (por planilla) de su sueldo bruto que se calcula en base a las horas trabajadas al mes y su tarifa por hora trabajada. Visualizar sueldo bruto, descuento y sueldo neto a pagar. */ //Paquete de datos e/s datos por consola import JAVA.util.Scanner; //Clase principal public class Ejercicio2_PS { //Metodo principal public static void main(String args[]){ //Declaracion de variales String e=new String(); double ht,th,sb,d,sn; Scanner lectura= new Scanner(System.in); //Entada de datos System.out.print("Nombre de empleado: "); e=lectura.next(); System.out.print("Horas trabajadas: "); ht=lectura.nextDouble(); System.out.print("Tarifa por hora: "); th=lectura.nextDouble(); //Proceso de datos sb=ht*th; d=sb*0.13; sn=sb-d; //Salida de datos System.out.println("Sueldo basico: "+sb); System.out.println("Descuento: "+d); System.out.println("Sueldo Neto: "+sn); }//Fin del metodo }//Fin de la clase principal
*Ejecución del programa(Menu Proyecto – Run File).
Página 10 de 237
Italo Yaranga Vite 3. Diseñar un algoritmo que permita distribuir una cantidad ingresada en soles y Visualice la cantidad de billetes de cada denominación de billetes de 200, 100, 50, 20, 10 y moneda 5, 2 y 1. Solución: *Análisis de datos E: cs (cantidad soles) S: b200, b100, b50, b20, b10, m5. *Algoritmo 2.-cs=0,b200=0,b100=0,b50=0,b20=0,b10=0,m5=0,r=0, m2=0,m1=0 3.-leer cs 4.-b200=entero(cs/200) r=residuo(cs/200) b100=entero(r/100) r=residuo(r/100) b50=entero(r/50) r=residuo(r/50) b20=entero(r/20) r=residuo(r/20) b10=entero(r/10) r=residuo(r/10) m5=entero(r/5) r=residuo(r/5) m2=entero(r/2) r=residuo(r/2) m1=entero(r/1) 5.escribir b200,b100,b50,b20,b10,m5,m2,m1 6.fin *Prueba de Escritorio cs=388 b200=1, b100=1, b50=1, b20=1, b10=1, m5=1,m2=1,m1=1
Página 11 de 237
Italo Yaranga Vite *Implementación del algoritmo en JAVA. package procesos.secuenciales; /* Ejercicio1: Diseñar un programa que permita distribuir una cantidad ingresada en soles y Visualice la cantidad de billetes de cada denominación de billetes de 200, 100, 50, 20, 10, m5, 2 y 1. */ //paquete de e/s de datos por consola import JAVA.util.Scanner; //clase principal public class Ejercicio3_PS { //metodo principal public static void main(String args[]){ //declarar variables int cs, b200, b100, b50, b20, b10,m5,m2,m1,r; Scanner lectura=new Scanner(System.in); //entrada de datos System.out.print("Ingresar Cantidad S/.:"); cs=lectura.nextInt(); //proceso de datos b200=cs/200; r=cs%200; b100=r/100; r=r%100; b50=r/50; r=r%50; b20=r/20; r=r%20; b10=r/10; r=r%10; m5=r/5; r=r%5; m2=r/2; r=r%2; m1=r/1; //salida de datos System.out.println("Billetes de S/.200:"+b200); System.out.println("Billetes de S/.100:"+b100); System.out.println("Billetes de S/.50:"+b50); System.out.println("Billetes de S/.20:"+b20); System.out.println("Billetes de S/.10:"+b10); System.out.println("Monedas de S/. 5:"+m5); System.out.println("Monedas de S/. 2:"+m2); System.out.println("Monedas de S/. 1:"+m1); }//fin de metodo }//fin de la clase
Página 12 de 237
Italo Yaranga Vite *Ejecución del programa(Menu Proyecto – Run File).
4. Diseñar un algoritmo que permita obtener la depreciación acumulada y el valor real de un automóvil para su reventa. Solución: *Análisis de datos E: co (coste original), vu (vida útil), vrc (valor de recuperación), ap (años de propiedad) S: da (depreciación acumulada), vr (valor real) *Algoritmo 1.-inicio 2.-co=0.0, vu=0, vrc=0.0, ap=0, da=0.0, vr=0.0 3.-leer co, vu, vrc, ap 4.-da=ap*(co-vrc)/vu vr=co-da 5.-escribir da, vr 6.-fin *Prueba de Escritorio co =20000 vu =6 vrc =2000 ap =2 da =6000 vr =14000
Página 13 de 237
Italo Yaranga Vite *Implementación del algoritmo en JAVA. package procesos.secuenciales; /* Diseñar un algoritmo que permita obtener la depreciación acumulada y el valor real de un automóvil para su reventa. */ //paquete e/s datos por consola import JAVA.util.Scanner; //clase principal public class Ejercicio4_PS { //metodo principal public static void main(String args[]){ //declarar variales double co,vrc,da,vr; int vu,ap; Scanner lectura=new Scanner(System.in); //entrada de datos System.out.print("Coste original:"); co=lectura.nextDouble(); System.out.print("Vida util:"); vu=lectura.nextInt(); System.out.print("Valor de recuperacion:"); vrc=lectura.nextDouble(); System.out.print("Años de propiedad:"); ap=lectura.nextInt(); //proceso de datos da=ap*(co-vrc)/vu; vr=co-da; //salida de datos System.out.println("Depreciacion acumulada:"+da); System.out.println("Valor real:"+vr); }//fin del metodo }//fin de la clase *Ejecución del programa(Menu Proyecto – Run File).
Página 14 de 237
Italo Yaranga Vite 5. Diseñar un algoritmo que permita realizar las operaciones aritmeticas basicas como: suma, resta, mult, división, residuo, potencia, raiz cuadrada mediante dos números ingresados. Solución: *Análisis de datos E:n1,n2 S:s(suma),r(resta),m(mult),d(div), rs(residuo),p(potencia),rc(raiz cuadrada) *Algoritmo 1.-inicio 2.-n1=0.0,n2=0.0,s=0.0,r=0.0,m=0.0,d=0.0,rs=0,p=0,rc=0.0 3.-leer n1,n2 4.-s=n1+n2 r=n1-n2 m=n1*n2 d=n1/n2 rs=residuo(n1/n2) p=potencia(n1,n2) rc=raiz(n1) 5.-escribir s,r,m,d,rs,p,rc 6.-fin *Prueba de Escritorio n1=10 n2=5 s=15 r=5 m=50 d=2 rs=0 p=100000 rc=3.16228
Página 15 de 237
Italo Yaranga Vite *Implementación del algoritmo en JAVA. package procesos.secuenciales; /* Diseñar un algoritmo que permita realizar las operaciones aritmeticas basicas como: suma,resta, mult, división, residuo, potencia, raiz cuadrada mediante dos números ingresados. */ //paquete e/s datos por consola import JAVA.util.Scanner; import JAVA.math.BigDecimal; //clase principal public class Ejercicio5_PS { //metodo principal public static void main(String args[]){ //declaracion de variables //int p; double n1,n2,s,r,m,d,rc,rs,p; Scanner lectura=new Scanner(System.in); //entrada de datos System.out.print("Numero 1:"); n1=lectura.nextDouble(); System.out.print("Numero 2:"); n2=lectura.nextDouble(); //proceso de datos s=n1+n2; r=n1-n2; m=n1*n2; d=n1/n2; rs=n1%n2; p=Math.pow(n1,n2); rc=Math.sqrt(n1); //salida de datos System.out.println("Suma :"+s); System.out.println("Resta:"+r); System.out.println("Multiplicacion:"+m); System.out.println("Division:"+d); System.out.println("Residuo:"+r); System.out.println("Potencia:"+p); System.out.println("Raiz cuadrada:"+rc); }//fin del metodo }//fin de la clase principal
Página 16 de 237
Italo Yaranga Vite *Ejecución del programa(Menu Proyecto – Run File).
6. Diseñar un algoritmo que solicite al usuario su sueldo mensual, sus gastos de: renta, luz, agua y comida y le muestre cuánto dinero le queda. Solución: *Análisis de datos E:sm,r,l,a,c S:dr(dinero restante) *Algoritmo 1.-inicio 2.-sm=0,r=0,l=0,a=0,c=0,dr=0,s=0 3.-leer sm,r,l,a,c 4.-s=r+l+a+c dr=sm-s 5.-escribir dr 6.-fin *Prueba de Escritorio sm=2000 r=700 l=100 a=120 comida=300 dr=780
Página 17 de 237
Italo Yaranga Vite *Implementación del algoritmo en JAVA. package procesos.secuenciales; /* Diseñar un algoritmo que solicite al usuario su sueldo mensual, sus gastos de: renta, luz, agua y comida y le muestre cuánto dinero le queda. */ //Paquete de cuadros de dialogo import JAVAx.swing.JOptionPane; //clase principal public class Ejercicio6_PS { //metodo principal public static void main(String args[]){ //declaracion de variables int sm,r,l,a,c,dr,s; //entrada de datos sm=Integer.parseInt(JOptionPane.showInputDialog("Ingrese sueldo mensual:")); r=Integer.parseInt(JOptionPane.showInputDialog("Renta:")); l=Integer.parseInt(JOptionPane.showInputDialog("Luz:")); a=Integer.parseInt(JOptionPane.showInputDialog("Agua:")); c=Integer.parseInt(JOptionPane.showInputDialog("Comida:")); //proceso de datos s=r+l+a+c; dr=sm-s; //salida de datos JOptionPane.showMessageDialog(null,"Dinero Restante: "+dr); }//fin del metodo }//fin de la clase principal
*Ejecución del programa(Menu Proyecto – Run File).
Página 18 de 237
Italo Yaranga Vite 7.
Digite un número entero positivo de tres cifras, luego visualice el nuevo formado por sus cifras extremas y la inversa de dicho número.
Solución: *Análisis de datos E:n(numero) S: nnum(digitos de extremos), inv_nnum(números invertidos) *Algoritmo 1.-inicio 2.-n=0.0, c1=0,c2=0,c3=0, nnum=0,inv_nnum=0,r=0 3.-leer n 4.-c1=entero(n/100) r=residuo(n/100) c2=entero(r/10) r=residuo(r/10) c3=entero(r) nnum=(c1*10+c3) inv_nnum=(c1+c3*10) 5.-escribir nnum,inv_nnum 6.-fin *Prueba de Escritorio n=483 nnum=43 inv_nnum=34 *Implementación del algoritmo en JAVA. package procesos.secuenciales; /* Digite un número entero positivo de tres cifras, luego visualice el nuevo formado por sus cifras extremas y la inversa de dicho número. */ //paquete de cuadro de dialogo import JAVAx.swing.JOptionPane; //Clase principal public class Ejercicio7_PS { //Metodo principal public static void main(String args[]){ //declaracion de variables int c1,c2,c3,nnum,inv_nnum,r,n; //entrada de datos n=Integer.parseInt(JOptionPane.showInputDialog("Ingrese Numero:")); //proceso de datos c1=n/100; r=n%100; c2=r/10; r=r%10; c3=r; nnum=(c1*10+c3); inv_nnum=(c1+c3*10); //salida de datos JOptionPane.showMessageDialog(null,"Digitos Extremos:"+nnum+"\n"+"Numeros Invertidos:"+inv_nnum); }//fin del metodo principal }//fin de la clase principal
Página 19 de 237
Italo Yaranga Vite *Ejecución del programa(Menu Proyecto – Run File).
8.
¿Cual es el monto a devolver si nos prestan un capital c a una tasa de interes t%, durante n periodos?
Solución: *Analisis de datos E:c(capital),t(tasa de interes),n(periodos) S:m(monto) *Algoritmo 1.-Inicio 2.-c=0.0,t=0.0,n=0,m=0.0 3.-m=c*pow(1 + t ,n) 4.-escribir m 5.-fin *Prueba de escritorio c=500 t=0.2 n=5 m=1244.16
Página 20 de 237
Italo Yaranga Vite *Implementación del algoritmo en JAVA. package procesos.secuenciales; /* ¿Cual es el monto a devolver si nos prestan un capital c a una tasa de interes t%, durante n periodos? */ //paquete de cuadro de dialogo import JAVAx.swing.JOptionPane; import JAVA.math.BigDecimal; //clase principal public class Ejercicio8_PS { //metodo principal public static void main (String args[]){ //declaracion de variables int n; double c,t,m; //t=0; //entrada de datos c=Double.parseDouble(JOptionPane.showInputDialog("Capital:")); t=Double.parseDouble(JOptionPane.showInputDialog("Tasa de interes:")); n=Integer.parseInt(JOptionPane.showInputDialog("Periodo:")); //proceso de datos m=c*Math.pow(1+t,n); //salida de datos JOptionPane.showMessageDialog(null,"El monto a devolver es:"+m); }//fin del metodo }//fin de la clase
*Ejecución del programa(Menu Proyecto – Run File).
Página 21 de 237
Italo Yaranga Vite
9.
Diseñar un algoritmo que permite obtener el tiempo en segundos , si se ingresa el tiempo en horas, minutos y segundos.(Ejemplo 15hrs 20min 30seg).
Solución: *Analisis de datos E:hr(horas),m(minutos),s(segundos) S:ts(tiempo total en segundos) *Algoritmo 1.-Inicio 2.-hr=0.0,m=0.0,s=0.0,ts=0.0 3.-leer hr,m,s 4.-ts=hr*3600 + m*60 + s 5.-escribir ts 6.-fin *Prueba de escritorio hr=5 m=30 s=40 ts=19840
*Implementación del algoritmo en JAVA. package procesos.secuenciales; /* Diseñar un algoritmo que permite obtener el tiempo en segundos , si se ingresa el tiempo en horas, minutos y segundos.(Ejemplo 15hrs 20min 30seg). */ //paquete de cuadro de dialogo import JAVAx.swing.JOptionPane; //clase principal public class Ejercicio9_PS { //metodo principal public static void main(String args[]){ //declaracion de variables double hr,m,s,ts; //entrada de datos hr=Integer.parseInt(JOptionPane.showInputDialog("Hora:")); m=Integer.parseInt(JOptionPane.showInputDialog("Minuto:")); s=Integer.parseInt(JOptionPane.showInputDialog("Segundo:")); //proceso de datos ts=hr*3600+m*60+s; //salida de datos JOptionPane.showMessageDialog(null,"Tiempo Obtenido es: "+ ts +" segundos"); }//fin del metodo }//fin de la clase
Página 22 de 237
Italo Yaranga Vite *Ejecución del programa(Menu Proyecto – Run File).
10.
Diseñar un algoritmo que permita convertir una cantidad de dolares a una cantidad soles, teniendo en cuenta el tipo de cambio del dolar.
Solución: *Analisis de datos E:cd(cantidad dolares),tc(tipo de cambio) S:cs(cantidad soles) *Algoritmo 1.-inicio 2.-cd=0.0,tc=0.0,cs=0.0 3.-leer cd,tc 4.-cs=cd*tc 5.-escribir cs 6.-fin *Prueba de Escritorio cd=375 tc=2.75 cs=1031.25 *Implementación del algoritmo en JAVA. package procesos.secuenciales; /* Diseñar un algoritmo que permita convertir una cantidad de dolares a una cantidad soles,teniendo en cuenta el tipo de cambio del dolar. */ //paquete de cuadro de dialogo import JAVAx.swing.JOptionPane; //clase principal public class Ejercicio10_PS { //metodo principal public static void main (String args[]){ //declaracion de variables double cd,tc,cs; //entrada de datos cd=Double.parseDouble(JOptionPane.showInputDialog("Cantidad en dolares:")); tc=Double.parseDouble(JOptionPane.showInputDialog("Tipo de cambio:")); //proceso de datos cs=cd*tc; //salida de datos JOptionPane.showMessageDialog(null,"La cantidad en Soles es:"+cs); }//fin del metodo }//fin de la clase Página 23 de 237
Italo Yaranga Vite *Ejecución del programa(Menu Proyecto – Run File).
11.
Diseñar un algoritmo que permita determinar el área de un circulo, su diametro y la longitud de la circunferencia al dar como dato su radio.
Solución: *Analisis de datos e:r(radio) s:d(diametro), l(longitud de la circunferencia), a(area) *Algoritmo 1.-inicio 2.-r=0, d=0, l=0,a=0 3.-leer r 4.-d=2*r l=3.1416*radio*2; a=3.1416*radio*radio; 5.-escribir d,l,a 6.-fin *Prueba de escritorio r=5 d=10 l=31.416 a=78.54
Página 24 de 237
Italo Yaranga Vite *Implementación del algoritmo en JAVA. package procesos.secuenciales; /* Ejercicio 11 Desarrolar un algoritmo que permita determinar el área de un circulo, su diametro y la longitud de la circunferencia al dar como dato su radio. */ //paquete e/s datos por consola import JAVA.util.Scanner; //clase principal public class Ejercicio11_PS { //metodo principal public static void main(String args[]){ //declarar variales int r,d; double l,a; Scanner lectura=new Scanner(System.in); //entrada de datos System.out.print("Introducir el radio del circulo:"); r=lectura.nextInt(); //proceso de datos d=2*r; l=3.1416*r*2; a=3.1416*r*r; //salida de datos System.out.println("El diametro es:"+d); System.out.println("La longitud de la circunferencia es:"+l); System.out.println("El area del circulo es:"+a); }//fin del metodo }//fin de la clase
*Ejecución del programa(Menu Proyecto – Run File).
Página 25 de 237
Italo Yaranga Vite 12. Diseñar un algortimo en el cual calcule el equivalente en grados Fahrenheit o kelvin de una temperatura en grados celcius. Solución: *Analisis de datos e:t(temperaturaen celcius) s:f(temperatura fahrenheit),k(temperatura en kelvin) *Algoritmo 1.-inicio 2.-t=0.0,f=0.0,k=0.0 3.-leer t 4.-k=t+273 f=(1.8*t)+32 5.-escribir k,f 6.-fin *Prueba de escritorio t=5 f=41 k=278
*Implementación del algoritmo en JAVA. package procesos.secuenciales; /* 12.-Diseñar un algortimo en el cual calcule el equivalente en grados Fahrenheit o kelvin de una temperatura en grados celcius. */ //paquete e/s datos por consola import JAVA.util.Scanner; //clase principal public class Ejercicio12_PS { //metodo principal public static void main(String args[]){ //declarar variales double t,f,k; Scanner lectura=new Scanner(System.in); //entrada de datos System.out.print("Temperatura en Celsius:"); t=lectura.nextInt(); //proceso de datos k=t+273; f=(1.8*t)+32; //salida de datos System.out.println("Temperatura en Fahrenheit:"+f); System.out.println("Temperatura en Kelvin:"+k); }//fin del metodo }//fin de la clase
Página 26 de 237
Italo Yaranga Vite *Ejecución del programa(Menu Proyecto – Run File).
13.
Diseñar un algortimo que permita a un alumno desea saber cual será su calificación final en la materia de Algoritmos. Dicha calificación se compone de los siguientes porcentajes: · 55% del promedio de sus tres calificaciones parciales. · 30% de la calificación del examen final. · 15% de la calificación de un trabajo final.
Solución: *Analisis de datos e:p1(nota del primer parcial),p2(nota del segundo parcial), p3(nota del tercer parcial),ef(nota del examen final), tf(nota del trabajo final) s:cf(calificacion final) *Algoritmos 1.-inicio 2.-p1=0.0,p2=0.0,p3=0.0,pp=0.0,ef=0.0,tf=0.0,cf=0.0 3.-leer p1,p2,p3,ef,tf 4.-pp=(p1+p2+p3)/3 cf=0.55*pp+0.3*ef+0.15*tf 5.-escribir cf 6.-fin *Prueba de Escritorio p1=18 p2=12 p3=10 ef=14 tf=15 cf=13.78
Página 27 de 237
Italo Yaranga Vite *Implementación del algoritmo en JAVA. package procesos.secuenciales; /* Un alumno desea saber cual será su calificación final en la materia de Algoritmos. Dicha calificación se compone de los siguientes porcentajes: - 55% del promedio de sus tres calificaciones parciales. - 30% de la calificación del examen final. - 15% de la calificación de un trabajo final. */ //paquete e/s datos por consola import JAVA.util.Scanner; //clase principal public class Ejercicio13_PS { //metodo principal public static void main(String args[]){ //declarar variales double p1,p2,p3,ef,tf,cf,pp; Scanner lectura=new Scanner(System.in); //entrada de datos System.out.print("Ingrese la nota del primer parcial:"); p1=lectura.nextDouble(); System.out.print("Ingrese la nota del segundo parcial:"); p2=lectura.nextDouble(); System.out.print("Ingrese la nota del tercer parcial:"); p3=lectura.nextDouble(); System.out.print("Ingrese la nota del examen final:"); ef=lectura.nextDouble(); System.out.print("Ingrese la nota del trabajo final:"); tf=lectura.nextDouble(); //proceso de datos pp=(p1+p2+p3)/3; cf=0.55*pp+0.3*ef+0.15*tf; //salida de datos System.out.println("Los resultados son:"); System.out.println("La calificacion final es:"+cf); }//fin del metodo }//fin de la clase
*Ejecución del programa(Menu Proyecto – Run File).
Página 28 de 237
Italo Yaranga Vite 14. Diseñar un algoritmo que permita determinar el tiempo de alcance y el tiempo de encuentro en minutos de dos vehículos, que se calcula en base a la distancia que existe entre dos vehículos y sus respectivas velocidades. Visualizar el tiempo de encuentro y el tiempo de alcance de los dos vehículos. Solución: *Análisis de datos e:d(distancia entre los dos vehículos),v1(velocidad del primer vehículo), v2(velocidad del segundo vehículo),sv(suma de velocidades de los dos vehículos), dv(diferencia de velocidades de los dos vehículos) s:te(tiempo de encuentro),ta(tiempo de alcance) *Algoritmo 1.-inicio 2.-d=0.0,sv=0.0,dv=0.0,v1=0.0,v2=0.0,te=0.0,ta=0.0 3.-leer d,v1,v2 4.-sv=v1+v2 dv=v1-v2 te= d/sv ta= d/dv 5.-escribir te,ta 6.-fin *Prueba de Escritorio d=100 v1=40 v2=20 sv=60 dv=20 te=1.67 ta=5
Página 29 de 237
Italo Yaranga Vite *Implementación del algoritmo en JAVA. package procesos.secuenciales; /* 14.- Diseñar un algoritmo que permita determinar el tiempo de alcance y el tiempo de encuentro en minutos de dos vehículos, que se calcula en base a la distancia que existe entre dos vehículos y sus respectivas velocidades. Visualizar el tiempo de encuentro y el tiempo de alcance de los dos vehículos. */ //paquete e/s datos por consola import JAVA.util.Scanner; //clase principal public class Ejercicio14_PS { //metodo principal public static void main(String args[]){ //declarar variales double d,sv,dv,v1,v2,te,ta; Scanner lectura=new Scanner(System.in); //entrada de datos System.out.print("La distancia entre los dos vehiculos es:"); d=lectura.nextDouble(); System.out.print("La velocidad del primer vehiculo es:"); v1=lectura.nextDouble(); System.out.print("La velocidad del segundo vehiculo es:"); v2=lectura.nextDouble(); //proceso de datos sv=v1+v2; dv=v1-v2; te=d/sv; ta=d/dv; //salida de datos System.out.println("El tiempo de encuentro es:"+te+" Minutos"); System.out.println("El tiempo de alcance es:"+ta+" Minutos"); }//fin del metodo }//fin de la clase
*Ejecución del programa(Menu Proyecto – Run File).
Página 30 de 237
Italo Yaranga Vite 15. Diseñar un algoritmo que permita conocer los datos estadísticos de una asignatura, por lo tanto, que lea el número de desaprobados, aprobados y sobresalientes de una asignatura y devuelva el tanto por ciento de alumnos que pasaron la asignatura y el tanto por ciento de desaprobados, aprobados y sobresalientes de la asignatura. Solución: *Análisis de datos e:d(cantidad de alumnos desaprobados),a(cantidad de alumnos aprobados), s(cantidad de alumnos sobresalientes) s:ta(cantidad total de alumnos),pp(porcentaje de alumnos que pasaron la asignatura), pd(porcentaje de alumnos desaprobados),pa(porcentaje de alumnos aprobados), ps(porcentaje de alumnos sobresalientes) *Algoritmo 1.-inicio 2.-d=0.0,a=0.0,s=0.0,ta=0.0,pp=0.0,pd=0.0,pa=0.0,ps=0.0 3.-leer d,a,s 4.-ta=d+a+s pp=(a+s)*100/ta pd=d*100/ta pa=a*100/ta ps=s*100/ta 5.-escribir pp,pd,pa,ps 6.-fin *Prueba de Escritorio d=5 a=25 s=10 ta=40 pp=87.5 pd=12.5 pa=62.5 ps=25
Página 31 de 237
Italo Yaranga Vite *Implementación del algoritmo en JAVA. package procesos.secuenciales; /* 15.- Diseñar un algoritmo que permita conocer los datos estadísticos de una asignatura, por lo tanto, que lea el número de desaprobados, aprobados y sobresalientes de una asignatura y devuelva el tanto por ciento de alumnos que pasaron la asignatura y el tanto por ciento de desaprobados, aprobados y sobresalientes de la asignatura. */ //paquete e/s datos por consola import JAVA.util.Scanner; //clase principal public class Ejercicio15_PS { //metodo principal public static void main(String args[]){ //declarar variales double d,a,s,ta,pp,pd,pa,ps; Scanner lectura=new Scanner(System.in); //entrada de datos System.out.print("Estadisticas de una asignatura:"); System.out.print("Ingrese cantidad de alumnos desaprobados:"); d=lectura.nextDouble(); System.out.print("Ingrese cantidad de alumnos aprobados:"); a=lectura.nextDouble(); System.out.print("Ingrese cantidad de alumnos sobresalientes:"); s=lectura.nextDouble(); //proceso de datos ta=d+a+s; pp=(a+s)*100/ta; pd=d*100/ta; pa=a*100/ta; ps=s*100/ta; //salida de datos System.out.print("El:"); System.out.println(pp+" % de alumnos ha pasado la asignatura"); System.out.print("Hay un:"); System.out.println(pd+"% de alumnos desaprobados"); System.out.print("Hay un:"); System.out.println(pa+"% de alumnos aprobados"); System.out.print("Hay un:"); System.out.println(ps+"% de alumnos sobresalientes"); }//fin del metodo }//fin de la clase
Página 32 de 237
Italo Yaranga Vite *Ejecución del programa(Menu Proyecto – Run File).
16. Diseñar un algoritmo determinar el valor de la hipotenusa de un triangulo rectángulo aplicando el teorema de pitagoras. el perimetro y el area que representa conociendo solamente el valor de su catetos. Solución: *Análisis de datos E:at(altura),bs(base) S:hp(hipotenusa),pt(perimetro),ar(area) *Algoritmo 1.-inicio 2.-hp=0.0,pt=0.0,ar=0.0,at=0,bs=0 3.-leer at,bs 4.- hp=(at^2+bs^2)^(1/2) pt=hp+at+bs ar=(bs*at)/2 5.-mostrar hp,pt,ar 6.-fin *prueba de escritorio at=3, bs=4 hp=5 pt=12 ar=6
Página 33 de 237
Italo Yaranga Vite *Implementación del algoritmo en JAVA. package procesos.secuenciales; /* determinar el valor de la hipotenusa de un triangulo rectángulo aplicando el teorema de pitagoras. el perimetro y el area que representa conociendo solamente el valor de su catetos */ //paquete e/s datos por consola import JAVA.util.Scanner; //clase principal public class Ejercicio16_PS { //metodo principal public static void main(String args[]){ //declarar variales double hp,pt,ar; int at=0,bs=0; Scanner lectura=new Scanner(System.in); //entrada de datos System.out.print("ingresar la altura del triangulo:"); at=lectura.nextInt(); System.out.print("ingresar la base del triangulo:"); bs=lectura.nextInt(); //proceso de los datos hp=((at*at)+(bs*bs))/5; pt=hp+at+bs; ar=(bs*at)/2; //salida de datos System.out.println("la hipotenusa del triangulo es:"+hp); System.out.println("el perimetro del triangulo es:"+pt); System.out.println("el area del triangulo es:"+ar); }//fin del metodo }//fin de la clase
*Ejecución del programa(Menu Proyecto – Run File).
Página 34 de 237
Italo Yaranga Vite 17. Diseñar un algoritmo que permita calcular las funciones trigonométricas básicas como: seno, coseno y tangente de un ángulo ingresado Solución: *Analisis de datos E:grad S:seno(seno),coseno(coseno) *Algoritmo 1.-inicio 2.-grad=0.0,seno=0.0,coseno=0.0 3.-leer grad 4.-sen=sin(grad*pi/180) cose=cos(grad*pi/180) tang=tan(grad*pi/180) 5.-escribir sen,cose,tang 6.-fin *prueba de escritorio grad=50 seno=0.76604444 coseno=0.64278760 tangente=1.19175359 *Implementación del algoritmo en JAVA. package procesos.secuenciales; /* Diseñar un algoritmo que permita calcular las funciones trigonométricas básicas como: seno, coseno y tangente de un ángulo ingresado */ //paquete e/s datos por consola import JAVA.util.Scanner; import JAVA.math.BigDecimal; //clase principal public class Ejercicio17_PS { //metodo principal public static void main(String args[]){ //declarar variales int grad; double seno,coseno,tangente; Scanner lectura=new Scanner(System.in); //entrada de datos System.out.print("ingresar angulo en grados sexagesimales:"); grad=lectura.nextInt(); //proceso de los datos seno=Math.sin(grad*3.14159265/180); coseno=Math.cos(grad*3.14159265/180); tangente=Math.tan(grad*3.14159265/180); //salida de datos System.out.println("el seno de "+grad+" es="+seno); System.out.println("el coseno de "+grad+" es="+coseno); System.out.println("la tangente de "+grad+" es="+tangente); }//fin del metodo }//fin de la clase
Página 35 de 237
Italo Yaranga Vite *Ejecución del programa.
18. Diseñar un algoritmo que digite el radio y la altura de un cilindro y muestre su volúmen, área lateral y área total. Solución: *Analisis de datos e:r(radio),h(altura) s:v(volumen),at(area total),al(area lateral) *Algoritmo 1.- inicio 2.- r=0.0,h=0.0,v=0.0,at=0.0,al=0.0,ab=0.0(area de la base) 3.- leer r,h 4.- ab=3.14*r*r al=2*3.14*r*h at=al+2*ab v=ab*h 5.- escribir al,at,v 6.- fin *Prueba de Escritorio r=3 h=5 al=94.2 at=150.72 v=141.3
Página 36 de 237
Italo Yaranga Vite *Implementación del algoritmo en JAVA. package procesos.secuenciales; /* Digite el radio y la altura de un cilindro y muestre su volúmen, área lateral y área total */ //paquete e/s datos por consola import JAVA.util.Scanner; import JAVA.math.BigDecimal; //clase principal public class Ejercicio18_PS { //metodo principal public static void main(String args[]){ //declarar variales double r,h,v,at,al,ab; Scanner lectura=new Scanner(System.in); //entrada de datos System.out.print("Ingrese el radio:"); r=lectura.nextDouble(); System.out.print("Ingrese la altura:"); h=lectura.nextDouble(); //proceso de los datos ab=3.14*r*r; al=2*3.14*r*h; at=al+2*ab; v=ab*h; //salida de datos System.out.println("Area Lateral:"+al); System.out.println("Area Total:"+at); System.out.println("Volumen:"+v); }//fin del metodo }//fin de la clase
*Ejecución del programa.
Página 37 de 237
Italo Yaranga Vite 19.
Diseñar un algoritmo que digite un número natural de dos cifras y muestre el promedio de sus cifras.
Solución: *Analisis de datos e:n(numero) s:prom(promedio de cifras) *Algoritmo 1.- inicio 2.- n=0,Prom=0.0,d=0.0,u=0.0 3.- leer n; 4.- d=n/10 u=n%10 prom=(d+u)/10 5.- escribir prom 6.- fin *Prueba de Escritorio n=99 prom=9
*Implementación del algoritmo en JAVA. package procesos.secuenciales; /* 19.- Diseñar un algoritmo que digite un número natural de dos cifras y muestre el promedio de sus cifras. */ //paquete e/s datos por consola import JAVA.util.Scanner; //clase principal public class Ejercicio19_PS { //metodo principal public static void main(String args[]){ //declarar variales int n=0; double prom,d,u; Scanner lectura=new Scanner(System.in); //entrada de datos System.out.print("ingrese el numero:"); n=lectura.nextInt(); //proceso de los datos d=n/10; u=n%10; prom=(d+u)/2; //salida de datos System.out.println("promedio de cifras:"+prom); }//fin del metodo }//fin de la clase
Página 38 de 237
Italo Yaranga Vite *Ejecución del programa.
20. Diseñar un algoritmo que dados tres numeros positivos ,calcule la media armonica(permite medir velocidades). Solución: Análisis de datos e:n1,n2,n3 s:mh(media armoonica) Algoritmo 1.-inicio 2.-n1=0.0,n2=0.0,n3=0.0,mh=0.0 3.-leer n1,n2,n3 4.-mh=3/(1/n1+1/n2+1/n3) 5.-escribir mh 6.-fin prueba de escritorio n1=12 n2=16 n3=11 mh=12.672
Página 39 de 237
Italo Yaranga Vite *Implementación del algoritmo en JAVA. /* Diseñar un algoritmo que dados tres numeros positivos ,calcule la media armonica. */ //libreria de e/s de datos por consola #include //permite brindar comandosde lectura y escritura //programa principal main(){ // declarar variables double n1,n2,n3,mh; //real //entrada de datos coutn1; coutn2; coutn3; //proceso de datos mh=3/(1/n1+1/n2+1/n3); //salida de datos cout=10.5 ‘aprobado’ ,’desaprobado’ Estado =0 entonces m='si existe' sino m='no existe' fin de si 5.-escribir pos,m 6.-fin *Prueba de Escritorio 10-20-30-40-50 nb=30 m='si existe' pos=2
Página 186 de 237
Italo Yaranga Vite *Implementación del algoritmo en JAVA. package arreglo.datos; /* 1.-Diseñar un algoritmo que permita almacenar en un arreglo de datos cinco números ingresados y realizar una búsqueda mediante un número ingresado. Visualizar un mensaje indicando si el número existe o no existe y la posición del número en el arreglo de datos. */ //Paquete de datos e/s de datos por consola import java.util.Scanner; //clase principal public class Ejercicio1_Arreglos { //metodo tipo funcion fbuscar static int fbuscar(int arr[],int xnb){ int xpos=0,i=0; //arr.length devuelve la cantidad elemetos que tiene el arreglo for(i=0;i
