Informe: Ejercicios Práctivos y Uso de RPUBS

Objetivo Específico

Desarrollar programas en R que permitan aplicar estructuras de entrada de datos, condicionales, ciclos y operaciones aritméticas para resolver problemas básicos como conversiones de unidades, con el fin de fortalecer las habilidades prácticas en

EJERCICIO 1:

Planteamiento del Problema:

Se desea crear un programa en R que permita convertir temperaturas entre grados Celsius (°C) y Fahrenheit (°F). El usuario debe ingresar: 1.El valor de la temperatura. 2.La unidad en la que dicha temperatura está expresada (“C” o “F”).

El programa debe:

Convertir la temperatura a la unidad contraria.
Mostrar el resultado mediante un cuadro de diálogo.
En caso de que el usuario ingrese una unidad no válida, mostrar un mensaje de error.

library(svDialogs)

## Warning: package 'svDialogs' was built under R version 4.5.2

temp <- as.numeric(dlgInput("Ingrese la temperatura")$res)
unidad <- dlgInput("Ingrese la unidad: C para Celsius, F para Fahrenheit")$res

if (unidad == "F") {
  cal <- (temp - 32) * 5/9
  dlg_message(paste("Su temperatura es", cal, "°"))
  
} else if (unidad == "C") {
  cal <- (temp * 9/5) + 32
  dlg_message(paste("Su temperatura es", cal, "°"))
  
} else {
  dlg_message(paste("Unidad no válida. Debe ingresar 'C' o 'F'"))
}

Solución:
El programa solicita al usuario la temperatura y la unidad por medio de dlgInput(). Luego, mediante estructuras condicionales:

Si la unidad es F, convierte a Celsius usando:(F-32)*5/9

Si la unidad es C, convierte a Fahrenheit usando:(F*9/5)+32

Si se ingresa una unidad distinta, se muestra un mensaje indicando que es inválida.

diante un cuadro de diálogo.
En caso de que el usuario ingrese una unidad no válida, mostrar un mensaje de error.El programa finaliza mostrando el valor convertido mediante dlg_message().

EJERCICIO 2:

Planteamiento del Problema

Se requiere elaborar un programa en R que calcule el pago total de un trabajador. El programa debe solicitar:

1.El número total de horas trabajadas.

2.El costo por hora trabajada.

3.Si realizó horas extra (“S” o “N”). Si el trabajador realizó horas extra, también se debe ingresar:

-La cantidad de horas extra.

-El costo por hora extra. El objetivo es calcular el pago total, sumando pago normal + pago por horas extra (si existen).

horas <- as.numeric(dlgInput("Ingrese el total de horas trabajadas")$res)
costo <- as.numeric(dlgInput("Ingrese el costo por hora trabajada")$res)

ex <- toupper(dlgInput("¿Hizo horas extra? S/N")$res)

pago <- horas * costo

if (ex == "S") {
  hora_ex <- as.numeric(dlgInput("Ingrese el total de horas extras")$res)
  costo_ex <- as.numeric(dlgInput("Ingrese el costo por hora extra")$res)
  
  pago_ex <- hora_ex * costo_ex
  
  dlg_message(paste("Su pago total es:", pago + pago_ex))
  
} else if (ex == "N") {
  
  dlg_message(paste("Su pago es:", pago))
  
} else {
  
  dlg_message("Respuesta no válida. Debe ingresar S o N.")
}

Solución

El programa: 1.Solicita el número de horas trabajadas y el costo por hora.

2.Calcula el pago normal: pago=horas*costo

Pregunta si existe trabajo extra: Si la respuesta es S, se piden las horas extra y su costo correspondiente. El pago extra se calcula como:pago_ex=horas_ex*costo_ex

Nos muestra : pago total=pago+pago_ex Si la respuesta es N, solo se muestra el pago normal. Si la respuesta no es válida, se muestra un mensaje de error.

EJERCICIO 3:

Planteamiento del Problema

Desarrollar un programa en R que calcule la suma de los primeros n números enteros positivos, donde n es proporcionado por el usuario.

