UNIVERSIDAD CENTRAL DE ECUADOR

FACULTAD DE CIENCIAS ECONÓMICAS

CARRERA DE ESTADÍSTICA

PROGRAMA 1:TEOREMA DE PITAGORAS

Escribe un programa que solicite los catetos de un triángulo rectángulo y muestre su hipotenusa.

Este ejercicio nos plantea realizar el Teorema de Pitágoras, el cual establece que en un triángulo rectángulo:

\[ c^2 = a^2 + b^2 \]

donde: - c es la hipotenusa (el lado opuesto al ángulo recto), - a y b son los catetos.

Desarrollo del código

1. Ingreso de datos por el usuario Solicitamos al usuario que ingrese los dos catetos:

# INGRESA VALOR DEL CATETO
cateto1 <- as.numeric(readline("Ingrese el primer cateto: "))
cateto2 <- as.numeric(readline("Ingrese el segundo cateto: "))
  • readline() permite capturar lo que el usuario escribe.
  • as.numeric() convierte la entrada a número (porque readline() devuelve texto).

Para propósitos de demostración, vamos a usar valores fijos:

# Asignar valores para demostración
cateto1 <- 5
cateto2 <- 6

2. Cálculo de la hipotenusa Aplicamos directamente el Teorema de Pitágoras:

# CALCULA LA HIPOTENUSA USANDO EL TEOREMA DE PITAGORAS
hipotenusa <- sqrt(cateto1^2 + cateto2^2)
  • Elevamos al cuadrado ambos catetos y sumamos.
  • sqrt() calcula la raíz cuadrada del resultado.

3. Mostrar el resultado Finalmente, mostramos el valor de la hipotenusa:

# MUESTRA DEL RESULTADO
cat("La hipotenusa es:", hipotenusa)
## La hipotenusa es: 7.81025
  • cat() imprime texto junto con valores.

Conclusión Este ejercicio nos permite aplicar de forma práctica el Teorema de Pitágoras en el lenguaje R, integrando interacción con el usuario y operaciones matemáticas básicas. Usamos funciones como readline(), as.numeric(), y sqrt() que son fundamentales para el manejo de datos y cálculos en programas simples.

PROGRAMA 2: ECUACIÓN CUADRÁTICA

Escribe un programa que resuelva una ecuación de segundo grado usando la fórmula general.

Este ejercicio nos plantea resolver una ecuación cuadrática de la forma ax² + bx + c = 0 mediante la fórmula general:

\[ x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a} \]

donde: - a, b y c son los coeficientes de la ecuación. - El discriminante (b² - 4ac) determina el tipo de soluciones.

Desarrollo del código

1. Ingreso de coeficientes por el usuario

# INGRESAR LOS VALORES NUMÉRICOS A CALCULAR 
a <- as.numeric(readline("Ingrese el valor de a: "))
b <- as.numeric(readline("Ingrese el valor de b: "))
c <- as.numeric(readline("Ingrese el valor de c: "))
  • Usamos readline() para solicitar cada coeficiente.
  • as.numeric() convierte las entradas de texto a valores numéricos.

Para propósitos de demostración, vamos a usar valores fijos:

# Asignar valores para demostración
a <- 1
b <- -5
c <- 6

2. Cálculo del discriminante

# CALCULA Y MUESTRA DEL DISCRIMINANTE 
discriminante <- b^2 - 4*a*c
cat("El discriminante es:", discriminante, "\n")
## El discriminante es: 1
  • El discriminante (b² - 4ac) nos indica qué tipo de soluciones tendrá la ecuación.

3. Determinación del tipo de soluciones y cálculo

# VERIFICAR EL TIPO DE SOLUCIONES
if (discriminante > 0) {
  x1 <- (-b + sqrt(discriminante)) / (2*a)
  x2 <- (-b - sqrt(discriminante)) / (2*a)
  cat("La ecuación tiene dos soluciones reales distintas:\n")
  cat("x1 =", x1, "\n")
  cat("x2 =", x2, "\n")
} else if (discriminante == 0) {
  x1 <- -b / (2*a)
  cat("La ecuación tiene una solución real doble:\n")
  cat("x1 = x2 =", x1, "\n")
} else {
  parte_real <- -b / (2*a)
  parte_imaginaria <- sqrt(abs(discriminante)) / (2*a)
  cat("La ecuación tiene soluciones complejas:\n")
  cat("x1 =", parte_real, "+", parte_imaginaria, "i\n")
  cat("x2 =", parte_real, "-", parte_imaginaria, "i\n")
}
## La ecuación tiene dos soluciones reales distintas:
## x1 = 3 
## x2 = 2
  • Si el discriminante es positivo: la ecuación tiene dos soluciones reales distintas.
  • Si el discriminante es cero: la ecuación tiene una solución real repetida.
  • Si el discriminante es negativo: la ecuación tiene dos soluciones complejas conjugadas.

