El presente trabajo reúne una serie de ejercicios orientados al desarrollo de habilidades fundamentales en programación utilizando operaciones básicas, manejo de tipos de datos y estructuras simples de entrada y salida. Cada actividad permite aplicar conceptos esenciales como conversión de unidades, cálculos matemáticos, validación de datos, uso de variables, y procesamiento de información proporcionada por el usuario. A través de estos ejercicios, el estudiante fortalece su capacidad para analizar problemas cotidianos y traducirlos en soluciones computacionales eficientes y comprensibles. El objetivo principal es fomentar la lógica de programación y el uso adecuado de los distintos tipos de datos para resolver situaciones prácticas.
Desarrollar habilidades básicas de programación mediante la aplicación de tipos de datos, operaciones matemáticas y estructuras primitivas de entrada, procesamiento y salida para resolver problemas prácticos.
Comprender y aplicar diferentes tipos de datos (numéricos, cadenas y booleanos) en la elaboración de programas simples.
Implementar cálculos matemáticos comunes, como conversiones de temperatura, sumatorias, factoriales e índices, utilizando expresiones aritméticas.
El uso de tipos de datos es fundamental en programación, ya que permite definir la naturaleza de la información que un programa puede manejar.
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.
temp<- as.numeric(readline(prompt = "Ingrese su temperatura:"))## Ingrese su temperatura:tipo<- readline(prompt = "Ingrese la unidad Celsius 'C', 'F' para Fahrenheit: ")## Ingrese la unidad Celsius 'C', 'F' para Fahrenheit:if (toupper(tipo) == "C") {
resul<- ((temp* 9/5 )+ 32)
cat(temp, "C equivale a", resul, "F\n")
} else if (toupper(tipo) == "F") {
resul<- (temp -32) * 5/9
cat(temp, "F equivalen a", resul, "C\n" )
} else {
cat("Unidad no validad debe ingresar C o F ")
}## Unidad no validad debe ingresar C o F1.temp: almacena la temperatura ingresada por el
usuario. Se convierte a formato numérico con as.numeric(). 2.
tipo: guarda la unidad ingresada por el usuario (“C” o
“F”). 3. resul: contiene el resultado de la conversión, ya
sea de Celsius a Fahrenheit o de Fahrenheit a Celsius.
1.readline().Permite capturar datos ingresados por el
usuario desde la consola. Se usa para pedir tanto la temperatura como la
unidad de medida. 2.as.numeric(). Convierte el valor
ingresado mediante readline() en un número, ya que todo lo que ingresa
el usuario inicialmente se guarda como texto.
3.toupper().Convierte la unidad ingresada a mayúsculas,
garantizando que el programa funcione igual si el usuario escribe “c”,
“C”, “f” o “F”. 4.if, else if, else.Estructuras
condicionales que permiten ejecutar diferentes bloques de código según
la unidad ingresada. 5.cat().Muestra texto en la consola
concatenando variables y mensajes. Se utiliza para imprimir la
temperatura original y el valor convertido.
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
#ingresamos a la libreria svidialogs para poder desplazar cuadros de dialogo
library(svDialogs)
#asigando a una variable de nombre horas y luego convirtiendo a numerico por que al
#al ingresar datos en cuadro de dialogo se ingresa como caracter
horas<- as.numeric(dlgInput(message = "Ingrese sus hora trabajadas:")$res)
cohoras <- as.numeric(dlgInput( message = "Ingres el costo por horas:")$res)
extra<- tolower(dlgInput(message = "Tiene horas extras ingrese si/no:")$res)
pago_ex <-0
if ( extra == "si"){
hora_ex<- as.numeric(dlgInput(message = "Ingrese sus horas extras:")$res)
cos_ex<- as.numeric(dlgInput(message = "Ingrese el costo por hora extra:")$res)
pago_ex <- hora_ex*cos_ex
}
pago_n<- horas*cohoras
pago_to<- pago_n+pago_ex
dlg_message(paste("El pago total es:", pago_to, "$"))horas almacena las horas trabajadas ingresadas mediante
cuadro de diálogo, convertidas a número. cohoras guarda el
costo por hora trabajada. extra almacena la respuesta del
usuario sobre si tiene horas extras (“si” o “no”), convertida a
minúsculas. pago_ex inicializada en 0; guardará el valor
total de horas extras si existen. hora_ex captura la
cantidad de horas extras trabajadas (solo si extra == “si”).
cos_ex guarda el costo por cada hora extra.
pago_n contiene el pago normal (horas * costo por hora).
pago_to pago total resultante de sumar el pago normal y el
de horas extras.
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
#ingresamos a la libreria svidialogs para poder desplazar cuadros de dialogo
library(svDialogs)
#Asignamos a una variable el numero que el usuario va a ingresar
n <- as.numeric(dlgInput(message = "Ingrese un numero:")$res)
#Usamos el comando "for" para recorrer los valores desde 1 hasta n y calculamos la suma
for (a in 1:n)
{x <- (a*(a+1))/2 }
#Imprimimos el resultado
print(x)n Almancena el numero ingresado ppr el usuario y
dictamina el valor hasta el que se repetira el ciclo for a
Toma los valores de 1 hasta n , ademas de usarse para calcular la suma
de todos los valores hasta n x Guarda el resultado de la
suma ## Funciones de R utilizadas 1. library(svDialogs) Carga
la librería svDialogs, necesaria para mostrar ventanas emergentes de
entrada y mensajes. 2. dlgInput(message = …) Muestra un cuadro
de diálogo donde el usuario escribe un valor. Retorna una lista cuyo
elemento $res contiene lo ingresado. 3. dlg_message(…) Muestra
un cuadro emergente con un mensaje para el usuario. 4.
as.numeric(…) Convierte los datos ingresados (que llegan como
texto) a valores numéricos. 5. for (variable /in/ vector) {}
Estructura que repite instrucciones para cada valor del vector
especificado. 6 print(variable) Muestra en la consola el valor
o expresión indicada dentro del paréntesis.
Escribir un programa que pida al usuario su peso (en kg) y estatura
(en metros), calcule el índice de masa corporal y lo almacene en una
variable, y muestre por pantalla la frase Tu índice de masa corporal es
#ingresamos a la libreria svidialogs para poder desplazar cuadros de dialogo
library(svDialogs)
#Solicitamos al usuario que ingrese su peso en kg
peso<- as.numeric(dlgInput(message = "Ingrese su peso(kg):")$res)
#Solicitamos al usuario que ingrese su altura en metros
estatura <- as.numeric(dlgInput( message = "Ingrese su estaturura(metros):")$res)
# Calcular el imc usando la fórmula "peso / (estatura^2)"
imc <- peso/(estatura*estatura)
# Redondeamos el valor del imc a dos decimales
imc <- round(imc,2)
#imprimimos el imc
print(paste("Tu indice de masa corporal es: ",imc))## [1] "Tu indice de masa corporal es: NA"peso Almacena el valor ingresado por el usuario que
corresponde a su peso en kg. estatura Almacena el valor
ingresado por el usuario que corresponde a su estatura en metros
imc Contiene el resultado del indice de masa corporal ##
Funciones de R utilizadas 1. library(svDialogs) Carga la
librería svDialogs, necesaria para mostrar ventanas emergentes de
entrada y mensajes. 2. dlgInput(message = …) Muestra un cuadro
de diálogo donde el usuario escribe un valor. Retorna una lista cuyo
elemento $res contiene lo ingresado. 3. dlg_message(…) Muestra
un cuadro emergente con un mensaje para el usuario. 4.
as.numeric(…) Convierte los datos ingresados (que llegan como
texto) a valores numéricos. 5 . round(valor, n) Redondea un
número a n decimales, permitiendo presentar el resultado con la
precisión requerida. 6. Operación algebraica Realiza un cálculo
que combina valores numéricos mediante reglas matemáticas, como sumas,
restas, productos, divisiones o potencias.
Escribir un programa que pregunte al usuario una cantidad a invertir, el interés anual y el número de años, y muestre por pantalla el capital obtenido en la inversión
# Instalamos el paquete que nos servira para crear ventanas emergentes (solo si es la primera vez que lo vamos a usarlo)
if (!require("svDialogs")) install.packages("svDialogs")
library(svDialogs) # Cargamos el paquete
cantidad <- as.numeric(dlgInput(message = "Introduce la cantidad a invertir:")$res)
interes <- as.numeric(dlgInput(message = "Introduce el interés anual (%):",)$res)
anio <- as.numeric(dlgInput(message = "Introduce el número de años:",)$res)
if (!is.na(cantidad) && !is.na(interes) && !is.na(anio)) { #Si El uSUARIO cancela la operacion, el resultado seria NA
capital_final <- cantidad * (1 + (interes / 100)) ^ anio
capital_final <- round(capital_final, 2)
#Mostramos el resultado
mensaje <- paste("El capital obtenido después de", anio,
"años será de:", capital_final)
dlgMessage(message = mensaje, type = "ok")
} else{
dlgMessage(message = "Operación cancelada o datos inválidos", type = "ok")
}cantidad (Numérico): Representa el capital inicial
(\(C_i\)). Es la base sobre la que se
calculan los intereses.anio (Numérico/Entero): El tiempo (\(t\)) que durará la inversión. Es el
exponente en la fórmula.capital (Numérico): La variable de salida que almacena
el resultado matemático de la operación.require("svDialogs"): Intenta cargar el paquete
svDialogs. A diferencia de library, si no
encuentra el paquete devuelve FALSE (falso) en lugar de un
error. Esto nos permite detectar si falta el paquete para instalarlo
automáticamente.install.packages("svDialogs"): Descarga e instala el
paquete desde Internet. Solo se ejecuta si require devolvió
falso.library(svDialogs): Carga el paquete en la memoria de R
para que podamos usar sus funciones (dlgInput, etc.)dlgInput(...)$res: Abre una ventana emergente donde el
usuario puede escribir. El ...$res al final sirve para
capturar exactamente lo que el usuario escribió en la caja de
texto.as.numeric(...): Convierte el texto que recibimos de la
ventana (por ejemplo si el usuario ingresa “1000”) en un número real
(1000). Esto es fundamental, ya que si no lo hacemos, R no podrá
realizar multiplicaciones ni potencias porque el dato estaria en
texto.is.na(...): Significa “Is Not Available” (¿Es
inválido?). Verifica si la variable está vacía. Esto ocurre si el
usuario pulsa “Cancelar” en la ventana o lo deja en blanco. El
if (!is.na(...)) se lee: “Si el valor NO es inválido,
entonces continúa”.paste(...): Crea una sola cadena de texto uniendo
varias partes (texto fijo y variables). Se usa para construir la frase
final del resultado.dlgMessage(..., type = "ok"): Muestra una ventana
emergente informativa con el resultado final y un botón de
“Aceptar”.Realizar un programa que pida el tiempo ya sea en horas, minutos o segundos, luego indicar en qué tipo de tiempo desea transformar y luego presentar el resultado.
if (!require("svDialogs")) install.packages("svDialogs")
library(svDialogs)
# Creamos una función necesaria para que este bloque sea independiente
Fconvertirt <- function(valor, valor1, valor2) {
segundos <- 0
# Usamos la funcion if para normalizar a segundos
if (valor1 == "horas") {
segundos <- valor * 3600
} else if (valor1 == "minutos") {
segundos <- valor * 60
} else if (valor1 == "segundos") {
segundos <- valor
} else {
return(NA)
}
# Convertimos
resultado <- 0
if (valor2 == "horas") {
resultado <- segundos / 3600
} else if (valor2 == "minutos") {
resultado <- segundos / 60
} else if (valor2 == "segundos") {
resultado <- segundos
} else {
return(NA)
}
return(resultado)
}
# Aca acabamos la funcion
# 1. Pedimos el primer valor
valor_usuario <- as.numeric(dlgInput(message = "Introdusca la cantidad de tiempo:")$res)
# Mandamos las opciones disponibles
opciones <- c("horas", "minutos", "segundos")
unidad1 <- dlgList(choices = opciones,
title = "Selecciona la unidad de ORIGEN:")$res
unidad2 <- dlgList(choices = opciones,
title = "Selecciona la unidad de DESTINO:")$res
# 3. Calcular y Mostrar (Verificando que no haya cancelado nada)
if (!is.na(valor_usuario) && length(unidad1) > 0 && length(unidad2) > 0) {
# Llamamos a la función
res_user <- convertir_tiempo(valor_usuario, unidad1, unidad2)
if (!is.na(res_user)) {
msg <- paste(valor_usuario, unidad1, "equivalen a", res_user, unidad2)
dlgMessage(message = msg, type = "ok")
} else {
dlgMessage(message = "Error en las unidades seleccionadas.", type = "ok")
}
} else {
dlgMessage("Operación cancelada o datos incompletos", type = "ok")
}valor_usuario: Almacena el número que ingresa el
usuario al inicio por ejemplo 50. Se convierte a numérico para poder
calcular.
opciones: Es un vector que guarda las tres palabras
clave: “horas”, “minutos”, “segundos”. Que se usaan para llenar los
menús desplegables.
unidad1: Guarda la opción de origen que el usuario
eligió de la lista.
unidad2 : Guarda la opción de destino que el usuario
eligió.
res_user: Almacena el resultado final del cálculo
que devuelve la función Fconvertirt.
msg: Variable de texto donde construimos la frase
final (“50 minutos equivalen a…”) para mostrarla en la ventana.
Fconvertirt:valor, valor1, valor2: Son los
nombres internos que reciben los datos que enviamos
(valor_usuario, unidad1,
unidad2).
segundos: Variable temporal para hacer el cálculo
intermedio.
resultado: Variable final que la función devuelve.
c(...): Función “Combinar”. Crea un vector o lista
de elementos. Se usa en c(“horas”, “minutos”, “segundos”).
dlgList(choices = ..., title = ...)$res:
choices = opciones: Le dice que use tu variable opciones
para mostrar la lista.$res: Captura la selección que hizo el usuario.3.length(...): Cuenta cuántos elementos hay. Se usa en
length(unidad1) > 0 para comprobar si el usuario
realmente seleccionó algo. Si el usuario cierra la ventana sin elegir,
el largo es 0.
4.as.numeric(...), dlgInput(...),
paste(...), dlgMessage(...): Funcionan igual
que en el ejercicio anterior (convertir a número, pedir texto, pegar
texto y mostrar mensaje).
Escribir un programa en el que se digiten varios números y luego los números se presenten en pantalla ordenados
cat("¿Cuántos números desea ingresar? ")## ¿Cuántos números desea ingresar?num_ingresado <- as.numeric(readline())if (is.na(num_ingresado) || num_ingresado <= 0) {
cat("Error: Debe ingresar un número válido")
} else {
numeros <- numeric(num_ingresado)
for (i in 1:num_ingresado) {
cat("Número", i, ": ")
numeros[i] <- as.numeric(readline())}
cat("Números ordenados:", sort(numeros))
}## Error: Debe ingresar un número válidoEscribir un programa que calcule el factorial de un número que ha sido digitado por el usuario
cat("Ingrese un número positivo: ")## Ingrese un número positivo:num<-readline()n <- as.integer(num)
cat("El factorial de", n, "es:", factorial(n))## El factorial de NA es: NAEl problema planteado es encontrar un numero n1 ingresado por el usuario y verificar que es un numero primo. Esto se logra por la propiedad de los numeros primos, los cuales solo tiene 2 divisores exactos el 1 y si mismos.
n1 <- as.integer(readline("Ingresa un número a tu gusto: "))
if (is.na(n1)) {
stop("Error: Debe ingresar un número válido.")
}
div <- 0
for (i in 1:n1) {
if (n1 %% i == 0) {
div <- div + 1
}
}
if (div == 2) {
print(paste("El número", n1, "es primo!"))
} else {
print(paste("El número", n1, "no es primo!"))
}
n1: almacena el número ingresado por el usuario,
convertido a entero mediante as.integer(). div: contador de
divisores del número; inicia en 0 y aumenta cuando se encuentra un
divisor. i: variable del ciclo for, que toma valores desde
1 hasta n1.
1.readline(prompt = "...")Solicita al usuario un valor
ingresado desde la consola. 2.as.integer(...).Convierte el
valor ingresado (que llega como texto) a un número entero.
3.for (i in 1:n1).Crea un ciclo repetitivo que recorre los
valores desde 1 hasta el número ingresado por el usuario.
4.if (...) { } else { } Estructura condicional que permite
decidir entre dos opciones (primo o no primo).
5.%% (módulo).Operador que devuelve el residuo de una
división. Si n1 %% i == 0, significa que i divide a n1 sin residuo.
6.print(...) Muestra el mensaje final indicando si el
número es primo o no. 7.paste(..).Permite unir texto y
variables en una sola cadena para imprimirla ordenadamente.
De manera similar al anterior, ahora se pide que el numero ingresado
por el usuario n2 sea un numero par. Se logra cumpliendo la
propiedad de que los numeros pares son exactamente divisibles para
2.
n2 <- as.integer(readline("Ingresa un nùmero a tu gusto:"))
if (n2 %% 2 == 0) {
print(paste ("El numero", n2, "es par!"))
}else{
print(paste ("El numero", n2, "no es par!"))
}
n2: variable que almacena el número ingresado por el
usuario, convertido a entero mediante as.integer().
1.readline(prompt = “…”) Captura un dato ingresado por el usuario desde la consola. 2.as.integer(…) Convierte el dato ingresado —que llega como cadena de texto— a un número entero. 3.%% (operador módulo) Devuelve el residuo de la división de un número entre otro. Se utiliza para determinar si el número es divisible entre 2. 4.if (…) { } else { } Estructura condicional que permite decidir entre dos opciones: par o impar. 5.print(…) Muestra en pantalla el resultado final. 6.paste(…) Combina texto y variables en un solo mensaje para imprimirlos juntos.
El desarrollo de los programas permitió comprender la importancia del uso adecuado de los tipos de datos en R, ya que cada ejercicio dependió de identificar correctamente si los valores ingresados eran numéricos, enteros o cadenas de texto
Los ejercicios realizados facilitaron el aprendizaje del razonamiento lógico y del uso de estructuras fundamentales como ciclos, condicionales y operadores, herramientas esenciales para resolver problemas cotidianos mediante código.
1.Se recomienda validar siempre los datos ingresados por el usuario, ya que evitar valores incorrectos o vacíos garantiza que el programa funcione sin errores. Implementar verificaciones con is.na() o imponer rangos de entrada puede ayudar a evitar fallos comunes durante la ejecución.