1.El usuario debe ingresar un número entero positivo. El programa debe: -Validar que sea un número entero y mayor a cero. -En caso contrario, mostrar un mensaje de error. -Si el número es correcto, calcular la suma desde 1 hasta n utilizando la fórmula:S=(n(n+1))/2

n <- as.numeric(dlgInput("Ingrese un número entero positivo")$res)

if (is.na(n) || n <= 0 || n %% 1 != 0) {
  dlg_message("Número incorrecto")
} else {
  suma <- (n * (n + 1)) / 2
  dlg_message(paste("La suma de todos los enteros desde 1 hasta", n, "es:", suma))
}

Solución

El programa solicita un número mediante dlgInput() y lo convierte a numérico. Luego realiza una validación:

Si el número es NA, negativo, cero o no entero, muestra: “Número incorrecto”.

Si el valor es correcto, calcula la suma

EJERCICIO 4:

Escribe un programa en R que solicite al usuario su peso en kilogramos y su estatura en metros, y que posteriormente calcule su Índice de Masa Corporal (IMC) utilizando la fórmula:

IMC=peso/estatura^2

El programa debe:

Pedir al usuario que ingrese su peso (kg) mediante una ventana de diálogo.
Pedir al usuario que ingrese su estatura (m) mediante una ventana de diálogo.
Convertir ambos valores a tipo numérico.
Calcular el IMC.
Mostrar al usuario el resultado del IMC redondeado a dos decimales usando una ventana emergente.

library(svDialogs)
# Pedir peso
peso <- dlg_input("Ingresa tu peso en kg:")$res
pesototal <- as.numeric(peso)

# Pedir estatura
estatura <- dlg_input("Ingresa tu estatura en metros:")$res
estaturatotal <- as.numeric(estatura)

# Calcular IMC
imc <- pesototal / (estaturatotal^2)

# Mostrar resultado
resultado <- paste("Tu índice de masa corporal es", round(imc, 2))
dlgMessage(resultado, type = "ok")

EJERCICIO 5:

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

Planteamiento:

Desarrolla un programa en R que permita calcular el capital final generado por una inversión sometida a interés compuesto anual.

El programa debe realizar lo siguiente:

1. Solicitar al usuario, mediante ventanas de diálogo:

El capital inicial a invertir.
La tasa de interés anual en porcentaje.
El número de años que durará la inversión.

2.Convertir los valores ingresados a tipo numérico.

3. Calcular el capital final utilizando la fórmula del interés compuesto:

Capital final: capital inicial * (1+ interés/100)años

Mostrar el resultado del capital obtenido, redondeado a dos decimales, mediante:

Un cuadro de diálogo, y la consola (usando cat()).

##capital
capital <- dlg_input("Ingresa la cantidad a invertir:")$res
capitalt <- as.numeric(capital)

##interes
interes <- dlg_input("Ingresa el interés anual (%):")$res
interest <- as.numeric(interes)

##anios
anios <- dlg_input("Ingresa el número de años:")$res
aniost <- as.numeric(anios)

# Calcular capital final
capital_final <- capitalt * (1 + interest/100)^aniost

# Mostrar mensaje final en cuadro de diálogo
dlgMessage(
  paste("El capital obtenido en la inversión es:", round(capital_final, 2)),
  type = "ok"
)

# Convertir el interés a decimal
interes_decimal <- interest / 100

# Calcular capital final
capital_final <- capitalt * (1 + interes_decimal)^aniost

# Mostrar resultado
cat("El capital obtenido es:", round(capital_final, 2))

## El capital obtenido es: NA

EJERCICIO 6:

Planteamiento del Problema

Realizar un programa en R que permita convertir un tiempo dado por el usuario entre horas, minutos y segundos. El usuario debe ingresar un valor numérico y especificar la unidad origen (horas, minutos o segundos) y la unidad destino. El programa debe validar los datos ingresados y en caso de error mostrar un mensaje. Si todo es correcto, debe convertir el tiempo según la unidad solicitada utilizando las equivalencias correspondientes.