Conclusión Este ejercicio aplica conceptos matemáticos fundamentales para resolver ecuaciones cuadráticas. El programa identifica automáticamente el tipo de soluciones (reales distintas, real doble, o complejas) basándose en el valor del discriminante, y presenta los resultados de manera clara y organizada.

PROGRAMA 3: ÁREA DE UN TRIÁNGULO RECTÁNGULO

Calcular el área de un triángulo rectángulo.

Para este ejercicio aplicaremos la fórmula del área de un triángulo rectángulo:

\[ \text{Área} = \frac{\text{base} \times \text{altura}}{2} \]

Desarrollo del código

1. Definición de los datos del triángulo

# DATOS DEL TRIANGULO
base <- 5
altura <- 8
  • Se establecen valores fijos para la base y la altura del triángulo rectángulo.

2. Cálculo del área

# CALCULO DEL AREA DE UN TRIANGULO RECTANGULO
area_triangulo <- (base * altura) / 2
  • Se aplica la fórmula multiplicando base por altura y dividiendo entre 2.

3. Presentación del resultado

# MUESTRA DEL RESULTADO
cat("El área del triángulo rectángulo es:", area_triangulo, "\n")
## El área del triángulo rectángulo es: 20
  • Se muestra el resultado utilizando la función cat().

Conclusión Este ejercicio aplica una fórmula geométrica básica para calcular el área de un triángulo rectángulo. A diferencia del ejercicio anterior, aquí los valores no se solicitan al usuario sino que se definen directamente en el código, lo que simplifica el programa pero reduce su flexibilidad.

PROGRAMA 4: ÁREA Y PERÍMETRO DE UN RECTÁNGULO

Calcular el área y perímetro de un rectángulo dado su base y altura.

Para este ejercicio aplicaremos las fórmulas:

\[ \text{Área} = \text{base} \times \text{altura} \]

\[ \text{Perímetro} = 2 \times (\text{base} + \text{altura}) \]

Desarrollo del código

1. Definición de los datos del rectángulo

# DATOS DEL RECTANGULO
base <- 6
altura <- 4
  • Se establecen valores fijos para la base y la altura del rectángulo.

2. Cálculo del área y perímetro

#CÁLCULO DEL ÁREA Y PERÍMETRO DE UN RECTANGULO 
area_rectangulo <- base * altura
perimetro_rectangulo <- 2 * (base + altura)
  • Para el área: multiplicamos base por altura.
  • Para el perímetro: sumamos base y altura, luego multiplicamos por 2.

3. Presentación de los resultados

# MUESTRA DEL RESULTADO
cat("El área del rectángulo es:", area_rectangulo, "\n")
## El área del rectángulo es: 24
cat("El perímetro del rectángulo es:", perimetro_rectangulo, "\n")
## El perímetro del rectángulo es: 20
  • Se muestran ambos resultados por separado.

Conclusión Este ejercicio demuestra cómo aplicar fórmulas geométricas básicas para calcular tanto el área como el perímetro de un rectángulo. Al igual que en el ejercicio anterior, se utilizan valores predefinidos para mostrar los cálculos de forma directa.

PROGRAMA 5: CÁLCULO DE PROMEDIO DE NOTAS

Solicitar al usuario tres notas entre 0 y 20, calcular su promedio y mostrarlo en pantalla.

Este ejercicio requiere: 1. Solicitar tres notas al usuario 2. Verificar que estén en el rango válido (0-20) 3. Calcular el promedio 4. Mostrar el resultado

Desarrollo del código

1. Solicitud de las notas al usuario

# Solicitar al usuario las 3 notas
nota1 <- as.numeric(readline(prompt = "Ingrese la primera nota (0-20): "))
nota2 <- as.numeric(readline(prompt = "Ingrese la segunda nota (0-20): "))
nota3 <- as.numeric(readline(prompt = "Ingrese la tercera nota (0-20): "))
  • readline() se usa para pedir cada nota.
  • prompt permite mostrar un mensaje explicativo.
  • as.numeric() convierte la entrada a formato numérico.

Para propósitos de demostración, vamos a usar valores fijos:

# Asignar valores para demostración
nota1 <- 15
nota2 <- 17
nota3 <- 14

2. Verificación del rango y cálculo

