Formulas Matemáticas
Teorema de Pitagoras
Una de las aplicaciones mas inmediatas que tiene la programación es el uso de las formulas para realizar conversiones de magnitudes, hallar áreas o volúmenes de diferentes figuras geométricas, calcular algunas medidas físicas, cambio de moneda, etc.
Como ya conocemos los conceptos de variables, operadores y sabemos como mostrar datos en pantalla, recoger datos del teclado entre otras cosas, ya estamos listos para crear una aplicación un poco mas práctica.
Ejercicio:
Teorema de Pitágoras.
Se le pide al usuario que introduzca los catetos de un triangulo rectángulo y mediante la formula correspondiente el programa hallará la hipotenusa.
Tendremos que partir de la formula despejada y tener en cuenta el orden (prioridad) de las operaciones matemáticas, recordemos que se realizan primero las potencias de los catetos, luego se suman los resultados y a ello se le halla la raiz cuadrada
En Java
Como siempre arrancamos importando el método Scanner
import java.util.Scanner;
Declararemos dos variables tipo int donde recojer los datos de los catetos desde el teclado
int c1, c2;
Creamos el objeto para leer los datos del teclado
Scanner dato = new Scanner(System.in);
Le indicamos al usuario que debe ingresar los datos de los catetos
System.out.println(“Ingrese el primer cateto”);
Quedamos a la espera de dicho ingreso
c1 = dato.nextInt();
Para poder realizar con eficacia la oeración debemos hacer uso de la clase “Math” que ya está incluida en java y por lo tanto no será necesario importarla.
Para encontrar las potencias (elevar al cuadrado) podemos simplemente multiplicar por si mismo el número, pero vamos a aprovechar que la clase Math trae un método llamado “pow” para realizar esta operación.
Math.pow(base, potencia);
Para nuestro caso será:
Math.pow(c1, 2);
Este método devuelve como resultado un valor tipo double.
Asi mismo para hallar la raiz cuadrado usaremos el método “sqrt” que trae la clase “Math”
Math.sqrt(número);
Este método devuelve un valor tipo double, entonces debemos declarar una variable de este tipo si queremos almacenar este resultado.
double hipo;
Realizamos la operación completa y almacenamos en la varilable hipo
hipo = Math.sqrt(Math.pow(c1, 2)+Math.pow(c2, 2));
Mostramos en pantalla el resultado
System.out.println(“Hipotenusa = “+hipo);
El código quedará:
package pitagoras;
import java.util.Scanner;
public class Pitagoras {
public static void main(String[] args) {
int c1, c2;
double hipo;
Scanner dato = new Scanner(System.in);
System.out.println(“Ingrese el primer cateto”);
c1 = dato.nextInt();
System.out.println(“Ingrese el segundo cateto”);
c2 = dato.nextInt();
hipo = Math.sqrt(Math.pow(c1, 2)+Math.pow(c2, 2));
System.out.println(“Hipotenusa = “+hipo);
}
}
En Python
Debemos capturar dos datos del teclado, convertirlos a número (puede ser int) y almacenarlos en una variable, para eso podemos usar “input” y nos permite mostrar un mensaje:
ca=int(input(“ingrese primer cateto\t”))
Repetimos el proceso para el otrocateto
cb=int(input(“ingrese segundo cateto\t”))
Para elevar un número a una potencia usamos el operador ‘ ** ‘ seguido de la potencia a la cual queremos elevar, por ejemplo:
ca**2
Elevará el contenido de ‘ca’ al cuadrado
Para hallar raices en python se puede usar el mismo operador ‘ ** ‘ pero como las raices son potencias fraccionarias (por ejemplo raiz cuadrada es igual a elevar a la 1/2) podemos usar ese número ya sea como fraccionario (1/2) o como decimal (0.5)
raiz_cuadrada = numero**(1/2)
raiz_cuadrada = numero**0.5
Entonces para realizar la operación y almacenarla en la variable “hipo” escribiremos
hipo = (ca**2 + cb**2)**.5
Luego mostraremos el resultado:
print(“Hipotenusa = “,hipo)
El código quedará:
ca=int(input(“ingrese primer cateto\t”))
cb=int(input(“ingrese segundo cateto\t”))
hipo = (ca**2 + cb**2)**.5
print(“Hipotenusa = “,hipo)
Recordemos que para ejecutar este código debemos guardarlo con extensión .py y luego ejecutarlo desde consola con
python pitagoras.py
En C++
Debemos declarar dos variables que pueden ser de tipo int para almacenar el valor de los catetos
int ca,cb;
También necesitamos otra variable para almacenar el resultado de la operación, es necesaria una variable tipo float
float hipo;
Pediremos al usuario que ingrese cada cateto:
cout<<“Ingresa primer cateto\t”;
Lo capturamos desde el teclado
cin>>ca;
Para operaciones como raices cuadradas o potenciación e necesario incluir una libreria llamada “math.h”
#include <math.h>
Para elevar al cuadrado usaremos la función pow(base, potencia) donde base es el número que queremos elevar a dicha potencia y que se encuentra en la libreria math. En nuestro caso será
pow(ca,2)
Para hallar raiz cuadrada, usaremos la función sqrt(numero) que también se encuentra en la libreria math. La operación completa será:
hipo =sqrt(pow(ca,2)+pow(cb,2));
Solo nos queda mostrar en pantalla:
cout<<“Hipotenusa = “<<hipo;
#include <iostream>
#include <math.h>
using namespace std;
int main(){
int ca,cb;
float hipo;
cout<<“Ingresa primer cateto\t”;
cin>>ca;
cout<<“Ingresa segundo cateto\t”;
cin>>cb;
hipo =sqrt(pow(ca,2)+pow(cb,2));
cout<<“Hipotenusa = “<<hipo;
}
En Ruby
Primero solicitamos al usuario que ingrese los datos de cada cateto
puts “Ingrese primer cateto”
puts “Ingrese segundo cateto”
Luego capturamos dato del teclado, convertimos a entero (int) y almacenamos en variables correspondientes
ca = gets.to_i
cb = gets.to_i
Para elevar a una potencia usamos el operador **, es decir numero**2 elevara la variable numero al cuadrado, en nuestro caso:
ca**2 y cb**2
Hallar raices cuadradas puede realizarse con el mismo operador teniendo en cuenta que la potencia será un número fraccionario; numero**(1/2) o numero**0.5 calculara la raiz cuadrada de la variable numero. En nuestro caso debemos hallar la raiz cuadrada de una suma (ca^2+cb^2) entonces toda la operación quedará:
hipo = (ca**2 + cb**2)**0.5
El resultado quedará almacenado en la variable “hipo” y solo tenemos que mostrar el resultado:
puts “Hipotenusa = #{hipo}”
El Código será:
puts “Ingrese el primer cateto”
ca = gets.to_i
puts “Ingrese el segundo cateto”
cb = gets.to_i
hipo = (ca**2 + cb**2)**0.5
puts “Hipotenusa = #{hipo}”
En C#
Declaramos dos variables tipo int para recibir los datos del teclado
int ca, cb;
Declaramos una variable tipo double para almacenar el resultado de la operación
double hipo;
Solicitamos al usuario que ingrese datos de los catetos
Console.WriteLine(“Ingrese el primer cateto”);
Console.WriteLine(“Ingrese el primer cateto”);
Capturamos el dato, lo convertimos en entero y lo guardamos en una variable
ca = int.Parse(Console.ReadLine());
cb = int.Parse(Console.ReadLine());
Para elevar al cuadrado cada cateto usaremos el método Pow(base, potencia) de la Clase Math y luego sumamos las dos potencias
Math.Pow(ca, 2) + Math.Pow(cb, 2)
La misma clase Math tiene un método para hallar raiz cuadrada que se llama sqrt() que devuelbe un dato tipos double
Math.Sqrt(Math.Pow(ca, 2) + Math.Pow(cb, 2))
Almacenamos este resultado en la variable “hipo” que es tipo double
hipo = Math.Sqrt(Math.Pow(ca, 2) + Math.Pow(cb, 2));
Mostramos el resultado en pantalla
Console.WriteLine(“Hipotenusa = “+hipo);
El Código será:
using System;
namespace PitagorasCs
{
class Program
{
static void Main(string[] args)
{
int ca, cb;
double hipo;
Console.WriteLine(“Ingrese el primer cateto”);
ca = int.Parse(Console.ReadLine());
Console.WriteLine(“Ingrese el segundo cateto”);
cb = int.Parse(Console.ReadLine());
hipo = Math.Sqrt(Math.Pow(ca, 2) + Math.Pow(cb, 2));
Console.WriteLine(“Hipotenusa = “+hipo);
}
}
}