library(svDialogs)

# Pedir valor de tiempo
valor <- as.numeric(dlgInput("Ingrese el valor de tiempo:")$res)
class(dlgInput)

## [1] "function"

# Preguntar en qué unidad está el valor
origen <- dlgInput("¿En qué unidad está el tiempo ingresado? (horas / minutos / segundos)")$res

# Preguntar a qué unidad desea convertir
destino <- dlgInput("¿A qué unidad desea convertir? (horas / minutos / segundos)")$res

resultado <- NA  # Variable para guardar el resultado

# Conversión
if (origen == "horas") {
  if (destino == "minutos") resultado <- valor * 60
  if (destino == "segundos") resultado <- valor * 3600
  if (destino == "horas") resultado <- valor
}

if (origen == "minutos") {
  if (destino == "horas") resultado <- valor / 60
  if (destino == "segundos") resultado <- valor * 60
  if (destino == "minutos") resultado <- valor
}

if (origen == "segundos") {
  if (destino == "horas") resultado <- valor / 3600
  if (destino == "minutos") resultado <- valor / 60
  if (destino == "segundos") resultado <- valor
}

# Mostrar resultado
dlgMessage(paste("El resultado es:", resultado, destino))

Solucion

El programa solicita un valor numérico y lo valida. Luego pregunta la unidad de origen y la unidad a la que se desea convertir. Si las unidades son válidas, convierte el tiempo usando como base los segundos. Finalmente muestra el resultado mediante dlg_message().

EJERCICIO 7:

Planteamiento del Problema

Desarrollar un programa en R que permita ingresar varios números separados por comas, validarlos y mostrarlos ordenados de menor a mayor.
Si el usuario ingresa un valor no numérico, el programa debe mostrar un mensaje de error.
Si los datos son correctos, se debe ordenar la lista de números y mostrar el resultado.

# Pedir los números al usuario
entrada <- dlgInput("Ingresa varios números separados por comas:")$res

# Convertir a vector numérico
numeros <- as.numeric(unlist(strsplit(entrada, ",")))

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

# Mostrar resultado
dlgMessage(paste("Los números ordenados son:", paste(numeros_ordenados, collapse = ", ")))

Solución

El programa solicita una lista de números separados por comas y la convierte en un vector numérico.
Si alguno de los datos no es un número, muestra un mensaje de error.
Si la entrada es válida, utiliza sort() para ordenar los valores y los presenta en pantalla con dlg_message().

EJERCICIO 8:

Planteamiento del Problema

Escribir un programa en R que calcule el factorial de un número entero positivo proporcionado por el usuario.
El programa debe validar que el número ingresado sea entero y no sea negativo.
Si la validación falla, debe mostrar un mensaje de error.
Si el valor es correcto, se debe calcular el factorial mediante un ciclo.

library(svDialogs)

# Pedir número al usuario
n <- as.numeric(dlgInput("Ingrese un número para calcular su factorial:")$res)

# Validar si el usuario ingresó un número válido
if (is.na(n) || n < 0) {
  dlgMessage("Por favor ingrese un número entero positivo.", type = "ok")
} else {
  # Calcular el factorial
  factorial_result <- 1
  if (n > 1) {
    for (i in 2:n) {
      factorial_result <- factorial_result * i
    }
  }
  
  # Mostrar resultado
  dlgMessage(paste("El factorial de", n, "es:", factorial_result), type = "ok")
}

Solución

El programa pide un número al usuario y verifica que sea entero positivo.
Si el valor no es válido, muestra un mensaje de error.
Si es correcto, calcula el factorial multiplicando todos los números desde 1 hasta n dentro de un ciclo for.
Al final muestra el resultado usando dlg_message().

EJERCICIO 9:

Planteamiento del Problema

Escribir un programa en R que pida un número entero positivo al usuario e indique si el número ingresado es primo o no.

Un número primo es aquel entero mayor que 1 que tiene exactamente dos divisores positivos distintos: él mismo y 1.

