Alumno: SOTO ESPINO CARLOS JOSIMAR RESOLUCIÓN Ejercicio 2. Desarrollar un Algoritmo que indica si un año es bisiesto. Un año es bisiesto si es divisible por cuatro, excepto cuando es divisible por 100, a no ser que sea divisible por 400. Así, 1900 no fue bisiesto, pero 2000 sí lo fue.
Pseudocódigo: Algoritmo ejercicio2 Variables Entero año Inicio Leer Si(añoMOD4=o Si(añoMOD4= o y añoMOD100<>0 añoMOD100<>0)) entonces Escribir(“el año es bisiesto”) Sino Si(añoMOD100=0 y añoMOD400=0) Escribir(“el año es bisiesto”) Sino Escribir(“el año no es bisiesto”) Fin-si Fin-si Fin
Java: package UNFV.JAVA.PR UNFV.JAVA.PRINCIPAL; INCIPAL; import javax.swing.*; public class class EJERCICIO_2 EJERCICIO_2 { public static static void main(String[] main(String[] args){ args){ int año ; String añoCad; añoCad=JOptionPane.showInputDialog(null,"ingrese el año"); año=Integer.parseInt(añoCad); if (año%4==0 && año%100!=0){ JOptionPane.showMessageDialog(null,"el año es bisiesto"); } else{ if(año%100==0 && año%400==0){ JOptionPane.showMessageDialog(null,"el año es bisiesto"); } else{ JOptionPane.showMessageDialog(null,"el año no es bisiesto");
} }
} }
Ejercicio 3. Calcular el promedio de calificaciones de un alumno. Las dos primeras notas valen 30% cada una y la tercera 40%. Si el promedio es mayor o igual a 11 imprimirá aprobado, de lo contrario dirá reprobado. Si el promedio es igual a 20, dirá alumno excelente. Se desea imprimir el nombre del alumno, código de la materia y el promedio obtenido.
Pseudocódigo: Algoritmo ejercicio3 Variables entero nota,nota1,nota2,nota3,promedio Cadena alumno Inicio Leer nota nota1 ← nota * 0.3 nota2 ← nota * 0.3 nota3 ← nota * 0.4 promedio ←nota1 + nota2 + nota3 si (promedio = 20) entonces escribir (“Alumno (“Alumno Excelente”) Excelente” ) sino si( promedio >=11) entonces entonces escribir( “Aprobado” “Aprobado”)) sino escribir(“Reprobado” escribir( “Reprobado”)) Escribir (promedio) Fin
Java: package UNFV.JAVA.PR UNFV.JAVA.PRINCIPAL; INCIPAL; import javax.swing.*; public class class EJERCICIO3 EJERCICIO3 { public static static void main(String[] main(String[] args){ args){ int nota1,nota2,nota3,nota,promedio,p1,p2,p3; String nota1Cad,nota2Cad,nota3Cad,nombre,codigo; nombre=JOptionPane.showInputDialog(null,"ingrese nombre"); codigo=JOptionPane.showInputDialog(null,"ngrese codigo"); nota1Cad=JOptionPane.showInputDialog(null,"ingrese nota 1 "); nota2Cad=JOptionPane.showInputDialog(null,"ingrese nota 2 "); nota3Cad=JOptionPane.showInputDialog(null,"ingrese nota 3"); nota1=Integer.parseInt(nota1Cad); nota2=Integer.parseInt(nota2Cad); nota3=Integer.parseInt(nota3Cad); p1=nota1*3; p2=nota2*3; p3=nota3*4; promedio=(p1+p2+p3)/10; promedio=(p1+ p2+p3)/10; if(promedio==20){ JOptionPane.showMessageDialog(null,"excelente"); } else{ if(promedio>11){ JOptionPane.showMessageDialog(null,"alumno aprobado"); } else{ JOptionPane.showMessageDialog(null,"aluno aprobado"); } } } }
Ejercicio 4. Dado un número introducido por el usuario, indicar si éste es positivo, negativo o nulo. Resuélvelo usando estructura selectiva simple.
Pseudocódigo: Algoritmo ejercicio4 Entero num Inicio Leer num Si num > 0 entonces “Positivo”
Si num = 0 entonces “nulo”
Si num < 0 entonces “negativo”
Escribir num Fin
Java: package UNFV.JAVA.PRINCIPAL; import javax.swing.JOptionPane; public class Numero { public static void main(String[] args) args) { int numero; numero=Integer.parseInt(JOptionPane.showInputDialog("numero")); if (numero>=0) { if(numero>0) JOptionPane.showMessageDialog(null,"positivo"); else JOptionPane.showMessageDialog(null,"nulo"); } if (numero<0) { JOptionPane.showMessageDialog(null,"negativo"); } } }
Ejercicio 5. Escribir una programa tal que dados los goles del equipo local (gl) y los goles del equipo visitante (gv), devuelva una cadena de caracteres indicando qué equipo ha ganado (resultados posibles: ‘local’, ‘visitante’, ‘empate’).
Pseudocódigo: Algoritmo ejercicio5 Algoritmo ejercicio5 Variables Variabl es Entero gl,gv Inicio Leer (gl, gv) Si (gl > gv) entonces Escribir( “Local”) sino Si (gv > gl )entonces Escribir( “Visita”) Si Escribir( “Empate”) Escribir (“resultado ”) Fin
Java: import javax.swing.*; public class tarea5 { public static void main(String[] args) { String goleslocalCad,golesvisitanteCad; int goleslocal,golesvisitante; goleslocalCad=JOptionPane.showInputDialog(null, "ingresar goles del local"); goleslocal=Integer.parseInt(goleslocalCad); golesvisitanteCad=JOptionPane.showInputDialog(null, "ingresar goles del visitante"); golesvisitante=Integer.parseInt(golesvisitanteCad); if (goleslocal>golesvisitante) JOptionPane.showMessageDialog(null,"gano local"); else if (golesvisitante
Ejercicio 6. Dadas las lecturas del valor anterior y el actual de un medidor de luz, escribir un programa que determine a cuánto asciende la factura de la luz de un determinado usuario. El importe es la suma de la cuota fija (12 soles) más una cuota variable que depende del consumo y se calcula por tramos: los primeros 100 Kws, a 0.06 soles el Kw; los 150 Kws siguientes, a 0.04 soles el Kw; si el consumo excede de 250 Kws, esa fracción se cobra a 0.02 soles el Kw.
Pseudocódigo: Inicio
Leer cf , cv ; cf = 12 Si consumo1 <= 100 entonces cuota1 = cf + (consumo1 * 0.06 ) Si consumo2 <=250 entonces cuota2 = cf + (100 * 0.06 ) + (( 250
– consumo2) *0.04 )
Si consumo3 > 250 entonces cuota3 = cf + (100 * 0.06 ) + (150 * 0.04 ) + ((consumo3 250)*0.02) Escribir Consumo Fin
–
Ejercicio 7. Un banco antes de conceder un préstamo, comprueba los ingresos del solicitante. Si los ingresos son superiores a 12000 soles anuales, el crédito se concede. Si los ingresos son inferiores a 12000 soles anuales pero superiores a 10000 soles y el cliente tiene máximo 2 hijos, el crédito se concede. También se le concede, si tiene ingresos entre 8000 y 10000 soles pero no tiene hijos. Realizar un programa que pida los ingresos anuales y el número de hijos del solicitante, y diga si se le da el crédito o no.
Pseudocódigo: Algoritmo Algoritmo Variables Variabl es
ejercicio7 ejercici o7
Inicio Leer ingresos, NumHi , Si ingresos > 12000 entonces “Credito se concede”
Si ingresos > 10000 && ingresos < 12000 ^ NumHi = 2 entonces “Credito se concede”
si no entonces “Credito No concede”
Si ingresos > 8000 && ingresos < 10000 ^ NumHi = 0 entonces “Credito se concede”
si no entonces “Credito No concede”
Escribir ingresos Fin
Ejercicio 8. Diseñe un programa que lea el importe de la compra y la cantidad recibida y calcule el cambio a devolver, teniendo en cuenta que el número de monedas que se devuelven debe ser mínimo. Suponer que el sistema monetario utilizado consta de monedas de 100, 50, 25, 5 y 1 unidad, y que hay capacidad ilimitada de monedas.
Pseudocódigo: Algoritmo ejercicio8 Variables Variables Entero INICIO Importe, cantidad, moneda100, moneda50, moneda25, moneda5, moneda1 Leer Importe, cantidad, moneda100, moneda50, moneda25, moneda5, moneda1
← cantidad – importe; moneda100 moneda1 00 ← moneda1/100; moneda1 /100; moneda1 ← moneda1%100; moneda1% 100; moneda50 moneda5 0 ← moneda1/50; moneda1 /50; Cambio
moneda1=moneda1 moneda1 =moneda1%50; %50;
← moneda1/25; moneda1 /25; moneda1 ← moneda1%25; moneda1% 25; moneda5 ← moneda1/5; moneda1/ 5; moneda1 ← moneda1%5; moneda1% 5; moneda25 moneda2 5
Escribir Cambio, moneda100, moneda50, moneda25, moneda5, moneda1; Fin
Java: package UNFV.JAVA.PR UNFV.JAVA.PRINCIPAL; INCIPAL; import javax.swing.*; public class class EJERCICIO8 EJERCICIO8 {
public static static void main(String[] main(String[] args) args) { int impot,cant,mont = 0,c1,c2,c3,c4,c5,c6; String impotcad,cantcad; impotcad=JOptionPane.showInputDialog(null, "INGRESAR IMPORTE DE LA COMPRA:"); impot=Integer.parseInt(impotcad); cantcad=JOptionPane.showInputDialog(null, "INGRESAR CANTIDAD RECIBIDA:"); cant=Integer.parseInt(cantcad); mont=cant-impot; c1=mont/100; c2=(mont-c1*100)/50; c3=(mont-c1*100-c2*50)/25; c4=(mont-c1*100-c2*50 - c3*25)/10; c5=(mont-c1*100-c2*50 c5=(mont-c 1*100-c2*50 - c3*25-c4*10)/5; c6=(mont-c1*100-c2*50 - c3*25-c4*10-c5*5)/1; JOptionPane.sh owMessageDialog(null," JOptionPane.showMessageDialog( null," monedas de 100 = \n" +c1); JOptionPane.showMessageDialog( JOptionPane.sh owMessageDialog(null," null," monedas de 50 =\n" +c2); JOptionPane.showMessageDialog( JOptionPane.sh owMessageDialog(null," null," monedas de 25 =\n" +c3); JOptionPane.showMessageDialog( JOptionPane.sh owMessageDialog(null," null," monedas de 10 =\n" +c4); JOptionPane.showMessageDialog( JOptionPane.sh owMessageDialog(null," null," monedas de 5 =\n" +c5); JOptionPane.showMessageDialog( JOptionPane.sh owMessageDialog(null," null," monedas monedas de 1 =\n" +c6); }
}
Ejercicio 9. Escriba un algoritmo que lea tres números enteros de un supuesto triángulo, determine si realmente forman un triángulo, y muestre el tipo de triángulo que es (si es un triángulo). a) triángulo: La suma de dos cualesquiera de los lados debe ser mayor que el otro. b) equilátero: todos todos los lados son iguales. c) isósceles: solo dos lados son iguales. d) escaleno: no tiene dos lados iguales.
Pseudocódigo: algoritmo
ejercicio9
variables entero lado1,lado2,lado3 inicio leer lado1,lado2,lado3 si((lado1
sino si((lado1<>lado2)y(lado1<>lado3)y(lado2<>lado3)) entonces escribir(“ el triangulo es escaleno”) sino escribir(“el triangulo es isósceles”) fin-si fin-si fin-si fin
JAVA: package UNFV.JAVA.PRINCIPAL; import javax.swing.*; public class EJERCICIO_9 { public static void main(String[] args) args) { int lado1,lado2,lado3; String lado1Cad,lado2Cad,lado3Cad; lado1Cad=JOptionPane.showInputDialog(null,"ingrese lado1"); lado2Cad=JOptionPane.showInputDialog(null,"ingrese lado2"); lado3Cad=JOptionPane.showInputDialog(null,"ingrese lado3"); lado1=Integer.parseInt(lado1Cad); lado2=Integer.parseInt(lado2Cad); lado3=Integer.parseInt(lado3Cad); if((lado1
}
Ejercicio 10. Dos entidades financieras ofrecen las siguientes tasas de interés simple:
Desarrollar un programa que realice lo siguiente: Solicite al usuario que ingrese el monto de de dinero que desea depositar y el tiempo (meses) que lo mantendrá en el banco. Determine cual de las dos entidades, A o B, es mas conveniente para depositar el dinero y muestre un mensaje indicando en que banco debería el usuario depositar el monto ingresado, y cuanto dinero tendrá luego de transcurrido el tiempo que indico al inicio. Nota: Para calcular el interés simple se utiliza la siguiente formula: Interés = Capital * Tasa * Tiempo
JAVA: package UNFV.JAVA.PRINCIPAL; import javax.swing.*; public class EJERCICIO10 {
public static void main(String[] args) { int mont=0,meses=0,a,b; String montcad, mesescad; double inter1 = 0,inter2 = 0,total1,total2; montcad=JOptionPane.showInputDialog(null,"INGRESAR MONTO A DEPOSITAR:"); mont=Integer.parseInt(montcad); mesescad=JOptionPane.showInputDialog(null,"INGRESAR MESES:"); meses=Integer.parseInt(mesescad); if(mont>=0 && mont<=500) {inter1=meses*mont*0.05;} if(mont>=0 && mont<=600) {inter2=meses*mont*0.07;} if(mont>500 && mont<4500) {inter1=meses*mont*0.12;} if(mont>600 && mont<3500) {inter2=meses*mont*0.10;} if(mont>=4500) {inter1=meses*mont*0.16;} if(mont>=3500) {inter2=meses*mont*0.15;} total1=mont+inter1; total2=mont+inter2; if(total1 > total2)
{JOptionPane.showMessageDialog(null,"CONVIENE BANCO A\n"+total1);} else if (total2 > total1) {JOptionPane.showMessageDialog(null,"CONVIENE BANCO B \n "+total2);} }
}
Ejercicio 12. Determinar la cantidad de dinero que recibirá un trabajador por concepto de las horas extras trabajadas en una empresa, sabiendo que cuando las horas de trabajo exceden de 40, el resto se consideran horas extras y que éstas se pagan al doble de una hora normal cuando no exceden de 8; si las horas extras exceden de 8 se pagan las primeras 8 al doble de lo que se paga por una hora normal y el resto al triple. Pseudocódigo: Algoritmo ejercicio12 Variables Entero ht Real ph Inicio Leer (ht,ph) Si(ht>40) entonces he ← ht-40 si he>8 entonces het← he-8 phe← ph*2*8+ph*3*het sino phe ← ph*2*he fin-si pt← ph*40+phe sino pt← ph*ht fin-si escribir(pt) fin
Ejercicio 14. Leer dos números reales LS y LI que representan los limites superior e inferior de un intervalo, respectivamente. Dado un numero n determine si dicho numero pertenece al intervalo. En caso contrario, indique si está a la derecha o izquierda del intervalo.
Pseudocódigo: VARIABLES: REAL: LS,LI,n INICIO ESCRIBIR: ("INGRESE LIMITE INFERIOR:") LEER: LI ESCRIBIR: ("INGRESE LIMITE SUPERIOR:") LEER: LS ESCRIBIR ("INGRESE NUMERO:"); LEER: n SI (n>=LI) y( n<=LS) entonces Escribir (“PERTENECE AL INTERVALO”) sino si (nLS)entonces escribir("A LA DERECHA DEL INTERVALO") fin_si fin_si fin_si FIN
JAVA: package unfv.java.principal; import javax.swing.*; public class ejercicio5{ public static void main(String[] args) { String LScad,LIcad,ncad; double LS,LI,n; LIcad=JOptionPane.showInputDialog(null,"INGRESE LIMITE INFERIOR:"); LI=Integer.parseInt(LIcad); LScad=JOptionPane.showInputDialog(null,"INGRESE LIMITE SUPERIOR:"); LS=Integer.parseInt(LScad); ncad=JOptionPane.showInputDialog(null,"INGRESE NUMERO:"); n=Integer.parseInt(ncad); if(n>=LI && n<=LS){JOptionPane.showMessageDialog(null,"PERTENECE AL INTERVALO");} else{ if(n
if(n>LS){JOptionPane.showMessageDialog(null,"A LA DERECHA DEL INTERVALO..");} } } } }
Ejercicio 15. Una tienda ha puesto en oferta la venta al por mayor de cierto producto, ofreciendo un descuento del 15% por la compra de más de 3 docenas y 10% en caso contrario. Además por la compra de más de 3 docenas se obsequia una unidad del producto por cada docena en exceso sobre 3. Diseñe un algoritmo que determine el monto de la compra, el monto del descuento, el monto a pagar y el número de unidades de obsequio por la compra de cierta cantidad de docenas del producto. Pseudocódigo:
Algoritmo ejercicio15 Variables Real montopag,montocom,montodes,precio Entero docenas,obsequio Inicio leer(docenas,obsequio) montocom← docenas*precio si(docenas>3 ) entonces montodes←0.15*montocom obsequio← docenas-3 sino montodes←0.10*montocom obsequio←0 fin-si montopag← montocomp-montodes escribir(montopag,montodes,montocom,obsequi) fin
Ejercicio 16. Una compañía dedicada al alquiler de automóviles cobra $30 hasta un máximo de 300 Km. de distancia recorrida. Para más de 300 Km. y hasta 1000 Km., cobra $30 más un monto adicional de $ 0.15 por cada kilómetro en exceso sobre 300. Para más de 1000 Km. cobra $30 más un monto adicional de $ 0.10 por cada kilómetro en exceso sobre 1000. Los precios ya incluyen el 18% del impuesto general a las ventas, IGV. Diseñe un algoritmo que determine el monto a pagar por el alquiler de un vehículo y el monto incluido del impuesto.
Pseudocódigo:
Algoritmo ejercicio16 Variables Real kilomrec,montopag,montoigv,montofijo=30,igv=0.18 Inicio
Leer (kilomrec) montofijo←30*kilomrec Si(kilomrec<=300) entonces montoadic← 0 sino si(kilomrec<=1000) montoadic← 0.15*(kilomrec-300) sino montoadic ←+ 0.15*700+0.10*(kilomrec-100) montopag←motofijo+montoadic montoigv← igv*montopag/(1+igv) escribir(montopag,montoigv) fin
Ejercicio 17. Diseñe un algoritmo para obtener el grado de eficiencia de un operario de una fábrica de tornillos, de acuerdo a las siguientes condiciones, que se le imponen para un período de prueba: - Menos de 200 tornillos defectuosos. - Más de 10000 tornillos producidos. El grado de eficiencia se determina de la siguiente manera: - Si no cumple ninguna de las condiciones, grado 5. - Si sólo cumple la primera condición, grado 6. - Si sólo cumple la segunda condición, grado 7. - Si cumple las dos condiciones, grado 8.
Pseudocódigo: Algoritmo ejercicio17 Variables Entero def,prod,grado Inicio Leer(def,prod) Si(def>200 y prod<1000) entonces grado←5 sino si(def<200 y prod<1000) entonces grado←6 sino si(def>200 y prod>1000) entonces grado←7 sino grado←8 fin-si fin-si fin-si escribir(“el grado de eficiencia del operario es:”,grado) fin
JAVA: public class EJERCICIO_17 { public static void main(String[] args){ args){ int def,prod,grado; String defCad,prodCad; defCad=JOptionPane.showInputDialog(null,"ingrese deficiencia","titulo",1); prodCad=JOptionPane.showInputDialog(null,"ingrese producto","titulo",1); def=Integer.parseInt(defCad); prod=Integer.parseInt(prodCad); if(def>200 && prod<1000){ grado=5; } else{ if(def<200 && prod<1000){ grado=6; } else{ if(def>200 && prod>1000){ grado=7; } else{ grado=8; } JOptionPane.showMessageDialog(null,"el grado es :"+grado); } } } }