# Verificar que las notas estén entre 0 y 20
if (nota1 >= 0 & nota1 <= 20 & nota2 >= 0 & nota2 <= 20 & nota3 >= 0 & nota3 <= 20) {
  # Calcular el promedio
  promedio <- (nota1 + nota2 + nota3) / 3
  print(paste("El promedio de las notas es: ", promedio))
} else {
  print("Las notas deben estar entre 0 y 20.")
}
## [1] "El promedio de las notas es:  15.3333333333333"
  • Se usa una estructura if para verificar que todas las notas estén en el rango correcto.
  • El operador & (AND lógico) requiere que todas las condiciones sean verdaderas.
  • Si las notas son válidas, se calcula el promedio sumando las tres y dividiendo entre 3.
  • paste() combina texto y valores numéricos para mostrar el resultado.
  • Si alguna nota está fuera del rango, se muestra un mensaje de error.

Conclusión Este ejercicio introduce el uso de estructuras condicionales (if-else) para validar datos de entrada, asegurando que cumplan con criterios específicos antes de realizar los cálculos. También muestra cómo manejar errores potenciales mostrando mensajes adecuados al usuario cuando los datos no son válidos.

PROGRAMA 6: CÁLCULO DEL ÁREA Y PERÍMETRO DE UNA CIRCUNFERENCIA

Calcular el área y el perímetro de la circunferencia, dado el radio.

Sabemos que: \[ Área = \pi r^2 \] \[ Perímetro = 2 \pi r \]

Desarrollo del código

1. Ingreso del radio por el usuario
Solicitamos al usuario ingresar el radio.

# INGRESA EL RADIO
radio <- as.numeric(readline("Ingrese el radio: "))

Para demostración, usaremos un valor fijo:

# Valor del radio para demostración
radio <- 5

2. Cálculo del área y perímetro
Se procede a calcular el área y el perímetro.

# CALCULA ÁREA Y PERÍMETRO
area <- pi * radio^2
perimetro <- 2 * pi * radio

3. Mostrar resultados

# MUESTRA RESULTADOS
cat("El área es:", area, "\n")
## El área es: 78.53982
cat("El perímetro es:", perimetro, "\n")
## El perímetro es: 31.41593

Conclusión
Este programa aplica las fórmulas geométricas para calcular el área y perímetro de una circunferencia, permitiendo al usuario ingresar el radio y mostrando los resultados.

PROGRAMA 7: CÁLCULO DEL ÁREA Y PERÍMETRO DE UN TRAPECIO

Calcular el área y perímetro de un trapecio dadas su base mayor, base menor y altura.

Sabemos que:

Área del trapecio: \[ Área = \frac{(base\_mayor + base\_menor) \cdot altura}{2} \]

Suponiendo un trapecio isósceles: \[ lado = \sqrt{\left(\frac{base\_mayor - base\_menor}{2}\right)^2 + altura^2} \] \[ Perímetro = base\_mayor + base\_menor + 2 \cdot lado \]

Desarrollo del código

1. Ingreso de datos por el usuario
Ingresar datos.

# INGRESA LOS DATOS
base_mayor <- as.numeric(readline("Ingrese la base mayor: "))
base_menor <- as.numeric(readline("Ingrese la base menor: "))
altura <- as.numeric(readline("Ingrese la altura: "))

Para demostración, usaremos valores fijos:

# Valores para demostración
base_mayor <- 10
base_menor <- 6
altura <- 4

2. Cálculo del área y perímetro
Se pide calcular el área y su perímetro.

# CÁLCULO DEL ÁREA
area <- ((base_mayor + base_menor) * altura) / 2

# SUPONEMOS TRAPECIO ISÓSCELES
lado <- sqrt(((base_mayor - base_menor) / 2)^2 + altura^2)

# CÁLCULO DEL PERÍMETRO
perimetro <- base_mayor + base_menor + 2 * lado

3. Mostrar resultados

# MUESTRA RESULTADOS
cat("El área del trapecio es:", area, "\n")
## El área del trapecio es: 32
cat("El perímetro del trapecio es:", perimetro, "\n")
## El perímetro del trapecio es: 24.94427

Conclusión
Este programa permite calcular el área y perímetro de un trapecio isósceles ingresando su base mayor, base menor y altura.

PROGRAMA 8: COMPARACIÓN ENTRE DOS NÚMEROS

Determinar cuál es el número mayor y cuál el menor entre dos números dados por el usuario. Si ambos números son iguales, indicarlo.

Desarrollo del código

1. Ingreso de los dos números
Solicitamos al usuario ingresar dos números para comparar.

# INGRESO DE NÚMEROS
numero1 <- as.numeric(readline("Ingrese el primer número: "))
numero2 <- as.numeric(readline("Ingrese el segundo número: "))

Para demostración, usaremos valores fijos:

# Valores para demostración
numero1 <- 15
numero2 <- 8

2. Comparación de los valores
Se usan estructuras condicionales para determinar cuál es mayor, menor o si son iguales.