Secuencia de Código realizado en R

El código implementa una función optimizada para verificar la primalidad, buscando divisores solo hasta la raíz cuadrada del número.

library(svDialogs)
# 1. Pedir el número al usuario y convertirlo a entero
numero_primo <- as.integer(readline(prompt = "Escribe un número entero positivo para ver si es primo: "))

## Escribe un número entero positivo para ver si es primo:

# 2. Función de verificación
es_primo <- function(n) {
  # Caso especial: Números menores o iguales a 1 no son primos
  if (n <= 1) {
    return(FALSE)
  }
  
  # Caso especial: 2 es el único número par primo
  if (n == 2) {
    return(TRUE)
  }
  
  # Si es divisible por 2, no es primo (y ya verificamos el 2)
  if (n %% 2 == 0) {
    return(FALSE)
  }
  
  # Buscar divisores impares desde 3 hasta la raíz cuadrada de 'n'
  # El bucle va de 2 en 2 (solo revisa impares)
  i <- 3
  while (i * i <= n) {
    if (n %% i == 0) {
      return(FALSE) # Si encuentra un divisor, NO es primo
    }
    i <- i + 2
  }
  
  # Si el bucle termina sin encontrar divisores, ES primo
  return(TRUE)
}

# 3. Mostrar el resultado
if (is.na(numero_primo)) {
  cat("Entrada no válida.\n")
} else if (es_primo(numero_primo)) {
  cat(numero_primo, "es un número PRIMO.\n")
} else {
  cat(numero_primo, "NO es un número primo.\n")
}

## Entrada no válida.

Solución

La solución implementa una función auxiliar es_primo(n) para encapsular la lógica de verificación. Esta función maneja los casos especiales (1 y 2) y utiliza una optimización clave: solo verifica divisores impares desde 3 hasta la raíz cuadrada (\(\sqrt{n}\)) del número. Si un número no tiene divisores hasta su raíz cuadrada, no tendrá divisores mayores. La función utiliza el operador módulo (%%) para verificar la divisibilidad. El bloque final muestra el resultado en la consola.

EJERCICIO 10:

Planteamiento del Problema

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

Un número es par si es divisible por 2, resultando un residuo de 0. Es impar si el residuo de la división por 2 es 1 o -1.

Secuencia de Código realizado en R

El código utiliza la función readline() para pedir la entrada y el operador módulo (%%) para determinar la paridad.

# 1. Pedir el número al usuario y convertirlo a entero
numero_par_impar <- as.integer(readline(prompt = "Escribe un número entero para ver si es par o impar: "))

## Escribe un número entero para ver si es par o impar:

# 2. Verificar si la entrada es válida
if (is.na(numero_par_impar)) {
  cat("Entrada no válida.\n")
# 3. Usar el módulo para verificar la paridad
} else if (numero_par_impar %% 2 == 0) {
  # Si el residuo de dividir por 2 es 0, es PAR
  cat(numero_par_impar, "es un número PAR.\n")
} else {
  # Si el residuo de dividir por 2 es 1 (o -1), es IMPAR
  cat(numero_par_impar, "es un número IMPAR.\n")
}

## Entrada no válida.

Solución

El programa es directo y se basa en la definición matemática de paridad. Después de capturar la entrada como un entero, se realiza una validación básica con is.na(). La lógica principal reside en la verificación del residuo:

numero_par_impar %% 2 == 0: Esta expresión es verdadera si el número es par. El operador módulo (%%) devuelve el residuo de la división.

Si la condición anterior es falsa, el número es clasificado como impar.

El resultado se imprime directamente en la consola.

Informe: Ejercicios Práctivos y Uso de RPUBS

Universidad Central del Ecuador

Facultad de Ciencias Económicas

Carrera de Estadística

Jennifer Chicaiza

Melissa León

Evelyn Machay

Naidelin Tabango

Melany Tipanluisa

Quito - Ecuador, 2024

Introducción

Objetivo General

Objetivo Específico

Solución