Determinar el biotipo de una persona en Python

Continuando con esta serie sobe el cálculo de biotipos en C y Java ahora veremos cómo se hace en Python.

Siguiendo la misma lógica de la entrega anterior tenemos:

biotipo.py

peso_dict = {
    "85.54": 3.0, "83.79": 2.75, "82.04": 2.5, "80.29": 2.25,
    "78.54": 2.0, "76.79": 1.75, "75.04": 1.5, "73.29": 1.25,
    "71.54": 1.0, "69.79": 0.75, "68.04": 0.50, "66.29": 0.25,
    "64.54": 0.0, "62.79": -0.25, "61.04": -0.50, "59.29": -0.75,
    "57.54": -1.0, "55.79": -1.25, "54.04": -1.50, "52.29": -1.75,
    "50.54": -2.0, "45.79": -2.25, "47.04": -2.5, "45.29": -2.75,
    "43.54": -3.0
}

estatura_dict = {
    "1.87": 3.0, "1.86": 2.75, "1.85": 2.50, "1.83": 2.23,
    "1.82": 2.0, "1.81": 1.75, "1.79": 1.50, "1.78": 2.25,
    "1.77": 1.0, "1.75": 0.75, "1.74": 0.50, "1.73": 0.25,
    "1.71": 0.0, "1.7": -0.25, "1.69": -0.50, "1.67": -0.75,
    "1.66": -1.0, "1.65": -1.25, "1.63": -1.50, "1.62": -1.75,
    "1.61": -2.0, "1.59": -2.25, "1.58": -2.50, "1.57": -2.75,
    "1.55": -3.0
}

def obtener_valor(diccionario, clave):
    return diccionario.get(clave, -999.0)

def main():
    peso = input("Tu peso es de (ejemplo: 56.00): ").strip()
    estatura = input("Tu estatura es de (ejemplo: 1.55): ").strip()

    valor_peso = obtener_valor(peso_dict, peso)
    valor_estatura = obtener_valor(estatura_dict, estatura)

    #print(f"valor peso: {valor_peso:.1f}")
    #print(f"valor estatura: {valor_estatura:.1f}")
    
    if valor_peso == -999.0 or valor_estatura == -999.0:
        print("Error: Peso o estatura no válidos. Asegúrate de ingresar valores dentro del rango permitido.")
        return

    desviacion = valor_peso - valor_estatura

    if desviacion < 0:
        print("Tu biotipo es: longitipo. Largo. Delgado. De apariencia frágil.")
    elif desviacion > 0:
        print("Tu biotipo es: braquitipo. Sobrepeso. Acumula grasas. Puede ganar musculatura si realiza ejercicio.")
    else:
        print("Tu biotipo es: normotipo. Fuerte. Atlético. Musculoso.")

if __name__ == "__main__":
    main()

Ejecutando:

Tu peso es de (ejemplo: 56.00): 75.04
Tu estatura es de (ejemplo: 1.55): 1.66
Tu biotipo es: braquitipo. Sobrepeso. Acumula grasas. Puede ganar musculatura si realiza ejercicio.

Como hemos mencionado, el código qrequiere ciertos ajustes para abarcar más pesos y tallas.

Enlaces:

https://ucsc.cl/medios-ucsc/blogs-academicos/biotipo-y-el-factor-mental/

Determinar el biotipo de una persona en C

En una pasada entrega vimos cómo calcular el biotipo de una persona en Java. Ahora lo haremos usando el lenguaje de programación C.

Pero, ¿Qué es el biotipo de una persona?

Es la forma característica de un animal o planta. Es el aspecto general de un sujeto de acuerdo a sus características somáticas o morfológicas y se basa en los datos que refleja su estructura corporal, en todo lo que se ve y se puede medir de su cuerpo.

Se refiere a las características corporales, como la estructura ósea, la musculatura y la predisposición al metabolismo, que influyen en la salud, el rendimiento físico y la respuesta a la dieta o ejercicio.

Establece que hay una relación entre las características físicas y la personalidad. Esto ya lo habiamos mencionado en la entrega pasada.

Para el programa en C:

1. Crearemos un archivo de encabezado: biotipo.h 
2. Un archivo donde tendremos las funciones necesarias para los cálculos: biotipo.c 
3. Un programa main: main.c

