Los siguientes ejercicios están diseñados para familiarizarse con los conceptos fundamentales de la programación estructurada a través de la práctica. Estos problemas abarcan una variedad de temas esenciales que son la base para el desarrollo de cualquier aplicación o software.
A lo largo de estos 10 ejercicios, practicarás y afianzarás las siguientes habilidades de programación:
• Entrada y Salida de Datos (I/O): Aprenderás a solicitar datos al usuario (como peso, temperatura u horas trabajadas) y presentar resultados de manera clara en pantalla (Ejercicios 1, 2, 4, 6, 7, 10).
• Estructuras Condicionales: Implementarás la lógica necesaria para que el programa tome decisiones basadas en condiciones (p. ej., si la temperatura es Fahrenheit o Celsius, si un número es par o impar, o si se debe calcular el pago con o sin horas extras) (Ejercicios 1, 2, 10).
• Operaciones Matemáticas y Fórmulas: Aplicarás cálculos básicos y fórmulas específicas (como el IMC, compuesto interés, o la suma de números enteros) para resolver problemas prácticos (Ejercicios 3, 4, 5, 8).
o Un ejemplo destacado es el uso de la fórmula de Gauss para la suma de una serie aritmética en el Ejercicio 3:\(S = \frac{n(n+1)}{2}\).
• Estructuras de control repetitivas (Bucles): Aunque no es explícito en todos, para resolver el cálculo del factorial (Ejercicio 8) y potencialmente la identificación de números primos (Ejercicio 9), necesitarás utilizar bucles ( foro while) para realizar operaciones repetidas.
• Manejo de Tipos de Datos: Trabajarás con enteros ( n, horas), números de punto flotante (temperatura, peso, estatura, interés) y posiblemente cadenas de texto (tipo de unidad de tiempo).
• Algoritmos de Ordenamiento: En el Ejercicio 7, aplicarás o simularás un algoritmo de ordenamiento simple para organizar una lista de números ingresados por el.
Desarrollar un varios programas en R que permitan aplicar conceptos básicos de programación, un buen manejo del proceso y operaciones aritméticas, con el fin de resolver problemas prácticos relacionados con conversiones, cálculos matemáticos y validaciones numéricas.
Aplicar estructuras de entrada y salida de datos en R es decir ingresar datos por teclado para interactuar con el usuario.
Implementar operaciones matemáticas y diseñar programas que permitan transformar unidades, realizar cálculos financieros, matemáticos y validar propiedades numéricas.
Utilizar estructuras de control como condicionales y ciclos para desarrollar soluciones eficientes.
Integrar todos los ejercicios en un único documento reproducible mediante RMarkdown o Quarto, promoviendo organización y claridad en el desarrollo del código.
Para el desarrollo de los ejercicios se utilizó el lenguaje de programación R dentro de un documento elaborado con RMarkdown o Quarto. El proceso seguido fue el siguiente:
Comprensión del problema:
Se analizó cada ejercicio para identificar los datos que debía ingresar
el usuario, el procedimiento a realizar y el resultado
esperado.
Diseño de la solución:
Se definieron las variables y operaciones necesarias, así como las
estructuras de control que permiten ejecutar cada programa
correctamente.
Interacción con el usuario:
Se empleó el paquete svDialogs para solicitar información mediante
cuadros de diálogo, facilitando la captura de datos dentro del entorno
de R.
Implementación:
Cada ejercicio fue programado siguiendo una estructura clara: ingreso de
datos, procesamiento y presentación del resultado en pantalla.
Verificación:
Se ejecutaron pruebas para confirmar el correcto funcionamiento de cada
programa y asegurar la coherencia de los resultados.
Un estudiante está realizando un proyecto en el que debe comparar datos de temperatura provenientes de diferentes fuentes. Algunas están en Celsius y otras en Fahrenheit, lo que dificulta su análisis. Para resolverlo, necesita un programa que permita ingresar un valor y su tipo de medida, y que automáticamente convierta la temperatura a la otra escala.
# install.packages("svDialogs")
library(svDialogs)
# Solicitar la temperatura
temp_input <- dlg_input("Ingrese la temperatura:")$res
temperatura <- as.numeric(temp_input)
# Solicitar la escala
escala <- dlg_input("¿La temperatura está en Celsius o Fahrenheit? (C/F)")$res
escala <- toupper(escala)
# Conversión según la escala
if (escala == "C") {
resultado <- (temperatura * 9/5) + 32
mensaje <- paste(temperatura, "°C equivalen a", round(resultado, 2), "°F")
} else if (escala == "F") {
resultado <- (temperatura - 32) * 5/9
mensaje <- paste(temperatura, "°F equivalen a", round(resultado, 2), "°C")
} else {
mensaje <- "Escala inválida. Debe ingresar C para Celsius o F para Fahrenheit."
}
# Mostrar mensaje
dlg_message(mensaje, type = "ok")Una pequeña empresa quiere facilitar a sus empleados el cálculo de su pago semanal. Sin embargo, algunos tienen horas extras que no se pagan igual que las horas normales. Para evitar confusiones, necesitan un programa que solicite la cantidad de horas trabajadas, el costo por hora y, si hay horas extras, su valor por separado. Al final, el sistema debe mostrar la paga total de manera clara y precisa.
# library(svDialogs)
# --- 1. Horas trabajadas ---
horas <- dlgInput("Ingrese el numero de horas trabajadas:")$res
horas <- as.numeric(horas)
if (is.na(horas) || horas < 0) {
dlgMessage("Debe ingresar un numero valido de horas.", type = "ok")
} else {
# --- 2. Coste por hora ---
costo_hora <- dlgInput("Ingrese el costo por hora:")$res
costo_hora <- as.numeric(costo_hora)
if (is.na(costo_hora) || costo_hora < 0) {
dlgMessage("Debe ingresar un costo por hora valido.", type = "ok")
} else {
# --- 3. Preguntar si hay horas extra ---
respuesta <- dlgList(
c("Si", "No"),
title = "¿Existen horas extra?"
)$res
pago_total <- horas * costo_hora # Pago base
if (respuesta == "Si") {
# --- 4. Horas extra ---
horas_extra <- dlgInput("Ingrese cuantas horas extra trabajo:")$res
horas_extra <- as.numeric(horas_extra)
if (is.na(horas_extra) || horas_extra < 0) {
dlgMessage("Debe ingresar un numero valido de horas extra.", type = "ok")
return(NULL)
}
# --- 5. Costo por hora extra ---
costo_extra <- dlgInput("Ingrese el costo por hora extra:")$res
costo_extra <- as.numeric(costo_extra)
if (is.na(costo_extra) || costo_extra < 0) {
dlgMessage("Debe ingresar un costo valido para horas extra.", type = "ok")
return(NULL)
}
# Calcular pago total
pago_total <- pago_total + horas_extra * costo_extra
}
# --- 6. Mostrar resultado final ---
dlgMessage(
paste("La paga total correspondiente es:", pago_total, "unidades monetarias."),
type = "ok"
)
}
}El objetivo de este ejercicio es desarrollar un programa en R que permita calcular la suma de los números enteros desde 1 hasta un valor n ingresado por el usuario. Este tipo de problema es un caso clásico dentro de la programación, ya que permite practicar conceptos fundamentales como entrada de datos, conversión de tipos, validación de valores, y la aplicación de fórmulas matemáticas simples.
En primer lugar, el programa debe solicitar al usuario un número entero positivo, que representará el límite superior de la suma. Sin embargo, dado que las entradas proporcionadas por un usuario pueden ser incorrectas o inválidas (por ejemplo, ingresar texto, números decimales o valores negativos), es indispensable realizar un proceso de validación. Esta validación garantiza que el valor ingresado sea:
NA).Solo si estas tres condiciones se cumplen, el programa podrá continuar con el cálculo.
Una vez validado el número, el programa debe convertirlo formalmente a entero para trabajar con un tipo de dato correcto y seguro. A continuación, se procede a calcular la suma de los enteros desde 1 hasta n utilizando la fórmula matemática cerrada:
\[ S = \frac{n(n+1)}{2} \]
Esta fórmula permite obtener el resultado de forma eficiente, sin necesidad de ciclos o acumuladores, lo que demuestra la utilidad de aplicar métodos matemáticos dentro de la programación.
Finalmente, el programa muestra el valor ingresado y el resultado de la suma calculada, proporcionando al usuario una respuesta clara y comprensible.
# library(svDialogs)
# 1. Solicitar número al usuario
entrada <- dlgInput("Ingrese un entero positivo n:")$res
# 2. Convertir la entrada a número
num <- as.numeric(entrada)
# 3. Validaciones
numerico <- !is.na(num) # Es numérico
entero <- numerico && (floor(num) == num) # Es entero
positivo <- entero && (num > 0) # Es positivo
# Validación final
valido <- numerico && entero && positivo
# 4. Revisar si es válido
if (!valido) {
dlgMessage("Entrada inválida. Por favor ingrese un ENTERO POSITIVO mayor que 0.", type = "ok")
} else {
# 5. Convertir formalmente a entero
n <- as.integer(num)
dlgMessage(paste("Has ingresado el número =", n), type = "ok")
# 6. Calcular la suma con la fórmula (Método A)
suma <- (n * (n + 1)) / 2
# 7. Mostrar resultado final
dlgMessage(paste("La suma de los enteros desde 1 hasta", n, "es:", suma), type = "ok")
}El Índice de Masa Corporal (IMC) es una medida ampliamente utilizada en el ámbito de la salud para evaluar si una persona tiene un peso adecuado en relación con su estatura. Este indicador se calcula mediante la fórmula:
\[ IMC = \frac{peso}{estatura^2} \]
donde el peso se expresa en kilogramos y la estatura en metros. Su valor permite clasificar a un individuo en categorías como bajo peso, peso normal, sobrepeso u obesidad, lo cual es fundamental para el análisis de la salud física y la prevención de enfermedades asociadas al estilo de vida.
El propósito de este ejercicio es diseñar un programa en R que solicite al usuario su peso y estatura, calcule su IMC, lo almacene en una variable y finalmente muestre el resultado redondeado a dos decimales. Para asegurar que el cálculo sea correcto, es necesario validar las entradas del usuario, ya que no todos los valores ingresados pueden ser adecuados. Por ejemplo, el usuario podría escribir letras, dejar el campo vacío, ingresar valores negativos o colocar ceros, lo cual generaría errores o resultados sin sentido.
Por ello, el programa debe verificar que:
El peso ingresado sea numérico y positivo.
Esto garantiza que el valor representa una cantidad realista de masa
corporal.
La estatura ingresada también sea numérica y
positiva.
La estatura igual a 0 o valores negativos harían imposible el cálculo,
ya que implicarían una división inválida.
Una vez validados ambos valores, el programa procede a convertir las entradas a tipo numérico seguro y aplica la fórmula del IMC. Finalmente, el resultado se muestra con dos decimales para brindar una presentación clara y estándar del indicador.
Este ejercicio permite reforzar el uso de lectura de datos, validación de variables, conversión de tipos, operaciones aritméticas y comunicación de resultados en pantalla, todos elementos esenciales en la programación básica con R.
# library(svDialogs)
# 1. Pedir entrada al usuario (peso en kg)
peso <- dlgInput("Ingrese su peso en kilogramos (ej. 70.5):")$res
# 2. Pedir entrada al usuario (estatura en metros)
altura <- dlgInput("Ingrese su estatura en metros (ej. 1.75):")$res
# 3. Convertir a número
peso_num <- as.numeric(peso)
# 4. Validar que peso sea numérico y positivo
peso_es_num <- !is.na(peso_num)
peso_positivo <- peso_es_num && (peso_num > 0)
if (!peso_positivo) {
dlgMessage("Entrada inválida para el peso. Por favor ingrese un número POSITIVO (kg).", type = "ok")
} else {
# 5. Convertir a número
altura_num <- as.numeric(altura)
# 6. Validar que la altura sea numérica y positiva
altura_es_num <- !is.na(altura_num)
altura_positiva <- altura_es_num && (altura_num > 0)
if (!altura_positiva) {
dlgMessage("Entrada inválida para la estatura. Por favor ingrese un número POSITIVO (m).", type = "ok")
} else {
# 7. Conversión formal a numérico
peso <- peso_num
altura <- altura_num
# 8. Cálculo del IMC (solo como ejemplo matemático)
imc <- peso / (altura^2)
# 9. Redondear a 2 decimales
imc_redondeado <- round(imc, 2)
# 10. Mostrar resultado final
dlgMessage(paste("El cálculo de IMC es:", imc_redondeado), type = "ok")
}
}Un usuario está evaluando diferentes oportunidades de inversión y necesita comparar los resultados. Para eso, requiere una herramienta que calcule automáticamente cuánto dinero tendrá al terminar cada opción, ingresando la cantidad inicial, el interés anual y el tiempo en años. Esto le permitirá tomar una decisión más informada.
# library(svDialogs)
# Ingreso de datos del usuario por teclado
inversion <- dlgInput("Ingrese la cantidad a invertir: ")$res
inversion <- as.numeric(inversion)
inversion## [1] NAinteres <- dlgInput("Ingrese el interés anual en %: ")$res
interes <- as.numeric(interes)
interes## [1] NAaños <- dlgInput("Ingrese el número de años: ")$res
años <- as.numeric(años)
años## [1] NA# Convertir interés de porcentaje a decimal
deci <- interes / 100
# Calcular el capital obtenido de la inversion
capital <- inversion * (1 + deci)^años
dlgMessage (paste("El capital obtenido de la inversión después de", años, "años y con un", interes,"% de interes es:", capital,"$"), type= "ok" )En una actividad de organización de horarios, una persona necesita manejar tiempos en diferentes formatos. Sin embargo, realizar las conversiones manualmente se vuelve tedioso. Por ello, busca un programa que reciba un valor en horas, minutos o segundos, pregunte a qué formato desea convertir y muestre el resultado de manera clara y exacta.
# library(svDialogs)
# Ingreso del valor numérico
tiempo <- dlgInput("Ingrese el tiempo (en horas, minutos o segundos):")$res
tiempo <- as.numeric(tiempo)
# Validación básica
if (is.na(tiempo) || tiempo < 0) {
dlgMessage("Por favor ingrese un número válido y positivo.", type = "ok")
} else {
# Selección de unidad de tiempo ingresada
t_ingr <- dlgList(
choices = c("Minutos", "Horas", "Segundos"),
preselect = "Minutos",
title = "Seleccione la unidad del tiempo ingresado"
)$res
# Selección de unidad a convertir
t_cambiar <- dlgList(
choices = c("Minutos", "Horas", "Segundos"),
preselect = "Minutos",
title = "Seleccione la unidad a la que desea convertir"
)$res
# Convertir etiquetas a números
op_ingr <- match(t_ingr, c("Minutos","Horas","Segundos"))
op_conv <- match(t_cambiar, c("Minutos","Horas","Segundos"))
# ---- CONVERSIONES ----
if (op_ingr == 1 && op_conv == 1) { # Minutos a minutos
resultado <- tiempo
dlgMessage(paste("La conversión es:", resultado, "minutos"), type = "ok")
}
if (op_ingr == 1 && op_conv == 2) { # Minutos a horas
resultado <- tiempo / 60
dlgMessage(paste("Minutos a horas:", resultado, "horas"), type = "ok")
}
if (op_ingr == 1 && op_conv == 3) { # Minutos a segundos
resultado <- tiempo * 60
dlgMessage(paste("Minutos a segundos:", resultado, "segundos"), type = "ok")
}
if (op_ingr == 2 && op_conv == 1) { # Horas a minutos
resultado <- tiempo * 60
dlgMessage(paste("Horas a minutos:", resultado, "minutos"), type = "ok")
}
if (op_ingr == 2 && op_conv == 2) { # Horas a horas
resultado <- tiempo
dlgMessage(paste("La conversión es:", resultado, "horas"), type = "ok")
}
if (op_ingr == 2 && op_conv == 3) { # Horas a segundos
resultado <- tiempo * 3600
dlgMessage(paste("Horas a segundos:", resultado, "segundos"), type = "ok")
}
if (op_ingr == 3 && op_conv == 1) { # Segundos a minutos
resultado <- tiempo / 60
dlgMessage(paste("Segundos a minutos:", resultado, "minutos"), type = "ok")
}
if (op_ingr == 3 && op_conv == 2) { # Segundos a horas
resultado <- tiempo / 3600
dlgMessage(paste("Segundos a horas:", resultado, "horas"), type = "ok")
}
if (op_ingr == 3 && op_conv == 3) { # Segundos a segundos
resultado <- tiempo
dlgMessage(paste("La conversión es:", resultado, "segundos"), type = "ok")
}
}En una actividad escolar, un estudiante debe ordenar varias listas de números para analizarlas, pero hacerlo a mano consume demasiado tiempo. Para facilitar su trabajo, necesita una herramienta que permita escribir números separados por comas y que luego los ordene automáticamente en pantalla.
# library(svDialogs)
# Solicitar al usuario una lista de números separados por comas
numeros_texto <- dlgInput("Ingrese los números separados por comas (ej: 4, 1, 9, 3):")$res
# Separar por comas y convertir a numérico
numeros <- as.numeric(unlist(strsplit(numeros_texto, ",")))
# Validación por si hay entradas no numéricas
if (any(is.na(numeros))) {
dlgMessage("Error: asegúrese de ingresar solo números separados por comas.", type = "ok")
} else {
# Ordenar
numeros_ordenados <- sort(numeros)
# Mostrar resultado
dlgMessage(
paste("Los números ordenados son:\n", paste(numeros_ordenados, collapse = ", ")),
type = "ok"
)
}Un estudiante está aprendiendo sobre matemáticas y necesita calcular el factorial de varios números para resolver ejercicios, pero hacerlo manualmente le toma tiempo y puede cometer errores. Por ello, requiere un programa que permita digitar un número y obtener automáticamente su factorial.
# library(svDialogs)
# Solicitar número al usuario
entrada <- dlgInput("Ingrese un número entero no negativo para calcular su factorial:")$res
n <- as.numeric(entrada)
# Validaciones
if (is.na(n) || n < 0 || n != floor(n)) {
dlgMessage(
"Debe ingresar un número ENTERO NO NEGATIVO.",
type = "ok"
)
} else {
# Cálculo del factorial
factorial_n <- factorial(n)
# Mostrar resultado
dlgMessage(
paste("El factorial de", n, "es:", factorial_n),
type = "ok"
)
}En una actividad de clasificación numérica, un usuario debe separar números primos de los que no lo son. Hacer esta revisión uno por uno puede ser tardado, por lo que requiere una herramienta que pida un número y devuelva automáticamente si este es primo o no, evitando errores y ahorrando tiempo.
# library(svDialogs)
# Solicitar número al usuario
entrada <- dlgInput("Ingresa un número entero positivo para verificar si es primo:")$res
numero <- as.numeric(entrada)
# Validar entrada
if (is.na(numero) || numero != floor(numero) || numero <= 0) {
dlgMessage("Debes ingresar un número ENTERO POSITIVO.", type = "ok")
} else {
# Verificar si 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
}
}
}
# Mostrar resultado
if (es_primo) {
dlgMessage(paste("El número", numero, "es PRIMO."), type = "ok")
} else {
dlgMessage(paste("El número", numero, "NO es primo."), type = "ok")
}
}En una actividad escolar, se deben clasificar números según sus características. Para facilitar esta tarea, el usuario necesita una herramienta sencilla que reciba un número digitado y muestre si pertenece al grupo de los pares o al de los impares, evitando errores en la clasificación manual.
library(svDialogs)
# Solicitar número al usuario
entrada <- dlgInput("Ingresa un número para verificar si es par o impar:")$res
numero <- as.numeric(entrada)
# Validar entrada
if (is.na(numero)) {
dlgMessage("Debes ingresar un valor numérico.", type = "ok")
} else {
# Verificar si es par o impar
if (numero %% 2 == 0) {
dlgMessage(paste("El número", numero, "es PAR."), type = "ok")
} else {
dlgMessage(paste("El número", numero, "es IMPAR."), type = "ok")
}
}En conclusión, la realización de cada uno de estes ejercicios nos ha permitido reforzar el manejo básico de programación en R, especialmente la interacción con el usuario mediante readline(), el uso de funciones para procesar datos y la presentación de resultados en pantalla.
En conjunto, de los diferentes ejercicios permitieron desarrollar habilidades fundamentales para la construcción de programas simples en R, fortaleciendo el pensamiento lógico, la manipulación de datos y la correcta presentación de resultados dentro de un documento R Markdown.
Leer con atención cada enunciado para comprender exactamente qué datos se deben solicitar y qué operaciones debe realizar el programa.
Validar siempre los datos ingresados por el usuario, asegurando que no estén vacíos y que sean del tipo adecuado (numéricos, enteros, positivos, etc.).
Convertir las entradas con funciones apropiadas, como as.numeric() o as.integer(), antes de realizar cálculos para evitar errores en la ejecución.
Probar cada programa con distintos tipos de valores, incluyendo casos límite, valores incorrectos y valores esperados para comprobar su funcionamiento.
Incluir mensajes de error claros cuando el usuario ingrese datos inválidos, permitiendo corregir la información fácilmente.
Comentar el código de forma ordenada y concisa, explicando qué hace cada sección para mejorar la legibilidad y facilitar revisiones futuras.
Mantener una estructura lógica en el programa, separando las etapas de entrada, validación, cálculo y salida.
Evitar repetir cálculos innecesarios y procurar que el código sea lo más eficiente y entendible posible.