20 ejercicios realizados en Java. •Ponce Martínez Isaac •Cecytem Tecámac •Grupo: 402

1. 20 EJERCICIOS PROPUESTOS
ALUMNO: PONCE MARTÍNEZ ISAAC
GRUPO: 402
TURNO: MATUTINO
MATERIA: DESARROLLA APLICACIONES MÓVILES
PROFESOR: DOMÍNGUEZ ESCALONA RENÉ
PLANTEL: CECYTEM TECÁMAC
Ponce Martínez Isaac
Página 1

2. ÍNDICE
Problema 1. .........................................................................................................................3
Problema 2 ..........................................................................................................................5
Problema 3. .........................................................................................................................7
Problema 4. .........................................................................................................................9
Problema 5. .......................................................................................................................12
Problema 6. .......................................................................................................................14
Problema 7. .......................................................................................................................16
Problema 8. .......................................................................................................................20
Problema 9. .......................................................................................................................23
Problema 10.......................................................................................................................26
Problema 11.......................................................................................................................28
Problema 12.......................................................................................................................30
Problema 13.......................................................................................................................33
Problema 14.......................................................................................................................35
Problema 15.......................................................................................................................37
Problema 16.......................................................................................................................40
Problema 17.......................................................................................................................42
Problema 18.......................................................................................................................44
Problema 19.......................................................................................................................46
Problema 20.......................................................................................................................48
Ponce Martínez Isaac
Página 2