Existen varios biotipos, pero el general comprende estos tres:

• Ectomorfo: Cuerpo delgado, extremidades largas, dificultad para ganar peso o masa muscular, metabolismo rápido. En otras palabras, sería Longitipo
•  Mesomorfo: Cuerpo atlético, facilidad para ganar músculo, estructura ósea equilibrada, metabolismo eficiente. En otras palabras, sería Normotipo.
•  Endomorfo: Cuerpo con mayor tendencia a acumular grasa, estructura más ancha, metabolismo más lento. En otras palabras, sería Braquitipo.

El programa comprenderá dos "hashmap", hechos con estructuras. Uno para los pesos y el otro para las estaturas.

biotipos.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Estructura para simular el HashMap (clave-valor)
typedef struct {
    char *clave;
    double valor;
} ParClaveValor;

// Listas de pares clave-valor para peso y estatura
ParClaveValor mapaPeso[] = {
    {"85.54", 3.0}, {"83.79", 2.75}, {"82.04", 2.5}, {"80.29", 2.25},
    {"78.54", 2.0}, {"76.79", 1.75}, {"75.04", 1.5}, {"73.29", 1.25},
    {"71.54", 1.0}, {"69.79", 0.75}, {"68.04", 0.50}, {"66.29", 0.25},
    {"64.54", 0.0}, {"62.79", -0.25}, {"61.04", -0.50}, {"59.29", -0.75},
    {"57.54", -1.0}, {"55.79", -1.25}, {"54.04", -1.50}, {"52.29", -1.75},
    {"50.54", -2.0}, {"45.79", -2.25}, {"47.04", -2.5}, {"45.29", -2.75},
    {"43.54", -3.0}
};

ParClaveValor mapaEstatura[] = {
    {"1.87", 3.0}, {"1.86", 2.75}, {"1.85", 2.50}, {"1.83", 2.23},
    {"1.82", 2.0}, {"1.81", 1.75}, {"1.79", 1.50}, {"1.78", 2.25},
    {"1.77", 1.0}, {"1.75", 0.75}, {"1.74", 0.50}, {"1.73", 0.25},
    {"1.71", 0.0}, {"1.7", -0.25}, {"1.69", -0.50}, {"1.67", -0.75},
    {"1.66", -1.0}, {"1.65", -1.25}, {"1.63", -1.50}, {"1.62", -1.75},
    {"1.61", -2.0}, {"1.59", -2.25}, {"1.58", -2.50}, {"1.57", -2.75},
    {"1.55", -3.0}
};

// Tamaños de los mapas
const int TAMANO_PESO = sizeof(mapaPeso) / sizeof(mapaPeso[0]);
const int TAMANO_ESTATURA = sizeof(mapaEstatura) / sizeof(mapaEstatura[0]);

// Función para buscar el valor asociado a una clave en el mapa
double buscarValor(ParClaveValor mapa[], int tamano, const char *clave) {
    for (int i = 0; i < tamano; i++) {
        if (strcmp(mapa[i].clave, clave) == 0) {
            return mapa[i].valor;
        }
    }
    return -999.0; // Valor por defecto si no se encuentra la clave
}

// Función para obtener el peso (equivalente a getPeso en Java)
double obtenerPeso(const char *peso) {
    return buscarValor(mapaPeso, TAMANO_PESO, peso);
}

// Función para obtener la estatura (equivalente a getTalla en Java)
double obtenerEstatura(const char *estatura) {
    return buscarValor(mapaEstatura, TAMANO_ESTATURA, estatura);
}