3. Mostrar resultados y conclusión
Se imprimen los resultados y se presenta una breve conclusión.

# COMPARACIÓN ENTRE NÚMEROS Y RESULTADOS
if (numero1 > numero2) {
  cat("El número mayor es:", numero1, "\n")
  cat("El número menor es:", numero2, "\n")
  cat("Conclusión: Se compararon dos valores diferentes. El primero es mayor que el segundo.\n")
} else if (numero2 > numero1) {
  cat("El número mayor es:", numero2, "\n")
  cat("El número menor es:", numero1, "\n")
  cat("Conclusión: Se compararon dos valores diferentes. El segundo es mayor que el primero.\n")
} else {
  cat("Ambos números son iguales:", numero1, "\n")
  cat("Conclusión: Ambos números ingresados son exactamente iguales.\n")
}
## El número mayor es: 15 
## El número menor es: 8 
## Conclusión: Se compararon dos valores diferentes. El primero es mayor que el segundo.

Conclusión
Este programa permite comparar dos valores numéricos ingresados por el usuario, determinando cuál es el mayor y cuál el menor.

PROGRAMA 9: OPERACIONES BÁSICAS ENTRE DOS NÚMEROS

Ingresar dos números por teclado y realizar la suma, la resta, la multiplicación y la división entre ambos.

Desarrollo del código

1. Ingreso de los dos números
Solicitamos al usuario ingresar dos números.

# INGRESO Y OPERACIONES BÁSICAS
numero1 <- as.numeric(readline("Ingrese el primer número: "))
numero2 <- as.numeric(readline("Ingrese el segundo número: "))

Para demostración, usaremos valores fijos:

# Valores para demostración
numero1 <- 10
numero2 <- 5

2. Cálculo de las operaciones
Se realiza la suma, resta, multiplicación y división (verificando división por cero).

3. Mostrar resultados

suma <- numero1 + numero2
resta <- numero1 - numero2
multiplicacion <- numero1 * numero2

if (numero2 != 0) {
  division <- numero1 / numero2
  cat("La suma es:", suma, "\n")
  cat("La resta es:", resta, "\n")
  cat("La multiplicación es:", multiplicacion, "\n")
  cat("La división es:", division, "\n")
} else {
  cat("La suma es:", suma, "\n")
  cat("La resta es:", resta, "\n")
  cat("La multiplicación es:", multiplicacion, "\n")
  cat("La división no se puede realizar porque el segundo número es cero.\n")
}
## La suma es: 15 
## La resta es: 5 
## La multiplicación es: 50 
## La división es: 2

Conclusión
Este programa permite al usuario ingresar dos números y realizar las operaciones básicas entre ellos: suma, resta, multiplicación y división.

PROGRAMA 10: CÁLCULO DEL IVA Y TOTAL A PAGAR EN DÓLARES

Realice un programa que pida una cantidad en dólares y como resultado se visualice el IVA del 12% y el valor total a pagar.

Desarrollo del código

1. Ingreso de la cantidad en dólares
Solicitamos al usuario ingresar la cantidad en dólares.

# INGRESO Y CÁLCULO DE IVA Y TOTAL
valor <- as.numeric(readline("Ingrese la cantidad en dólares: "))

Para demostración, usaremos un valor fijo:

# Valor para demostración
valor <- 100

2. Cálculo del IVA y total a pagar
Se calcula el 12% del valor ingresado y luego se suma para obtener el total.

3. Mostrar resultados

iva <- valor * 0.12
total <- valor + iva

cat("El IVA (12%) es:", iva, "\n")
## El IVA (12%) es: 12
cat("El total a pagar es:", total, "\n")
## El total a pagar es: 112

Conclusión
Este programa permite calcular el impuesto al valor agregado (IVA) del 12% sobre una cantidad en dólares ingresada por el usuario.

PROGRAMA 11: CONVERSIÓN DE TEMPERATURA

Escribir un programa que pida la temperatura y si esta es en Fahrenheit o Celsius y presentar en pantalla su transformación en la otra medida.

Este ejercicio nos plantea crear un programa para convertir temperaturas entre las escalas Celsius y Fahrenheit usando las fórmulas de conversión:

Desarrollo del código

1. Definición de variables

Establecemos la temperatura y su unidad:

temperatura <- 25    # Se asigna la temperatura en grados Celsius
unidad <- "C"        # Se asigna la unidad ("C" para Celsius)
  • La variable temperatura almacena el valor numérico.
  • La variable unidad indica el tipo de escala (“C” para Celsius o “F” para Fahrenheit).

2. Estructura de decisión y cálculo

Utilizamos condicionales para decidir qué conversión realizar:

