Ejercicios Resueltos Clase Math

Ejercicio 1
Crear un código que muestre el nombre del alumno y el promedio de cuatro materias asignadas.
La forma de ingreso será: NOMBRE: NOTA1-NOTA2-NOTA3-NOTA4.
Este ejercicio tiene la finalidad de generar una primera aproximación a la algorítimica.

public class Problema1 {

String datos;
public Problema1(String datos){
this.datos=datos;
}
public void calcular(){
int auxiliar= datos.indexOf(":");
String nombre= datos.substring(0, auxiliar);

String nota1 = datos.substring(auxiliar+2, auxiliar+5);

String nota2= datos.substring(auxiliar+6, auxiliar+9);
String nota3= datos.substring(auxiliar+10, auxiliar+13);
String nota4= datos.substring(auxiliar+14, datos.length());

double not1= new Double(nota1).doubleValue();

double not2= new Double(nota2).doubleValue();
double not3= new Double(nota3).doubleValue();
double not4= new Double(nota4).doubleValue();
double promedio = (not1+not2+not3+not4)/4;
double aux = promedio - Math.round(promedio);

System.out.println("Bienvenido "+nombre+"\nSus notas este semestre fueron : "+nota1+",

"+nota2+", "+nota3+" y "+nota4+". \nSu promedio final fue: "+promedio);

}
public static void main(String args[]){
Problema1 a= new Problema1("CARLOS PEREZ: 7.0-3.5-4.5-5.7");
a.calcular();
}
}

Explicación del código:

Como se dice en el enunciado, vemos que es fácil identificar el nombre y las notas, ya que basta
tomar como referencia los dos puntos, considerando que un espacio después de los dos puntos
comienza la primera nota, y ésta llega hasta el primer guión. Desde este guión y hasta el otro,
encontramos el segundo nombre, y así sucesivamente.

Yéndonos a la parte de código, vemos que se creó un método llamado calcular(), el que tiene de
variable de entrada un String, el que es básicamente de la forma NOMBRE: NOTA1-NOTA2-
NOTA3-NOTA4. Luego, aplicamos lo que dijimos antes: creamos una variable auxiliar, que
almacena la ubicación de los dos puntos, dentro del String. A través de esta, generamos el
nombre, que sería desde el inicio hasta los dos puntos ( (0, auxiliar) ). Luego, lo que resta es
entender el método substring, que básicamente se utilizó para sacar cierta parte de nuestro
String, con la referencia de posiciones mencionada anteriormente.

Para la parte matemática, debemos pasar lo que ya teníamos a un Double, por lo que ocupamos
el método doubleValue. Luego, lo que nos queda es sacar el promedio e imprimirlo en pantalla.

Autor: KuroNeko (Rodolfo V.) [Fundamentos de la Informática Industrial]

Resultado en pantalla:

Ejercicio 2
Éste problema es el último en el que jugaremos un poco con números y cosas así, simples. Con
éste quiero mostrarles más que nada el manejo de variables, y cómo ocuparlas para obtener un
pequeño resultado. El código muestra, en una forma muy sencilla, cuántos años tienen los datos
ingresados, y los extiende a meses, días, etc.
public class Problema2 {
int añonacimiento;
int añoactual;
public void calculoExtendido(){
int ac = añoactual-añonacimiento;
int dia = ac*365;
int mes = ac*12;
int hora = dia*24;
int minuto = hora*60;
int segundo = minuto*60;

System.out.println("Haz vivido:\n"+ac+" años \n"+mes+" meses\n"+dia+" dias\n"+hora+"

horas\n"+minuto+" minutos\n"+segundo+" segundos");
}
public static void main(String args[])
{
Problema2 b= new Problema2();
b.añonacimiento=1990;
b.añoactual=2010;
b.calculoExtendido();

}
}

Explicación del código:

Comenzamos inicializando tanto la variable entera añonacimiento como añoactual. Luego,

creamos el método calculoExtendido(), en donde nosotros calcularemos lo pedido. Para ello,
primero vemos cuántos años han transcurrido desde nuestro nacimiento, a través de la resta
entre el año actual y nuestro año de nacimiento. Posterior a ello, multiplicamos por 365, para
sacar cuántos dias van, los dias por 12 para sacar los meses, y así sucesivamente. Finalmente
mostramos el resultado en pantalla, a través de la concatenación de los resultados.

Resultado en pantalla:

Autor: KuroNeko (Rodolfo V.) [Fundamentos de la Informática Industrial]

Ejercicio 3
En este problema aplicamos un poco la clase Math. Veremos acá que aún nos faltan muchas
herramientas para poder sacarle un provecho real.
En este problema he planteado un simple lanzamiento de dados, y que señale el dado ganador.
public class Problema3 {
public void tirarDados(){
System.out.println("Se presentan los participantes. A continuación, hará su
lanzamiento el jugador 1");
double aux1= (Math.random()*6)+0.5;
double aux2= (Math.random()*6)+0.5;
double intento1= Math.round(aux1);
double intento2= Math.round(aux2);
int jugador1= (int)intento1;
int jugador2= (int)intento2;

System.out.println("El jugador 1 ha sacado: "+jugador1+" y el jugador 2 ha sacado

"+jugador2);
int ganador = Math.max(jugador1, jugador2);
System.out.println("Quien sacó "+ganador+" es el ganador :D Felicitaciones");

}
public static void main(String args[]){
Problema3 c = new Problema3();
c.tirarDados();
}
}

Resultado en pantalla:

Ejercicio 4
Se propone la siguiente función:

Impleméntala en Java, y evalúe en X=0. Muestre el resultado en pantalla.

public class Problema4 {

double xo;
public void evaluacion1(double a){
this.xo=a;

double seno = Math.sin(Math.pow(xo,3)+(2/9)*xo);

double euler= Math.pow(Math.E,Math.pow(xo,3));
double tangente= Math.tan(euler);
double coseno = Math.cos(6*Math.PI+tangente);
double resultado = Math.sqrt(seno+coseno);

System.out.println("La función f(x)= [sen(x^3+2x/9)+cos(6PI+tan(e^x^3))]^1/2 evaluada

en "+xo+" es "+resultado);
}
Autor: KuroNeko (Rodolfo V.) [Fundamentos de la Informática Industrial]
public void evaluacion2(double a){
this.xo=a;
double resultadof =
Math.sqrt(Math.sin(Math.pow(xo,3)+(2/9)*xo)+Math.cos(6*Math.PI+Math.tan(Math.pow(Math.E
,Math.pow(xo,3)))));
System.out.println("La función f(x)= [sen(x^3+2x/9)+cos(6PI+tan(e^x^3))]^1/2 evaluada
en "+xo+" es "+resultadof);
}

public static void main(String args[]){

Problema4 d = new Problema4();
d.evaluacion1(0.0);
d.evaluacion2(0.0);
}
}

Resultado en pantalla:

Ejercicio 5
Éste ejercicio me lo envío Camilo Umaña (agradecimientos) y en el enunciado se pide que
programemos el determinante de una función cuadrática.

public class Ecuacion_Cuadratica {

double a;
double b;
double c;
double x1;
double x2;
double d;
public void asignacion(double a,double b, double c){
this.a=a;
this.b=b;
this.c=c;
}
public void Calculodiscriminante(){
d=(Math.pow(b, 2))-(4*a*c);
System.out.println("El discriminante es: "+d);
if(d>0){ System.out.println("Hay dos raíces reales distintas");
}else if(d==0){
System.out.println("Hay dos raíces reales iguales");
}else{
System.out.println("Hay dos raíces complejas y conjugadas");
}
}
public void Calculoraices(){ x1=((-B)+(Math.sqrt(d)))/(2*a);
x2=((-B)-(Math.sqrt(d)))/(2*a);
if(d>0){ System.out.println("Las raíces son: "+x1+" y "+x2);
}else if(d==0){
System.out.println("La raíz es: "+x1);
}
}
public static void main (String args[]){
Ecuacion_Cuadratica intento=new Ecuacion_Cuadratica();
intento.asignacion(1, -5, 6);

Autor: KuroNeko (Rodolfo V.) [Fundamentos de la Informática Industrial]

intento.Calculodiscriminante();
intento.Calculoraices(); } }

Explicación del código:

Creo que este ejercicio ya debiera ser de fácil entendimiento, por lo que sólo quiero explicarles
que acá se separó la resolución en tres métodos, en donde el primero realiza la asignación de
variables, el segundo evalúa las características de las raíces (reales, complejas, etc.) y el tercero
netamente las calcula. Para hacer el segundo método, basta hacer un if e ingresar los intervalos
en que se puede mover "d".

Para el cálculo de raíces, es el típico:

Resultado en pantalla:

Autor: KuroNeko (Rodolfo V.) [Fundamentos de la Informática Industrial]