int main() {
    char peso[10], estatura[10];
    double valorPeso, valorEstatura, desviacion;

    // Solicitar entrada al usuario
    printf("Tu peso es de (ejemplo: 56.00): ");
    fgets(peso, sizeof(peso), stdin);
    peso[strcspn(peso, "\n")] = 0; // Eliminar el salto de línea

    printf("Tu estatura es de (ejemplo: 1.55): ");
    fgets(estatura, sizeof(estatura), stdin);
    estatura[strcspn(estatura, "\n")] = 0; // Eliminar el salto de línea

    // Obtener los valores asociados a peso y estatura
    valorPeso = obtenerPeso(peso);
    valorEstatura = obtenerEstatura(estatura);

    printf("valor peso: %.1f\n", valorPeso);
    printf("valor estatura: %.1f\n", valorEstatura);
    // Verificar si se encontraron los valores
    if (valorPeso == -999.0 || valorEstatura == -999.0) {
        printf("Error: Peso o estatura no válidos. Asegúrate de ingresar valores dentro del rango permitido.\n");
        return 1;
    }

    // Calcular la desviación
    desviacion = valorPeso - valorEstatura;

    // Determinar el biotipo y mostrar el resultado
    if (desviacion < 0) {
        printf("Tu biotipo es: longitipo. Largo. Delgado. De apariencia frágil. \n");
    } else if (desviacion > 0) {
        printf("Tu biotipo es: braquitipo. Sobrepeso. Acumula grasas. Puede ganar musculatura si realiza ejercicio.\n");
    } else {
        printf("Tu biotipo es: normotipo. Fuerte. Atlético. Musculoso\n");
    }

    return 0;
}

Compilación y ejecución:

$ gcc -o biotipos.exe biotipos.c
$ ./biotipos.exe

Salida:

Tu peso es de (ejemplo: 56.00): 43.54
Tu estatura es de (ejemplo: 1.55): 1.61
valor peso: -3.0
valor estatura: -2.0
Tu biotipo es: longitipo. Largo. Delgado. De apariencia frágil.

El programa requiere ciertos ajustes para permitir otras entradas de estatura y peso.

Enlaces:

https://codemonkeyjunior.blogspot.com/2013/03/determinar-el-biotipo-de-una-persona-en.html

Un programa en varios lenguajes de programación (2da parte)

En una entrega anterior vimos como resolver un ejercicio de programación (determina si una cadena de caracteres tiene una longitud distinta de 0) usando diversos lenguajes de programación.

Para probar estos ejemplos puedes ir a este sitio:

https://codapi.org/

En está ocasión resolveremos el siguiente problema:

Si enumeramos todos los números naturales menores de 10 que sean múltiplos de 3 o 5, obtenemos 3, 5, 6 y 9. La suma de estos múltiplos es 23. Halla la suma de todos los múltiplos de 3 o 5 menores de 1000.

Un ejercicio propuesto en la página de Project Euler: https://projecteuler.net/

En Dlang:

multipos3o5.d

void main()
{
    import std.stdio : writefln;
    const MAX = 1000;
    int counter = 1;
    int suma = 0;
    while(counter < MAX){
        if(counter%3==0 || counter%5==0){
           suma+=counter;
           writefln("Suma = %d, Counter: %d",suma,counter);
        }
        ++counter;
    }
    writefln("Suma final= %d",suma);
}

En C:

multiplos3o5.c

#include <stdio.h>
const int MAX = 1000;

int main() {
    int counter = 1;
	int suma = 0;
    
	 while(counter < MAX){
        if(counter%3==0 || counter%5==0){
           suma+=counter;
           printf("Suma = %d, Counter: %d\n",suma,counter);
        }
        ++counter;
    }
	printf("Suma final = %d\n",suma);
    return 0;
}

En Python:

multiplos3o5.py

MAX = 1000;
counter = 1
suma = 0
while counter < MAX:
    if counter%3== 0 or counter%5==0:
        print(f"Suma: {suma}, Counter: {counter}")
        suma = suma + counter
    counter = counter + 1   
print(f"Suma final: {suma}")

En Java:

Multiplos3o5.java

package com.test.main;

public class Main {
    public static final int MAX = 1000;
    public static void main(String[] args) {
        int counter = 1;
        int suma = 0;
        while(counter < MAX){
            if(counter%3==0 ||counter%5==0){
                suma+=counter;
                System.out.printf("Suma: %d, Counter: %d\n",counter,suma);
            }
            ++counter;
        }
        System.out.printf("Suma final: %d\n",suma);
    }
}

En Javascript:

multiplos3o5.js

const MAX = 1000;
let counter = 1;
let suma = 0;
    
	while(counter < MAX){
        if(counter%3==0 || counter%5==0){
           suma+=counter;
           console.log(`Suma = ${suma}, Counter: ${counter}`);
        }
        ++counter;
    }
	console.log(`Suma final = ${suma}`);

En Clojure:

multiplos3o5.clj

(def MAX 1000)