if (unidad == "C" || unidad == "c") {            # Condición si es Celsius
  resultado <- (temperatura * 9/5) + 32          # Fórmula de conversión a Fahrenheit
  cat("La temperatura", temperatura, "°C en Fahrenheit es:", resultado, "°F\n")  # Imprime resultado
} else if (unidad == "F" || unidad == "f") {      # Condición si es Fahrenheit
  resultado <- (temperatura - 32) * 5/9          # Fórmula de conversión a Celsius
  cat("La temperatura", temperatura, "°F en Celsius es:", resultado, "°C\n")
} else {                                         # Caso de unidad incorrecta
  cat("Unidad no válida. Debe ingresar 'C' o 'F'.\n")
}
## La temperatura 25 °C en Fahrenheit es: 77 °F
  • El operador || significa “o lógico”, permitiendo que la unidad sea “C” o “c”.
  • La estructura if-else if-else maneja los tres casos posibles.
  • La función cat() muestra los resultados de forma legible.

Conclusión Este ejercicio aplica conceptos básicos de programación como variables, operadores de comparación, estructuras condicionales y salida de datos. La conversión de temperatura es un problema común que demuestra cómo tomar decisiones basadas en condiciones específicas y realizar cálculos con fórmulas matemáticas simples.

PROGRAMA 12: CÁLCULO DE PAGO CON HORAS EXTRAS

Escribir un programa que pregunte al usuario por el número de horas trabajadas y el coste por hora. Después debe mostrar por pantalla la paga que le corresponde, además debe preguntar si existen horas extras que tienen un valor diferente y con estos valores se calcule la paga correspondiente.

Este ejercicio nos plantea calcular el pago de un trabajador considerando tanto horas regulares como posibles horas extras con diferente tarifa.

Desarrollo del código

1. Definición de variables básicas

Establecemos las horas trabajadas y el costo por hora:

horas <- 40                # Número de horas trabajadas
costo_hora <- 15            # Pago por hora trabajada

pago_base <- horas * costo_hora  # Multiplicación para calcular el pago base
  • Las variables horas y costo_hora almacenan los valores iniciales.
  • El pago_base se calcula multiplicando estas dos variables.

2. Verificación y cálculo de horas extras

hay_extras <- "S"           # Variable para saber si hay horas extras

if (hay_extras == "S" || hay_extras == "s") {    # Condición si hay horas extras
  horas_extras <- 5
  costo_hora_extra <- 20
  pago_extras <- horas_extras * costo_hora_extra  # Pago por las horas extra
  pago_total <- pago_base + pago_extras           # Suma de pago base y extras
  
  cat("Pago base:", pago_base, "\n")              # Mostrar pago base
  cat("Pago por horas extras:", pago_extras, "\n") # Mostrar pago extra
  cat("Pago total:", pago_total, "\n")             # Mostrar pago total
} else {
  cat("Pago total:", pago_base, "\n")
}
## Pago base: 600 
## Pago por horas extras: 100 
## Pago total: 700
  • La variable hay_extras controla si se deben calcular horas extras.
  • En caso afirmativo, se definen y calculan las horas extras y su pago.
  • Se suma el pago base y el pago por extras para obtener el total.
  • La función cat() muestra información detallada sobre cada componente del pago.

Conclusión Este ejercicio demuestra el uso de operaciones aritméticas básicas y control de flujo condicional para resolver un problema práctico de cálculo de salarios. El programa maneja diferentes componentes del pago (base y extras) y presenta la información de manera clara y organizada, lo que refleja un caso de uso común en programación de negocios.

PROGRAMA 13: SUMA DE ENTEROS POSITIVOS

Escribir un programa que lea un entero positivo, n, introducido por el usuario y después muestre en pantalla la suma de todos los enteros desde 1 hasta n. La suma de los n primeros enteros positivos puede ser calculada de la siguiente forma: suma=(n(n+1))/2

Este ejercicio nos plantea utilizar una fórmula matemática para calcular la suma de los primeros n números enteros positivos sin necesidad de usar un bucle.

Desarrollo del código

1. Definición del límite

Establecemos hasta qué número sumaremos:

n <- 10                    # Número hasta donde se suma
  • La variable n determina hasta qué número se realizará la suma.

2. Verificación y cálculo

if (n > 0) {                # Condición: el número debe ser positivo
  suma <- n * (n + 1) / 2   # Fórmula matemática para la suma
  cat("La suma de los enteros desde 1 hasta", n, "es:", suma, "\n")
} else {
  cat("El número ingresado no es positivo.\n")
}
## La suma de los enteros desde 1 hasta 10 es: 55
  • Se verifica que n sea positivo antes de realizar el cálculo.
  • La fórmula n * (n + 1) / 2 es una fórmula cerrada para calcular la suma de los primeros n enteros positivos.
  • El resultado se muestra usando cat() con un mensaje claro.