3. Problema 1.
Descripción: Elaborar un algoritmo que calcule e imprima el costo de producción de un
articulo, teniendo como datos la descripción y el número de unidades producidas. El costo se
calcula multiplicando el número de unidades producidas por un factor de costo de materiales
de 3.5 y sumándole al producto un costo fijo de 10 700
Pseudocódigo: Inicio
String a
Double num,costo
Leer num
Algoritmo
(Num*3.5)+10700
Imprime costo
Fin
Diagrama de Flujo:
Código Java:
public static void Uno(){
String a= JOptionPane.showInputDialog("introduce numero de unidades");
double num=Double.parseDouble(a);
double COSTO=(num*3.5)+10700;
JOptionPane.showMessageDialog(null, "el costo total es : "+COSTO);
Ponce Martínez Isaac
Página 3

4. Pruebas de Escritorio:
En esta ventana se pide el número de unidades, para posteriormente dar el resultado que se
muestra a continuación y de esta manera concluir el programa:
Conclusión: Este programa nos sirve para sacar el costo de un producto dependiendo del
número de unidades producidas.
Ponce Martínez Isaac
Página 4

5. Problema 2
Descripción: Elaborar un algoritmo que calcule e imprima el costo de un terreno cuadrado o
rectangular, teniendo como datos la anchura y la longitud en metros, y el costo del metro
cuadrado.
Pseudocódigo: Inicio
Scanner leer
Doublé a,b,x,resultado,resp
Leer x
Leer a
Leer b
Algoritmo
Resultado =a*b
Res= resultado*x
Imprime resp
Fin
Diagrama de Flujo:
Ponce Martínez Isaac
Página 5

6. Código Java:
public static void Dos(){
Scanner leer=new Scanner (System.in);
double a,b,x,resultado, resp;
System.out.println("ingrese precio del terreno metro cuadrado");
x=leer.nextInt();
System.out.println("ingrese la altura");
a=leer.nextInt();
System.out.println("ingrese la base");
b=leer.nextInt();
resultado=a*b;
resp=resultado*x;
System.out.print("el precio por metro cuadrado es:"+ resp);
}
Pruebas de Escritorio:
s
Aquí se muestra que al inicio del programa, el mismo pide el precio del terreno en m²,
posteriormente pide la altura y la base del mismo y al final del programa te muestra el total a
pagar.
Conclusión: Este programa nos servirá para poder saber el precio de un terreno.
Ponce Martínez Isaac
Página 6

7. Problema 3.
Descripción: Elaborar un algoritmo que lea una cantidad de horas e imprima su equivalente en
Pseudocódigo: Inicio
Escribir “Introduce el numero de dólares a comprar”
Leer d;
Algoritmo
m=h*60;
s=h*60*60;
d=h/24;
Imprime m
Imprime s
Imprime d
Fin
Diagrama de Flujo:
Código Java:
Ponce Martínez Isaac
Página 7

8. public static void Tres(){
Scanner leer=new Scanner(System.in);
double m,s,d,h;
System.out.println("Ingrese el número de horas que desea transformar");
h=leer.nextInt();
m=h*60;
s=h*60*60;
d=h/24;
System.out.println("Las hora ingresada en minutos es: "+m);
System.out.println("Las hora ingresada en segundos es: "+s);
System.out.println("Las hora ingresada en dias es: "+d);
}
Prueba de Escritorio:
Aquí se muestra como el programa pide el número de horas que se desea transformar y
posteriormente se muestra las horas transformados en minutos, segundos y horas.
Conclusión: Este programa nos ayuda a transformar las horas en minutos, segundos y horas.
Ponce Martínez Isaac
Página 8

9. Problema 4.
Descripción: Similar al del alumno, con la diferencia de que en el lugar del promedio se
obtiene una calificación final, multiplicando las calificaciones 1,2,3 y 4 por los porcentajes de
30,20,12 y 40%, respectivamente, y sumando los productos.
Pseudocódigo: Inicio
Scanner a, w, s, x, b
String nom
Int cal1, cal2, cal3, cal4, fi, num1
Leer nom
Leer num1
Leer num2
Leer num3
Leer num4
Algoritmo
Cal1= (num1*30/100)
Cal2= (num2*20/100)
Cal2= (num3*12/100)
Cal5= (num5*40/100)
Fi= cal1+cal2+cal3+cal4
Imprime fin
Fin
Ponce Martínez Isaac
Página 9

10. Diagrama de Flujo:
Código Java:
public static void Cuatro() {
System.out.println("INTRODUCE TU NOMBRE");
Scanner a = new Scanner(System.in);
String nom = a.next();
int cal1,cal2,cal3,cal4,fi;
System.out.println("HOLA "+ nom);
System.out.println("INTRODUCE TU PRIMERA CALIFICACION");
Scanner w = new Scanner(System.in);
int num1 = w.nextInt();
System.out.println("INTRODUCE TU SEGUNDA CALIFICACION");
Scanner s = new Scanner(System.in);
Ponce Martínez Isaac
Página 10

11. int num2 = s.nextInt();
System.out.println("INTRODUCE TU TERCERA CALIFICACION");
Scanner x = new Scanner(System.in);
int num3 = x.nextInt();
System.out.println("INTRODUCE TU CUARTA CALIFICACION");
Scanner b = new Scanner(System.in);
int num4 = b.nextInt();
cal1=(num1*30/100);
cal2=(num2*20/100);
cal3=(num3*12/100);
cal4=(num4*40/100);
fi=(cal1+cal2+cal3+cal4);
System.out.println("TU CALIFICACION FINAL ES: " +fi);
}
Pruebas de Escritorio:
Aquí se muestra que por primero se pide el nombre del usuario, posteriormente se piden 4
calificaciones del mismo y al final te muestra la calificación final del mismo.
Conclusión: Este programa te sirve para sacar una calificación final de cuatro calificaciones
introducidas en el programa.
Ponce Martínez Isaac
Página 11

12. Problema 5.
Descripción: La velocidad de la luz es de 300 000 kilómetros por segundo. Elaborar un
algoritmo que lea un tiempo en segundos e imprima la distancia que recorre dicho tiempo.
Pseudocódigo: Inicio
Scanner a
Int i, r
Algoritmo
R=i*3000000
Imprime r
Fin
Diagrama de Flujo:
Código Java:
public static void Cinco(){
System.out.println("INGRESA EL TIEMPO EN SEGUNDOS");
Scanner a=new Scanner(System.in);
int i=a.nextInt();
int r;
r=i*3000000;
Ponce Martínez Isaac
Página 12

13. System.out.println("los kilometros recorridos son: " +r+"km");
}
public static void Seis(){
Scanner leer=new Scanner(System.in);
System.out.println("Ingresa valor de X");
System.out.println("x: ");
double x=leer.nextDouble();
double y=(3*x*x)+(7*x)-15;
System.out.println("Y= "+y);
}
Pruebas de Escritorio:
Aquí se muestra que principalmente se pide un número de segundos, para posteriormente
mostrar el número de kilómetros recorridos a la velocidad de la luz.
Conclusión: Este programa te sirve para saber los kilómetros recorridos a la velocidad de la luz
dependiendo de los segundos que se pongan en el programa.
Ponce Martínez Isaac
Página 13

14. Problema 6.
Descripción: Hacer un algoritmo que obtenga e imprima el valor de Y a partir de dicha
ecuación: Y=3x² + 7x – 15
Pseudocódigo: Inicio
Scanner leer
Double x, y
Leer x
Algoritmo
Y= (3*x*x)+(7*x)-15
Imprime y
Fin
Diagrama de Flujo:
Código Java:
public static void Seis(){
Scanner leer=new Scanner(System.in);
System.out.println("Ingresa valor de X");
System.out.println("x: ");
double x=leer.nextDouble();
double y=(3*x*x)+(7*x)-15;
Ponce Martínez Isaac
Página 14

15. System.out.println("Y= "+y);
}
Prueba de Escritorio:
Aquí se muestra que el programa pide el valor de la variable X y posteriormente con la formula
mencionada anteriormente te saca el resultado de la variable Y.
Conclusión: Este programa sirve para conocer el resultado de Y utilizando la formula escrita
anteriormente.
Ponce Martínez Isaac
Página 15

16. Problema 7.
Descripción: Una temperatura en grados Celsius© se puede convertir a su equivalente
Fahrenheit (F) con sus formulas correspondientes.
Elaborar un algoritmo que lea la temperatura en grados centígrados y obtenga e imprima la
temperatura en Fahrenheit equivalente.
Pseudocódigo: Inicio
Scanner leer
Int opción
Double b, c, d, e, f, g, h
Leer opcion
Si opcion=1
Algoritmo
D= (b-32)/1.8
Imprime d
Si no
Si opcion=2
Algoritmo
G=(b*1.8)+32
Imprime g
Sino
Si opcion=3
Algoritmo
H=(b/1.8)-32
Imprime h
Fin si
Fin si
Fin
Ponce Martínez Isaac
Página 16

17. Diagrama de Flujo:
Código Java: public static void Siete() {
Scanner leer=new Scanner(System.in);
int opcion;
double b,c,d,e,f,g,h;
Ponce Martínez Isaac
Página 17

18. System.out.println("selecciona de que grados a que grados deseas
transformar");
System.out.println("1.-Celcius: Farenheit");
System.out.println("2.-Farenheit: Celcius");
System.out.println("3.-Introduce tu opcion");
opcion =leer.nextInt();
System.out.println("introduce los grados que deseas transformar ");
b =leer.nextInt();
switch(opcion)
{
case 1:
d=(b-32)/1.8;
System.out.println("el resultado es: "+d);
break;
case 2:
g=(b*1.8)+32;
System.out.println("el resultado es: "+g);
break;
case 3:
h=(b/1.8)-32;
System.out.println("el resultado es: "+h);
break;
}
}
Prueba de Escritorio:
Ponce Martínez Isaac
Página 18

19. Aquí se muestra que el programa te da a elegir una de las tres opciones, una vez escogida una
de ellas ingresas el número de grados que deseas transformar y al final te da el resultado del
mismo.
Conclusión: Este programa te ayuda para saber transformar los grados que tu deseas.
Ponce Martínez Isaac
Página 19

20. Problema 8.
Descripción: Elabore un algoritmo que lea un número de pies y calcule e imprima su
equivalente en yardas, pulgadas, centímetros y metros, de acuerdo con las siguientes
equivalencias 1 pie= 12 pulgadas, 1 yarda=3 pies, 1 pulgada=2.54 cm, 1 metro =100cm.
Pseudocódigo: Inicio
Scanner leer
Double a, a1, a2, a3, a4
Leer a
Algoritmo
A1=a*12
A2=a/3
A3=a1*2.54
A4=a3/100
Imprime a2
Imprime a1
Imprime a3
Imprime a4
Fin
Diagrama de Flujo:
Ponce Martínez Isaac
Página 20

21. Código Java:
public static void Ocho(){
Scanner leer=new Scanner (System.in);
double a,a1,a2,a3,a4;
System.out.println("NUMERO DE PIES:");
a=leer.nextInt();
a1=a*12;
a2=a/3;
a3=a1*2.54;
a4=a3/100;
System.out.println("EQUIVALE EN YARDAS AH:"+ a2);
System.out.println("EQUIVALE EN PULGAS AH:"+ a1);
System.out.println("EQUIVALE EN CENTIMETROS AH:"+ a3);
System.out.println("EQUIVALE EN METROS AH:"+ a4);
}
Prueba de Escritorio:
Ponce Martínez Isaac
Página 21

22. Aquí se muestra como el programa pide el número de pies, una vez ingresado o puesto el
valor, se mostrará a lo que equivale el pie en yardas, pulgadas, centímetros y metros.
Conclusión: Este programa nos sirve para saber la equivalencia de los pies en la otras cuatro
medidas mencionadas anteriormente.
Ponce Martínez Isaac
Página 22

23. Problema 9.
Descripción: Elaborar un algoritmo que lea el artículo y su costo, la utilidad es el 150% y el
impuesto es del 15%, calcular e imprimir el artículo, utilidad, impuesto y precio de venta.
Pseudocódigo: Inicio
Int pro, po, pro2
Scanner a, b
String pro1
Leer a
Leer b
Algoritmo
Pro= (pro2*150)/100
Po= (pro2*15)/100
Imprime pro1
Imprime pro
Imprime po
Imprime pro2
Fin
Diagrama de Flujo:
Ponce Martínez Isaac
Página 23

24. Código Java:
public static void Nueve(){
int pro, po;
System.out.println(" Introduce el nombre del producto");
Scanner a = new Scanner(System.in);
String pro1 = a.next();
System.out.println(" Introduce el precio del producto");
Scanner b = new Scanner(System.in);
int pro2 = b.nextInt();
pro=(pro2 *150)/100;
po=(pro2 *15)/100
System.out.println(" NOMBRE DEL PRODUCTO: " +pro1);
System.out.println(" SU UTILIDAD: " +pro+" pesos");
System.out.println(" SU IMPUESTO: " +po+" pesos");
System.out.println(" SU PRECIO: " +pro2+" pesos");
}
Ponce Martínez Isaac
Página 24

25. Prueba de Escritorio:
Aquí se muestra que principalmente el programa pide el nombre del producto y
posteriormente el precio del mismo al final se muestra el nombre del producto, su utilidad,
impuesto y precio.
Conclusión: Este programa nos sirve para introducir algún producto, su precio y al final nos
muestra su utilidad, impuesto y su precio.
Ponce Martínez Isaac
Página 25

26. Problema 10.
Descripción: Elaborar un algoritmo que lea el radio de un circulo e imprima el área.
Pseudocódigo: Inicio
Scanner leer
Double a, r
Leer a
Algoritmo
R=(3.1416*a*a)
Imprime r
Diagrama de Flujo:
Código Java:
public static void Diez(){
Scanner leer=new Scanner(System.in);
double a;
double r;
System.out.println("introduce el radio del circulo");
a =leer.nextInt();
r=(3.1416*a*a);
System.out.println("el resultado es: "+r);
Ponce Martínez Isaac
Página 26

27. }
Prueba de Escritorio:
Aquí se muestra como el programa pide el radio del círculo y posteriormente una vez
introducido el radio se muestra el área del círculo.
Conclusión: Este programa nos sirve para sacar el área de un círculo de una manera más
rápida.
Ponce Martínez Isaac
Página 27

28. Problema 11.
Descripción: Elaborar un algoritmo que lea la cantidad de dólares a comprar, calcular e
imprimir la cantidad a pagar en pesos por la cantidad de dólares indicada.
Pseudocódigo: Inicio
Escribir "Introduzca numero de dolares a comprar"
Leer dolar
double a,b
Algoritmo
a=13.65
b=dolar*b;
Imprime "El total a pagar en pesos mexicanos por el numero de dólares que se quiere
es",b
Fin
Diagrama de Flujo:
Código Java:
public static void Once(){
System.out.println("Introduzca la cantidad de dolares a comprar:");
Scanner leer=new Scanner(System.in);
Ponce Martínez Isaac
Página 28

29. int dolar=leer.nextInt();
double a,b;
a=13.65;
b=dolar*a;
System.out.println("el total a pagar en pesos mexicanos por el numero de dolares que
quiere es: " +b);
}
Prueba de Escritorio:
Aquí se mira como el programa pide el número de dólares a comprar y posteriormente se
muestra la cantidad pagar en pesos mexicanos.
Conclusión: Este programa nos sirve para saber cuánto vamos a pagar por cierto número de
dólares.
Ponce Martínez Isaac
Página 29

30. Problema 12.
Descripción: Elaborar un algoritmo que permita leer valores para X,Y,Z y W e imprima el valor
de F con dicha ecuación.
Pseudocódigo: Inicio
Scanner leer
Escribir "Introduce valor de W,X,Y,Z"
Leer w
Leer x
Leer y
Leer z
Algoritmo
double a=(x*x)*(y*y)*4;
double b=Math.sqrt(z*w*2);
double c=(a*b);
double d=c*c;
double e=(x*0.5)*4;
double f=d/e;
Imprime "F= ",f
Fin
Ponce Martínez Isaac
Página 30

31. Diagrama de Flujo:
Código Java:
public static void Doce(){
Scanner leer= new Scanner (System.in);
System.out.println("Ingresa los digitos W,X,Y y Z Respectivamente:");
System.out.println("W: ");
int w= leer.nextInt();
System.out.println("X: ");
int x= leer.nextInt();
System.out.println("Y: ");
int y= leer.nextInt();
System.out.println("Z: ");
int z= leer.nextInt();
Ponce Martínez Isaac
Página 31

32. double a=(x*x)*(y*y)*4;
double b=Math.sqrt(z*w*2);
double c=(a*b);
double d=c*c;
double e=(x*0.5)*4;
double f=d/e;
System.out.println("F= "+f);
}
Prueba de Escritorio:
Aquí se ve como el programa pide el valor de w,x,y,z y posteriormente te da el resultado de F.
Conclusión: Este programa nos ayuda a encontrar el valor de F introduciendo los datos
pedidos anteriormente.
Ponce Martínez Isaac
Página 32

33. Problema 13.
Descripción: Elaborar un algoritmo que lea el radio de una esfera, calcule e imprima el
volumen y el área.
Pseudocódigo: Inicio
Escribir “El radio de la esfera”
Leer r
Algoritmo
v=(4*3.146)*(r*r);
a=(3.146*r*r);
Imprime v
Imprime a
Fin
Diagrama de Flujo:
Código Java:
public static void Trece() {
Scanner leer=new Scanner(System.in);
double v,r,a;
System.out.println("Ingrese el radio de la esfera");
Ponce Martínez Isaac
Página 33

34. r=leer.nextInt();
v=(4*3.146)*(r*r);
a=(3.146*r*r);
System.out.println("El volumen de la esfera es: "+v);
System.out.println("El area de la esfera es: "+a);
}
Prueba de Escritorio:
Aquí se muestra como el programa pide que se ingrese el radio de la esfera y posteriormente
el mismo da a conocer el volumen y el área de la esfera.
Conclusión: Este programa nos sirve para poder saber de manera rápida el volumen y el área
de una esfera tan solo dando el valor al radio de la misma.
Ponce Martínez Isaac
Página 34

35. Problema 14.
Descripción: Elaborar un algoritmo que lea el valor de W e imprima el valor de Z.
Pseudocódigo: Inicio
Escribir "Introduce el valor de W"
Leer d
Algoritmo
double z =(1/(Math.sqrt(2*Math.PI)))* Math.pow(Math.E, (Math.pow(de,
2)/2));
Imprime "El valor de z= ", z
Fin
Diagrama de Flujo:
Código Java:
public static void Catorce(){
String d = JOptionPane.showInputDialog("introduce w");
double de=Double.parseDouble(d);
double z =(1/(Math.sqrt(2*Math.PI)))* Math.pow(Math.E, (Math.pow(de, 2)/2));
JOptionPane.showMessageDialog(null,"el valor de z="+z);
}
Prueba de Escritorio:
Ponce Martínez Isaac
Página 35

36. En esta ventana el programa pide que se le asigne un valor a W, posteriormente el programa
con la formula dicha se sacará el resultado como se muestra a continuación:
Conclusión: Este programa nos servirá para sacar el valor de Z con dicha fórmula mencionada
anteriormente.
Ponce Martínez Isaac
Página 36

37. Problema 15.
Descripción: Elaborar un algoritmo que lea la cantidad de dólares a comprar y el tipo de
cambio (costo de un dólar) en: yenes, pesetas, libras esterlinas y marcos; calcular e imprimir la
cantidad a pagar en yenes, pesetas, libras esterlinas y marcos.
Pseudocódigo: Inicio
Escribir “Introduce el numero de dólares a comprar”
Leer d
Algoritmo
y=(d*91.2001);
p=(d*100);
l=(d*0.597);
m=(d*1.330 );
Imprime y
Imprime p
Imprime l
Imprime m
Fin
Diagrama de Flujo:
Ponce Martínez Isaac
Página 37

38. Código Java:
public static void Quince(){
Scanner leer=new Scanner(System.in);
double d,y,p,l,m;
System.out.println("Introduce el numero de dolares a comprar");
d=leer.nextInt();
y=(d*91.2001);
p=(d*100);
l=(d*0.597);
m=(d*1.330 );
System.out.println("La cantidad a pagar en yenes es: "+y);
System.out.println("La cantidad a pagar en pesetas es: "+p);
System.out.println("La cantidad a pagar en libras esterlinas es: "+l);
System.out.println("La cantidad a pagar en marcos es: "+m);
}
Prueba de Escritorio:
Ponce Martínez Isaac
Página 38

39. Aquí se muestra como el programa pide el número de dólares a comprar y posteriormente el
mismo te da la cantidad a pagar en yenes, pesetas, libras esterlinas y marcos.
Conclusión: Este programa nos ayuda a saber la cantidad que vamos a pagar en yenes,
pesetas, libras esterlinas y marcos de dichos dólares.
Ponce Martínez Isaac
Página 39

40. Problema 16.
Descripción: Elaborar un algoritmo que permita leer un valor e imprima el logaritmo natural, el
exponencial, el valor absoluto y la raíz cuadrada.
Pseudocódigo: Inicio
Escribir "El numero x"
Leer x
Algoritmo
double x=leer.nextDouble();
double lo=Math.log(x);
double ex=Math.exp(x);
double ab=Math.abs(x);
double raiz=Math.sqrt(x);
Imprime "logaritmo= "+lo+"n exponencial= "+ex+"n absoluto= "+ab+"n raiz= "+raiz"
Fin
Diagrama de Flujo:
Código Java:
public static void Dieciseis(){
Ponce Martínez Isaac
Página 40

41. int r;
Scanner leer=new Scanner(System.in);
System.out.println("el numero x");
System.out.println("x:");
double x=leer.nextDouble();
double lo=Math.log(x);
double ex=Math.exp(x);
double ab=Math.abs(x);
double raiz=Math.sqrt(x);
System.out.println("logaritmo= "+lo+"n exponencial= "+ex+"n absoluto= "+ab+"n raiz=
"+raiz);
}
Prueba de Escritorio:
Aquí se muestra como el programa pide que se le asigne un valor a la variable X y
posteriormente te saca los resultados del logaritmo, exponencial, valor absoluto y raíz
cuadrada.
Ponce Martínez Isaac
Página 41

42. Problema 17.
Descripción: Elaborar un algoritmo que permita leer el tamaño de un ángulo en radianes e
imprima la tangente, cotangente, secante y cosecante.
Pseudocódigo: Inicio
Escribir "Angulo en radianes"
Escribir "Radianes"
Leer r
Algoritmo
double ta= Math.sin(r)/Math.cos(r);
double cot= Math.cos(r)/Math.sin(r);
double sec=1/Math.cos(r);
double cosec=1/Math.sin(r);
Imprime "Tangente=" + ta + "n contangente =" +cot+"n secante=" +sec+"n
cosecante="+ cosec"
Fin
Diagrama de Flujo:
Ponce Martínez Isaac
Página 42

43. Código Java:
public static void Diecisiete(){
Scanner leer=new Scanner(System.in);
System.out.println("angulo en radianes: ");
System.out.println("radianes: " );
double r= leer.nextDouble();
r= Math.toRadians (r);
double ta= Math.sin(r)/Math.cos(r);
double cot= Math.cos(r)/Math.sin(r);
double sec=1/Math.cos(r);
double cosec=1/Math.sin(r);
System.out.println ("Tangente=" + ta + "n contangente =" +cot+"n secante="
+sec+"n cosecante="+ cosec);
}
Prueba de Escritorio:
Aquí se muestra como el programa pide el ángulo en radianes y posteriormente el mismo
programa saca el resultado de la tangente, cotangente, secante y cosecante.
Conclusión: Este programa nos ayuda a sacar la tangente, cotangente, secante y cosecante de
una manera más fácil y rápida.
Ponce Martínez Isaac
Página 43

44. Problema 18.
Descripción: Elaborar un algoritmo similar al anterior; sólo que el dato que se lee estará en
grados. Debe convertirse los grados leídos a radianes antes de hacer los cálculos.
Pseudocódigo: nicio
Escribir "Angulo en radianes"
Escribir "Radianes"
Leer r
Algoritmo
double ta= Math.sin(r)/Math.cos(r);
double cot= Math.cos(r)/Math.sin(r);
double sec=1/Math.cos(r);
double cosec=1/Math.sin(r);
Imprime "Tangente=" + ta + "n contangente =" +cot+"n secante=" +sec+"n
cosecante="+ cosec"
Fin
Diagrama de Flujo:
Código Java:
Ponce Martínez Isaac
Página 44

45. public static void Dieciocho(){
Scanner leer=new Scanner(System.in);
System.out.println("Angulo de Radianes");
System.out.println("angulo:");
double r=leer.nextDouble(); r=Math.toRadians(r);
double ta=Math.sin(r)/Math.cos(r);
double cot=Math.sin(r)/Math.cos(r);
double sec=1/Math.cos(r);
double cosec=1/Math.sin(r);
System.out.println("tagente="+ta+"n cotangente="+cot+"n secante="+sec+"n
cosecante="+cosec);
}
Prueba de Escritorio:
Aquí se muestra como el programa pide que se ingrese un valor y posteriormente se da a
conocer el valor de la tangente, cotangente, secante y cosecante.
Conclusión: Este programa nos ayuda a sacar la tangente, cotangente, secante y cosecante de
una manera más fácil y rápida.
Ponce Martínez Isaac
Página 45

46. Problema 19.
Descripción: Elaborar un algoritmo que permita leer el tamaño de un ángulo en grados e
imprima el seno y coseno. Debe convertirse los grados leídos a radianes antes de hacer los
cálculos.
Pseudocódigo: Inicio
Escribir “Introduce el número de ángulo en grados”
Leer g
Algoritmo
g=leer.nextInt();
r=(g*3.146/180);
cos=Math.cos(g);
sen=Math.sin(g);
Imprime cos
Imprime sen
Fin
Diagrama de Flujo:
Código Java:
public static void Diecinueve(){
Ponce Martínez Isaac
Página 46

47. Scanner leer=new Scanner(System.in);
double g,r,cos,sen;
System.out.println("Introduce el numero de angulo en grados");
g=leer.nextInt();
r=(g*3.146/180);
cos=Math.cos(g);
sen=Math.sin(g);
System.out.println("El valor del seno es: "+sen);
System.out.println("El valor del coseno es: "+cos);
}
Prueba de Escritorio:
Aquí se muestra como el programa pide el número de ángulo en radios, posteriormente este
los convierte a radianes y finalmente da a conocer el valor del seno y coseno.
Conclusión: Este programa nos ayuda a saber el seno y coseno.
Ponce Martínez Isaac
Página 47

48. Problema 20.
Descripción: Elaborar un algoritmo que permita leer los valores para A y B e imprima Y,Z y W.
Pseudocódigo: Inicio
Escribir "a: "
Leer a
Escribir "b: "
Leer b
Algoritmo
double num2=Double.parseDouble(a);
double y=(3*num*num*num2*num2)*(Math.sqrt(2*num));
double w=4*(Math.sqrt(Math.pow(2,
num))*num)*((3*num*num*num2*num2)-(Math.sqrt(2)));
double z=(12*(Math.sqrt(num)))/(Math.pow(num2, 0.75));
Imprime ""y= "+y+"n w= "+w+"n z="+z"
Fin
Diagrama de Flujo:
Código Java:
public static void Veinte(){
Ponce Martínez Isaac
Página 48

49. String a= JOptionPane.showInputDialog("a:");
double num=Double.parseDouble(a);
String b=JOptionPane.showInputDialog("b:");
double num2=Double.parseDouble(a);
double y=(3*num*num*num2*num2)*(Math.sqrt(2*num));
double w=4*(Math.sqrt(Math.pow(2, num))*num)*((3*num*num*num2*num2)(Math.sqrt(2)));
double z=(12*(Math.sqrt(num)))/(Math.pow(num2, 0.75));
JOptionPane.showMessageDialog(null, "y= "+y+"n w= "+w+"n z="+z);
}
Prueba de Escritorio:
Aquí se muestra como el programa pide que se le asigne un valor a la variable a.
Una vez asignado el valor a la variable a el programa pide que le asignen un valor a la variable
b.
Ponce Martínez Isaac
Página 49

50. Una vez asignado valor a las variables a y b el programa da los resultados de las variables
y,w,z.
Conclusión: Este programa nos permite conocer el valor de las variables y,w,z asignándole un
valor a las variables a,b.
Ponce Martínez Isaac
Página 50