(defn calcular-suma []
  (loop [counter 1 suma 0]
    (if (< counter MAX)
      (if (or (zero? (mod counter 3)) (zero? (mod counter 5)))
        (do
          (println "Suma:" suma ", Counter:" counter)
          (recur (inc counter) (+ suma counter)))
        (recur (inc counter) suma))
      (do
        (println "Suma final:" suma)
        suma))))

(calcular-suma)

Clojure es un lenguaje muy distinto a la mayoría. Como emplea la misma sintaxis de LISP, el cual es un lenguaje orientado a expresiones.

En Ada Language Programming:

multiplos3o5.adb

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

procedure Suma_Multiplos is
   MAX     : constant Integer := 1000;
   Counter : Integer := 1;
   Suma    : Integer := 0;
begin
   while Counter < MAX loop
      if (Counter mod 3 = 0) or (Counter mod 5 = 0) then
         Put_Line("Suma: " & Integer'Image(Suma) & ", Counter: " & Integer'Image(Counter));
         Suma := Suma + Counter;
      end if;
      Counter := Counter + 1;
   end loop;

   Put_Line("Suma final: " & Integer'Image(Suma));
end Suma_Multiplos;

En Rust:

multiplos3o5.rs

fn main() {
    const MAX: i32 = 1000;
    let mut counter = 1;
    let mut suma = 0;

    while counter < MAX {
        if counter % 3 == 0 || counter % 5 == 0 {
            suma += counter;
            println!("Suma = {}, Counter: {}", suma, counter);
        }
        counter += 1;
    }

    println!("Suma final = {}", suma);
}

En Odin:

multiplos3o5.odin

package main

import "core:fmt"

MAX :: 1000;

main :: proc() {
    counter: int = 1;
    suma: int = 0;

    for counter < MAX {
        if counter % 3 == 0 || counter % 5 == 0 {
            suma += counter;
            fmt.printf("Suma = %d, Counter: %d\n", suma, counter);
        }
        counter += 1;
    }

    fmt.printf("Suma final = %d\n", suma);
}

En Go:

multiplos3o5.go

package main

import "fmt"

func main() {
    const MAX = 1000
    counter := 1
    suma := 0

    for counter < MAX {
        if counter%3 == 0 || counter%5 == 0 {
            suma += counter
            fmt.Printf("Suma = %d, Counter = %d\n", suma, counter)
        }
        counter++
    }

    fmt.Printf("Suma final = %d\n", suma)
}

Continuaremos ampliando la lista de ejemplos.

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/02/un-programa-en-varios-lenguajes.html
https://projecteuler.net/

Lenguaje de programación D: katas

Dlang o D es un lenguaje de programación similar al clásico C. Mucha de su sintaxis nos recordará a dicho lenguaje. En esta entrega haremos varios ejercicios con funciones. Para instalar este lenguaje ve a este sitio:

https://dlang.org/

Si solo quieres probar el lenguaje, ve este sitio:

https://run.dlang.io/

Para compilar y ejecutar un programa en Dlang(D):

dmd programa.d

Ejercicios en Dlang

Ejercicio 1. Crear funciones para sumar, restar, multiplicar y dividir dos números enteros.

basicas.d

import std.stdio;

int sumar(int x, int y)
{
    return x + y;
}

int restar(int x, int y)
{
    return x - y;
}

int multiplicar(int x, int y)
{
    return x * y;
}

int dividir(int x, int y)
{
    if (y == 0)
    {
        return x;
    }
    return x / y;
}

void main(string[] args)
{
    int x = 45;
    int y = 21;

    int suma = sumar(x, y);
    int resta = restar(x, y);
    int producto = multiplicar(x, y);
    int division = dividir(x, y);
    writeln("\t === Operaciones aritméticas básicas ===");
    writef("La suma de %d y %d es: %d\n", x, y, suma);
    writef("La resta de %d y %d es: %d\n", x, y, resta);
    writef("La multiplicación de %d y %d es: %d\n", x, y, producto);
    writef("La división de %d y %d es: %d\n", x, y, division);
}

D nos permite crear funciones "tipo flecha", por lo que podemos editar el código y quedaría de la siguiente manera:

import std.stdio;

int sumar(int x, int y)=> x+y;

int restar(int x, int y)=>x-y;

int multiplicar(int x, int y)=>x*y;

int dividir(int x, int y)=>y==0?0:x/y;

void main(string[] args)
{
    int x = 45;
    int y = 21;

    int suma = sumar(x, y);
    int resta = restar(x, y);
    int producto = multiplicar(x, y);
    int division = dividir(x, y);
    writeln("\t === Operaciones aritméticas básicas ===");
    writef("La suma de %d y %d es: %d\n", x, y, suma);
    writef("La resta de %d y %d es: %d\n", x, y, resta);
    writef("La multiplicación de %d y %d es: %d\n", x, y, producto);
    writef("La división de %d y %d es: %d\n", x, y, division);
}

Ejercicio 2. Programa que calcule el factorial de un número entero.

factorial.d

import std.stdio;

int factorial(int num)
{
    if (num == 0)
    {
        return 1;
    }
    return num * factorial(num - 1);
}

void main(string[] args)
{
    int numero = 6;
    writeln("\t === Factorial de un número ===");
    writef("El factorial de %d es: %d\n", numero, factorial(numero));
}

El clásico programa del Factorial de un número en Dlang.

Ejercicio 3. Crear un programa que divida un número entre 2. Si el resultado del residuo de esa división es 0, el programa terminará. En otro caso el programa se ciclará.

ciclar.d

import std.stdio;

void mientras(int num)
{
    const int MAX = 100;
    while(num  < MAX ){
        writef("Número : %d\n", num);
        if(num%2==0){
            break;
        }else{
           continue;
        }
        ++num;
    }
}

void main(string[] args)
{
    int numero = 8;
    mientras(numero);
}

La entrada es 8. Si se divide entre 2 dará un residuo de 0 y entonces el programa terminará. Si fuese un número cuya división diera un residuo distinto de 0, entonces el programa se ciclará (un ciclo infinito). Será necesario matar el proceso.

Nota: El operador continue es una instrucción que se utiliza en programación para omitir la iteración actual de un bucle y pasar a la siguiente. En este caso, provocará que se muestre constanteente la entrada que no termina el ciclo, creando un ciclo infinito. Este ejercicio solo es didáctico y no tiene otro propósito.

Ejercicio 4. Este es un ejercicio propuesto en la página de Project Euler:

Si enumeramos todos los números naturales menores de 10 que sean múltiplos de 3 o 5, obtenemos 3, 5, 6 y 9. La suma de estos múltiplos es 23. Halla la suma de todos los múltiplos de 3 o 5 menores de 1000.

multiplos3o5.d

void main()
{
    import std.stdio : writefln;
    const MAX = 1000;
    int counter = 1;
    int suma = 0;
    while(counter < MAX){
        if(counter%3==0 || counter%5==0){
           suma+=counter;
           writefln("Suma = %d, Counter: %d",suma,counter);
        }
        ++counter;
    }
    writefln("Suma final= %d",suma);
}

Como detalles:

// Se puede crear una constante de esta forma:
const int MAX = 1000;

// Y de esta:
const MAX = 1000;

Además podemos hacer importaciones desde el cuerpo del método principal del programa (main).

Ejercicio 5. Crear una clase llamada Punto con propiedades x, y de tipo ``int``. Agregaremos una clase hija denominada PuntoColor, con un campo color de tipo ``string``.

clases.d

 import std.stdio : writeln;

void main()
{    
    Punto myPunto = new Punto(3,4);
    writeln("x:", myPunto.x);
    writeln("y:", myPunto.y);
    PuntoColor myPuntoColor = new PuntoColor("Rojo");
    writeln("color:", myPuntoColor.color);
}

class Punto{
   public int x;
   public int y;
    
   
    this(int x, int y) {
        writeln("Se ha creado una instancia de la clase Punto");
        this.x = x;
        this.x = x;
    }
}

class PuntoColor: Punto{
   public string color;
    this(string color){
      super(0,0);
      writeln("Se ha creado una instancia de la clase PuntoColor");
      this.color = color;
    }
}

Dlang es un lenguaje de programación que ha aprendido de los errores y aciertos de otros lenguajes como C, Java y C++, entre otros más.

Hasta otra entrega más.

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/06/el-lenguaje-de-programacion-d.html
https://projecteuler.net/