Conclusión Este ejercicio ilustra cómo se pueden aplicar fórmulas matemáticas eficientes en programación para evitar bucles y cálculos repetitivos. También demuestra el uso de estructuras condicionales para validar datos de entrada y asegurar que el cálculo solo se realice cuando las condiciones son adecuadas. La implementación es simple pero poderosa, mostrando que a veces el conocimiento matemático puede llevar a soluciones más elegantes y eficientes.

PROGRAMA 14: CÁLCULO DE ÍNDICE DE MASA CORPORAL (IMC)

Se necesita crear un programa en R que pida al usuario su peso (en kg) y estatura (en metros), calcule el índice de masa corporal (IMC) y lo muestre por pantalla con la frase “Tu índice de masa corporal es <imc>” donde <imc> es el valor redondeado a dos decimales.

Este ejercicio nos plantea calcular el IMC, una medida que relaciona el peso y la altura de una persona mediante la fórmula: IMC = peso (kg) / [estatura (m)]².

Desarrollo del código

1. Introducción del programa

Explicamos al usuario qué hará el programa:

# Introducción del programa
cat("Este programa pide al usuario su peso (en kg) y estatura (en metros),\n")
## Este programa pide al usuario su peso (en kg) y estatura (en metros),
cat("calcula el índice de masa corporal (IMC) y lo muestra redondeado a dos decimales.\n\n")
## calcula el índice de masa corporal (IMC) y lo muestra redondeado a dos decimales.
  • La función cat() muestra instrucciones e información al usuario.

2. Solicitud de datos

# Solicitar al usuario su peso en kg
peso <- as.numeric(readline(prompt = "Ingrese su peso en kg: "))

# Solicitar al usuario su estatura en metros
estatura <- as.numeric(readline(prompt = "Ingrese su estatura en metros: "))
  • La función readline() captura la entrada del usuario.
  • as.numeric() convierte dicha entrada a un valor numérico.

3. Cálculo y presentación de resultados

# Calcular el índice de masa corporal (IMC)
imc <- peso / (estatura^2)

# Redondear el IMC a dos decimales
imc_redondeado <- round(imc, 2)

# Mostrar el IMC en pantalla
cat("\nTu índice de masa corporal es", imc_redondeado, "\n")
  • Se aplica la fórmula del IMC dividiendo el peso por el cuadrado de la estatura.
  • La función round() redondea el resultado a 2 decimales.
  • cat() muestra el resultado formateado al usuario.

Conclusión Este ejercicio integra operaciones matemáticas, entrada de datos por el usuario y formateo de salida. Se demuestra cómo obtener datos del usuario, realizar cálculos específicos y presentar resultados de manera clara y con el formato adecuado. El redondeo a dos decimales muestra cómo controlar la precisión de los resultados numéricos en R, una habilidad importante para la presentación de datos.

PROGRAMA 15: CÁLCULO DE INTERÉS COMPUESTO

Se necesita crear un programa en R que pregunte al usuario una cantidad a invertir, el interés anual y el número de años, y luego muestre por pantalla el capital obtenido en la inversión.

Este ejercicio nos plantea calcular el crecimiento de una inversión utilizando la fórmula del interés compuesto: Monto Final = Principal × (1 + Tasa de Interés)^Tiempo.

Desarrollo del código

1. Solicitud de datos financieros

# Solicitar al usuario la cantidad a invertir
cantidad_invertir <- as.numeric(readline(prompt = "Ingrese la cantidad a invertir: "))

# Solicitar al usuario el interés anual
interes_anual <- as.numeric(readline(prompt = "Ingrese el interés anual (en porcentaje): ")) / 100

# Solicitar al usuario el número de años
num_anos <- as.numeric(readline(prompt = "Ingrese el número de años: "))
  • La función readline() con prompt muestra un mensaje y captura la entrada del usuario.
  • as.numeric() convierte la entrada a formato numérico.
  • El interés anual se divide por 100 para convertirlo de porcentaje a decimal.

2. Cálculo y presentación del capital final

# Calcular el capital obtenido con la fórmula del interés compuesto
capital_obtenido <- cantidad_invertir * (1 + interes_anual)^num_anos

# Mostrar el capital obtenido en pantalla
cat("\nEl capital obtenido después de", num_anos, "años es", round(capital_obtenido, 2), "\n")
  • Se aplica la fórmula del interés compuesto para calcular el capital final.
  • La función round() redondea el resultado a 2 decimales para facilitar su lectura.
  • cat() muestra el resultado con un mensaje explicativo claro.

Conclusión Este ejercicio aplica conceptos financieros básicos a través de programación en R. Demuestra cómo implementar fórmulas matemáticas complejas, manejar diferentes tipos de datos numéricos y presentar resultados financieros de manera comprensible. El código ilustra un caso de uso práctico para análisis financiero básico, habilidad esencial para estudiantes de economía y estadística.

PROGRAMA 16: CONVERTIDOR DE UNIDADES DE TIEMPO

Se necesita crear un programa en R que pida al usuario el tiempo en horas, minutos o segundos, luego le permita elegir en qué tipo de tiempo desea transformarlo (por ejemplo, horas a minutos, minutos a segundos, etc.) y luego mostrar el resultado de la conversión.

Este ejercicio nos plantea crear un convertidor de unidades de tiempo que pueda transformar entre horas, minutos y segundos usando las relaciones estándar (1 hora = 60 minutos, 1 minuto = 60 segundos).

Desarrollo del código

1. Solicitud de datos de entrada

# Solicitar datos de entrada
tiempo <- as.numeric(readline(prompt = "Ingresa el valor del tiempo (en número): "))
unidad_origen <- tolower(readline(prompt = "¿En qué unidad está el tiempo ingresado? (horas, minutos, segundos): "))
unidad_destino <- tolower(readline(prompt = "¿A qué unidad deseas convertir? (horas, minutos, segundos): "))
  • readline() captura los valores ingresados por el usuario.
  • as.numeric() convierte el tiempo a un valor numérico.
  • tolower() convierte el texto a minúsculas para facilitar la comparación.

2. Lógica de conversión

# Realizar la conversión
if (unidad_origen == "horas" && unidad_destino == "minutos") {
  resultado <- tiempo * 60
} else if (unidad_origen == "horas" && unidad_destino == "segundos") {
  resultado <- tiempo * 3600
} else if (unidad_origen == "minutos" && unidad_destino == "horas") {
  resultado <- tiempo / 60
} else if (unidad_origen == "minutos" && unidad_destino == "segundos") {
  resultado <- tiempo * 60
} else if (unidad_origen == "segundos" && unidad_destino == "horas") {
  resultado <- tiempo / 3600
} else if (unidad_origen == "segundos" && unidad_destino == "minutos") {
  resultado <- tiempo / 60
} else {
  resultado <- "Unidad no válida"
}
  • Se utilizan múltiples condiciones if-else if para manejar todas las posibles combinaciones de conversión.
  • El operador && representa “y lógico”, requiriendo que ambas condiciones sean verdaderas.
  • Las operaciones incluyen multiplicación por 60 (o 3600) para convertir a unidades más pequeñas y división para convertir a unidades más grandes.

3. Presentación del resultado

# Mostrar el resultado
cat("El resultado es:", resultado, "\n")
  • La función cat() muestra el resultado de la conversión de forma clara.

Conclusión Este ejercicio demuestra cómo manejar múltiples condiciones para crear un convertidor de unidades flexible. El programa utiliza estructuras condicionales anidadas para cubrir todos los posibles escenarios de conversión y muestra cómo trabajar con diferentes factores de conversión. Este tipo de programa es útil para entender cómo implementar tablas de conversión en código y cómo manejar interacciones del usuario más complejas con múltiples entradas relacionadas.

PROGRAMA 17: ORDENAMIENTO DE NÚMEROS

Programa para ingresar varios números y mostrarlos ordenados.

Este ejercicio nos plantea crear un programa que permita al usuario ingresar múltiples números separados por espacios, para luego mostrarlos ordenados de menor a mayor.

Desarrollo del código

1. Solicitud y procesamiento de entrada múltiple

entrada <- readline(prompt = "Ingrese los números separados por espacio: ")
numeros <- as.numeric(unlist(strsplit(entrada, " ")))
  • readline() captura la entrada completa del usuario.
  • strsplit() divide la cadena de texto en palabras individuales usando el espacio como separador.
  • unlist() convierte la lista resultante en un vector.
  • as.numeric() transforma cada elemento del vector a formato numérico.

2. Ordenamiento y presentación de resultados

# Ordenar los números
numeros_ordenados <- sort(numeros)

# Mostrar los números ordenados
cat("Números ordenados:\n")
print(numeros_ordenados)
  • La función sort() ordena el vector de números de menor a mayor.
  • cat() muestra un encabezado explicativo.
  • print() muestra el vector ordenado de forma clara.

Conclusión Este ejercicio muestra cómo procesar entradas múltiples del usuario en una sola línea, separar texto en componentes individuales y manipular colecciones de datos. El uso de la función sort() demuestra cómo R proporciona herramientas integradas para operaciones comunes de manipulación de datos. Este tipo de programa es fundamental para entender cómo trabajar con conjuntos de datos y realizar ordenamientos, una operación estadística básica.

PROGRAMA 18: CÁLCULO DE FACTORIAL

Pedir un número al usuario y calcular su factorial.

Este ejercicio nos plantea calcular el factorial de un número entero positivo. El factorial de un número n (denotado como n!) es el producto de todos los enteros positivos menores o iguales que n.

Desarrollo del código

1. Solicitud de entrada al usuario

# Pedir un número al usuario
numero <- as.integer(readline(prompt = "Ingrese un número para calcular su factorial: "))
  • readline() captura la entrada del usuario con un mensaje informativo.
  • as.integer() convierte la entrada a un número entero.

2. Cálculo y presentación del factorial

# Calcular el factorial
factorial_resultado <- factorial(numero)

# Mostrar el resultado
cat("El factorial de", numero, "es:", factorial_resultado, "\n")
  • La función integrada factorial() de R calcula directamente el factorial del número.
  • cat() muestra el resultado de forma clara y con contexto.

Conclusión Este ejercicio demuestra cómo utilizar funciones matemáticas incorporadas en R para realizar cálculos complejos de manera sencilla. El uso de la función factorial() muestra la riqueza de la biblioteca estándar de R para operaciones matemáticas. Aunque podría implementarse manualmente con un bucle, este enfoque muestra cómo aprovechar las funciones existentes para hacer el código más conciso y eficiente.

PROGRAMA 19: VERIFICACIÓN DE NÚMERO PRIMO

Pedir un número al usuario y verificar si es un número primo.

Este ejercicio nos plantea determinar si un número entero es primo (solo divisible por 1 y por sí mismo) mediante un algoritmo de verificación.

Desarrollo del código

1. Solicitud de entrada al usuario

# Pedir un número al usuario
numero <- as.integer(readline(prompt = "Ingrese un número para saber si es primo: "))
  • readline() captura la entrada del usuario con un mensaje claro.
  • as.integer() convierte la entrada a un número entero.

2. Algoritmo de verificación de primalidad

# Verificar si el número es primo
es_primo <- TRUE

if (numero <= 1) {
  es_primo <- FALSE
} else {
  for (i in 2:(numero - 1)) {
    if (numero %% i == 0) {
      es_primo <- FALSE
      break
    }
  }
}
  • Se inicializa es_primo como TRUE y se cambia según las condiciones.
  • Los números menores o iguales a 1 no son primos.
  • El bucle for verifica si el número es divisible por algún entero entre 2 y (numero-1).
  • El operador %% calcula el resto de la división.
  • break detiene el bucle tan pronto como se encuentra un divisor.

3. Presentación del resultado

# Mostrar el resultado
if (es_primo) {
  cat(numero, "es un número primo.\n")
} else {
  cat(numero, "NO es un número primo.\n")
}
  • Se utiliza una estructura condicional para mostrar el mensaje apropiado según el resultado.
  • cat() muestra el resultado de forma clara y directa.

Conclusión Este ejercicio implementa un algoritmo fundamental de la teoría de números para verificar la primalidad. Demuestra el uso de bucles, operadores de módulo y estructuras de control de flujo para resolver un problema matemático clásico. El uso de la declaración break muestra cómo optimizar el algoritmo deteniendo la búsqueda tan pronto como se encuentra un divisor, lo que es una técnica importante de eficiencia en programación.

PROGRAMA 20: VERIFICACIÓN DE NÚMERO PAR O IMPAR

Escribir un programa que pida un número e indique si el número es par o impar.

Este ejercicio nos plantea determinar si un número es par o impar, lo cual se logra verificando si el número es divisible por 2 (el residuo de la división es 0).

Desarrollo del código

1. Solicitud de entrada al usuario

# Solicitar un número al usuario
numero <- as.integer(readline(prompt = "INGRESAR UN NÚMERO : "))
  • readline() captura la entrada del usuario mostrando un mensaje claro.
  • as.integer() convierte la entrada a un número entero.

2. Verificación y presentación del resultado

# Verificar si el número es par o impar
if (numero %% 2 == 0) {
  cat("El número", numero, "es PAR.\n")
} else {
  cat("El número", numero, "es IMPAR.\n")
}
  • El operador %% calcula el residuo de la división por 2.
  • Si el residuo es 0, el número es par; de lo contrario, es impar.
  • cat() muestra el resultado con un mensaje claro y contextualizado.

Conclusión Este ejercicio demuestra uno de los conceptos más fundamentales de la programación: el uso del operador módulo para determinar la divisibilidad. La implementación es simple pero poderosa, mostrando cómo una sola línea de código puede resolver un problema matemático básico. Este tipo de verificación es común en muchos algoritmos y demuestra la importancia de entender las operaciones matemáticas básicas en programación.