UNIVERSIDAD CENTRAL DEL ECUADOR

FACULTAD DE CIENCIAS ECONÓMICAS

CARRERA DE INGENIERÍA EN ESTADÍSTICA

TERCER SEMESTRE

PROGRAMACIÓN

TALLER Nº4

TEMA: Mis primeros programas en R & Uso de tipo de datos.

GRUPO Nº7

Curso: EST S3 – 002

Docente: Ing. Francisco Valverde


Mis primeros programas


1. INTRODUCCIÓN.

Aprender un nuevo lenguaje de programación siempre representa un reto emocionante, especialmente cuando se trata de uno tan poderoso y versátil como R. Este lenguaje, ampliamente utilizado en estadística, análisis de datos y ciencia de datos, ofrece una gran variedad de herramientas que permiten explorar, transformar y visualizar datos de manera eficiente. En esta etapa inicial, realizar los primeros programas en R han sido una oportunidad para conocer su sintaxis, funciones básicas y entorno de trabajo. Este trabajo consta de 10 ejercicios prácticos, diseñados para poner en práctica los conceptos fundamentales del lenguaje. A través de estos ejercicios, se pudo descubrir el potencial de R como una herramienta fundamental para el análisis y la toma de decisiones basada en datos.



2. DESARROLLO.



1. Escribe un programa que solicite los catetos de un triángulo rectángulo y muestre su hipotenusa. El cálculo de la hipotenusa es: \[ \text{hipotenusa} = \sqrt{\text{cateto1}^2 + \text{cateto2}^2} \]

#Ingreso de los catetos:
#Solicitar al usuario que ingrese los dos catetos del triángulo rectángulo,
#y para lograrlo se utilizó la función readline().
#Esta función permite capturar lo que el usuario escribe por teclado.
cateto1 <- as.numeric(readline("Ingrese el Primer cateto: "))
## Ingrese el Primer cateto:
#Los datos ingresados por readline() son de tipo texto (caracteres), por lo cual,
#se utilizó as.numeric() para convertir esos valores a números reales (decimales),
#ya que se necesita porque se va a trabajar con operaciones matemáticas.
cateto2 <- as.numeric(readline("Ingrese el Segundo cateto: "))
## Ingrese el Segundo cateto:
#Calculo de la hipotenusa por Teorema de Pitagoras:
#Se aplicó el teorema de Pitágoras, que establece que la hipotenusa es igual a:
#la  raíz cuadrada de la suma de los cuadrados de los catetos.
#Esta operación se realizó con la función sqrt(),
#y las potencias se expresaron con el operador ^.
hipotenusa <- sqrt(cateto1^2 + cateto2^2)

# Muestra el resultado:
#Finalmente, se utilizó la función cat() para mostrar el resultado en pantalla,
#es decir, el resultado de la hipotenusa calculada.
cat("La hipotenusa es: ", hipotenusa)
## La hipotenusa es:  NA

2. Escribe un programa que calcule las soluciones de una ecuación de segundo grado de la forma ax² + bx + c = 0.

# Pedimos datos de A, B, C al usuario para usar la fórmula general

a <- as.numeric(readline("Ingrese el valor de A (no cero): "))
## Ingrese el valor de A (no cero):
b <- as.numeric(readline("Ingrese el valor de B: "))
## Ingrese el valor de B:
c <- as.numeric(readline("Ingrese el valor de C: "))
## Ingrese el valor de C:
# Verificamos que los datos sean válidos
if (is.na(a) || is.na(b) || is.na(c)) {
  cat("ERROR: Todos los valores deben ser numéricos.\n")
} else if (a == 0) {
  cat("ERROR: A no puede ser cero.\n")
} else {
  # Calculamos el discriminante
  d_raz <- b^2 - 4 * a * c
  
  if (d_raz < 0) {
    cat("ERROR: Las soluciones son números imaginarios.\n")
  } else {
    raiz <- sqrt(d_raz)
    respuesta_1 <- (-b + raiz) / (2 * a)
    respuesta_2 <- (-b - raiz) / (2 * a)
    
    cat("Respuesta 1:", respuesta_1, "\n")
    cat("Respuesta 2:", respuesta_2, "\n")
  }
}
## ERROR: Todos los valores deben ser numéricos.

3. Calcular el área del triángulo rectángulo dadas su base y altura.

#Ingreso de la Base:
#Este código calcula el área de un triángulo a partir de los valores:
#base y altura ingresados por el usuario. 
base <- as.numeric(readline(prompt = "Ingrese la base: "))
## Ingrese la base:
print(paste("Base: ", base, "\n"))
## [1] "Base:  NA \n"
altura <- as.numeric(readline(prompt = "Ingrese la altura: "))
## Ingrese la altura:
print(paste("Altura: ", altura, "\n"))
## [1] "Altura:  NA \n"
#Verificamos que no sean NA:
#Luego de recibir ambos valores, el programa verifica mediante una condición if
#que ninguno de ellos sea negativo,
#ya que no tendría sentido físico calcular un área con dimensiones negativas.
if (is.na(base) || is.na(altura)) {
  print("Por favor, ingrese valores numéricos válidos para base y altura.")
} else {
  #Usamos una condición para validar los valores
  if (base < 0 || altura < 0) {
    print("NO SERIA LOGICO TENER AREA NEGATIVA!", "\n")
  } else {
    #Hacemos la operación:
#Este ejercicio aplica la lectura de datos desde la consola,
#operadores lógicos y condicionales
#para validar la entrada del usuario antes de realizar el cálculo.
    area <- (base * altura) / 2
    print(paste("EL area del triangulo es: ", area, "\n"))
  }
}
## [1] "Por favor, ingrese valores numéricos válidos para base y altura."

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

#Este programa calcula el área y el perímetro de un rectángulo utilizando los valores de
#base y altura proporcionados por el usuario.
base <- as.numeric(readline("Ingrese la base: "))
## Ingrese la base:
print(paste("Base:", base))
## [1] "Base: NA"
altura <- as.numeric(readline("Ingrese la altura: "))
## Ingrese la altura:
print(paste("Altura:", altura))
## [1] "Altura: NA"
#USAMOS UNA CONDICION:
#Al igual que en el ejercicio anterior, se incluye una condición para asegurar que
#ambos valores sean positivos, ya que dimensiones negativas no son válidas en este contexto.
if (is.na(base) || is.na(altura)){
  print("ERROR: Debe ingresar valores numéricos válidos.")
} else if (base < 0 || altura < 0) {
  print("NO SERIA LOGICO TENER AREA NEGATIVA!")
} else {
  
#HACEMOS LA OPERACION:
#Silos datos ingresados son correctos, se realizan los siguientes cálculos:
#Área = base × altura
#Perímetro = 2 × (base + altura)
#Los resultados se muestran en pantalla.
#Este ejercicio refuerza el uso de estructuras condicionales,
#operaciones aritméticas y entrada/salida de datos en R
  area <- base * altura
  per <- 2 * (base + altura)
  print(paste("El área del rectángulo es:", area))
  print(paste("El perímetro del rectángulo es:", per))
}
## [1] "ERROR: Debe ingresar valores numéricos válidos."

5. Calcular el promedio de 3 notas que estén entre 0 y 20.

#USAMOS LA LIBRERIA svDialogs:
#este programa solicita al usuario tres notas utilizando cuadros de diálogo interactivos,
#gracias a la librería svDialogs, y luego calcula el promedio de estas notas
#si todas están dentro del rango válido de 0 a 20.

library(svDialogs)
#USAMOS NUMEROS ALEATORIOS PARA LAS 3 NOTAS:
#Primero, se piden las tres notas una por una.
nt_1 <- as.numeric(dlg_input(message = "Ingrese la primer nota")$res)
nt_2 <- as.numeric(dlg_input(message = "Ingrese la segunda nota")$res)
nt_3 <- as.numeric(dlg_input(message = "Ingrese la tercer nota")$res)

#Luego, el programa evalúa si las tres están dentro del rango permitido.
#Si todas son válidas, se calcula la suma y el promedio,
#y se muestra el resultado en ventanas emergentes.

if (any(is.na(c(nt_1, nt_2, nt_3)))) {
  dlg_message("ERROR: Debe ingresar valores numéricos válidos para todas las notas.")
} else if ((nt_1 >= 0 & nt_1 <= 20) & (nt_2 >= 0 & nt_2 <= 20) & (nt_3 >= 0 & nt_3 <= 20)) {
  
#CALCULAMOS LA SUMA:
  suma <- nt_1 + nt_2 + nt_3
  
#CALCULAMOS EL PROMEDIO:
#Si alguna nota está fuera del rango,
#se muestra un mensaje indicando que no se puede realizar el cálculo.
  promedio <- suma / 3
  dlg_message(paste("Nota 1:", nt_1))
  dlg_message(paste("Nota 2:", nt_2))
  dlg_message(paste("Nota 3:", nt_3))
  dlg_message(paste("El promedio de las 3 notas es:", promedio))

#Este ejercicio permite poner en práctica el uso de interfaces gráficas simples en R,
#validación de rangos y cálculo de promedios.
#También introduce al usuario a la interacción mediante diálogos más amigables.
} else {
  dlg_message("No se puede sacar el promedio con notas que estén fuera de 0 y 20.")
}

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

#Este programa calcula el área y el perímetro de un círculo
#a partir del valor del radio ingresado por el usuario.

#Ingrese el radio:
#Primero, se verifica que el valor ingresado sea mayor que cero,
#ya que un radio negativo o nulo no tiene sentido en una figura geométrica.

radio <- as.numeric(readline(prompt = "INGRESE EL RADIO QUE DESEA CALCULAR: "))
## INGRESE EL RADIO QUE DESEA CALCULAR:
if (is.na(radio)) {
  print("ERROR: Debe ingresar un valor numérico válido.")
} else if (radio <= 0) {
  print("NO SE PUEDE CALCULAR CON RADIO MENOR O IGUAL A CERO")
} else {
  
#Si el valor es válido, se realizan los siguientes cálculos:
#Área = pi × radio²
#Perímetro (circunferencia) = 2 × pi × radio

  area6 <- pi * radio^2
  perimetro6 <- 2 * pi * radio
  
#Los resultados se muestran utilizando la función cat(),
#que imprime los valores directamente en la consola de forma más limpia.
  cat("ÁREA:", area6, "\n")
  cat("PERÍMETRO:", perimetro6, "\n")
}
## [1] "ERROR: Debe ingresar un valor numérico válido."

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

#Este programa calcula el área y el perímetro de un trapecio,
#a partir de los valores ingresados por el usuario:
#base mayor (B), base menor (b), altura (h) y los dos lados no paralelos (L1 y L2).
B <- as.numeric(readline("INGRESE LA BASE MAYOR: "))
## INGRESE LA BASE MAYOR:
b <- as.numeric(readline("INGRESE LA BASE MENOR: "))
## INGRESE LA BASE MENOR:
h <- as.numeric(readline("INGRESE LA ALTURA: "))
## INGRESE LA ALTURA:
L1 <- as.numeric(readline("INGRESE EL LADO 1: "))
## INGRESE EL LADO 1:
L2 <- as.numeric(readline("INGRESE EL LADO 2: "))
## INGRESE EL LADO 2:
#Primero, se validan los datos ingresados, asegurando que todos los valores sean positivos,
#ya que no tendría sentido trabajar con medidas negativas en geometría.

#Luego, se realizan los siguientes cálculos:


if (any(is.na(c(B, b, h, L1, L2)))) {
  print("ERROR: Debe ingresar solo valores numéricos válidos.")
} else if (B <= 0) {
  print("LA BASE MAYOR DEBE SER POSITIVA")
} else if (b <= 0) {
  print("LA BASE MENOR DEBE SER POSITIVA")
} else if (h <= 0) {
  print("LA ALTURA DEBE SER POSITIVA")
} else if (L1 <= 0) {
  print("EL LADO 1 DEBE SER POSITIVO")
} else if (L2 <= 0) {
  print("EL LADO 2 DEBE SER POSITIVO")
} else {
  
#Área = ((B + b) × h) / 2
  area7 <- ((B + b) * h) / 2

#Perímetro = B + b + L1 + L2  
  perimetro7 <- B + b + L1 + L2
  
  
#Los resultados se muestran en consola utilizando la función cat().
#Este ejercicio integra el uso de condiciones múltiples (if/else if),
#validación de entradas,
#y el manejo de varias variables para el cálculo de fórmulas geométricas más complejas.
  
  cat("EL ÁREA DEL TRAPECIO ES:", area7)
  cat("EL PERÍMETRO DEL TRAPECIO ES:", perimetro7)
}
## [1] "ERROR: Debe ingresar solo valores numéricos válidos."

8. Dados dos números, determinar cuál es el número mayor y cuál es el número menor. Si los dos números son semejantes, el mensaje debe decir que son números iguales.

#Este programa permite comparar dos números ingresados por el usuario para determinar
#cuál es mayor, cuál es menor o si ambos son iguales.

#Ingreso de los numeros:
num1 <- as.numeric(readline("INGRESE EL PRIMER NÚMERO: "))
## INGRESE EL PRIMER NÚMERO:
num2 <- as.numeric(readline("INGRESE EL SEGUNDO NÚMERO: "))
## INGRESE EL SEGUNDO NÚMERO:
#Uso de condicional:
#Utiliza estructuras condicionales if, else if y else para hacer la comparación:
#Si el primer número es mayor que el segundo, se informa cuál es el mayor y cuál el menor.

if (is.na(num1) || is.na(num2)) {
  cat("ERROR: Debe ingresar solo números válidos.\n")
} else if (num1 > num2) {
  cat("EL MAYOR ES:", num1, "\n")
  cat("EL MENOR ES:", num2, "\n")
} else if (num2 > num1) {
  cat("EL MAYOR ES:", num2, "\n")
  cat("EL MENOR ES:", num1, "\n")
} else {
  cat("LOS NÚMEROS SON IGUALES\n")
  cat(num1, " = ", num2, "\n")
}
## ERROR: Debe ingresar solo números válidos.
#Este ejercicio permite practicar la lectura de datos, el uso de operadores de comparación,
#y el manejo de condiciones múltiples para mostrar distintos mensajes los valores ingresados.

9. Escribe un programa que lea dos números y muestre en la salida su suma, resta, multiplicación y división.

#este programa solicita al usuario dos números y luego muestra en pantalla los resultados:
#suma, resta, multiplicación y división.

#Ingreso de los numeros:
n1<-as.numeric(readline("INGRESE EL PRIMER NÚMERO: "))
## INGRESE EL PRIMER NÚMERO:
n2<-as.numeric(readline("INGRESE EL SEGUNDO NÚMERO: "))
## INGRESE EL SEGUNDO NÚMERO:
#Uso condicional:
#Antes de realizar los cálculos, el programa verifica si el segundo número es igual a cero.
#En ese caso, muestra un mensaje indicando que no es posible realizar una división entre cero,
#ya que no está definida matemáticamente.
if (is.na(n1) || is.na(n2)) {
  print("NO EXISTE DIVISION PARA CERO")
} else {
  
#Los resultados se muestran de forma ordenada usando cat(). Este ejercicio refuerza
#el uso de operadores aritméticos, estructuras condicionales
#y la presentación clara de resultados.
cat("LA SUMA DE LOS NúMEROs ES: ", n1+n2,"\n")
  cat("LA RESTA DE LOS NúMEROs ES: ", n1-n2,"\n")
  cat("LA MULTIPLICACIóN DE LOS NúMERO ES: ", n1*n2,"\n")
  cat("LA DIVISIóN DE LOS NúMERO ES: ", n1/n2,"\n")
}
## [1] "NO EXISTE DIVISION PARA CERO"

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

#Este programa solicita al usuario una cantidad en dólares y calcula el IVA (12%),
#además del valor total a pagar con impuesto incluido.

#Primero, verifica que el monto ingresado sea mayor a cero,
#ya que no tendría sentido aplicar impuestos a valores nulos o negativos.
monto <- as.numeric(readline("INGRESE LA CANTIDAD EN DÓLARES: "))
## INGRESE LA CANTIDAD EN DÓLARES:
if (is.na(monto)) {
  cat("ERROR: Debe ingresar un número válido.\n")
} else if (monto <= 0) {
  cat("EL MONTO DEBE SER MAYOR A CERO\n")
} else {

#Calcula el IVA como el 12% del monto ingresado.
  iva <- monto * 0.12
  
#Suma el IVA al monto original para obtener el total a pagar.
  total <- monto + iva
  
#muestra los resultados usando cat(), incluye una presentación del cálculo realizado.
  cat("EL (12%) DEL IVA ES: $", round(iva, 2), "\n")
  cat("$", monto, "+", "$", iva, "=", "$", total, "\n")
  cat("EL TOTAL A PAGAR ES: $", round(total, 2), "\n")
}
## ERROR: Debe ingresar un número válido.
#Este ejercicio combina entrada de datos, operaciones matemáticas con porcentajes,
#validación condicional,
#y formato de salida redondeando valores a dos decimales para una presentación adecuada.

3. CONCLUSIÓN.

En conclusión, estos primeros diez ejercicios permiten al estudiante de R comprender los fundamentos de la programación en este lenguaje. Se han aplicado conceptos esenciales como la lectura de datos, condiciones, operaciones matemáticas, validaciones y uso de librerías básicas. Este tipo de prácticas contribuye significativamente a desarrollar lógica computacional y a ganar confianza para enfrentar retos más avanzados en el uso de R para estadística, ciencia de datos y otros campos.


Uso de tipo de datos


1. INTRODUCCIÓN.

Aprender a resolver problemas mediante la programación es una habilidad fundamental en el mundo actual, especialmente cuando se utilizan herramientas tan potentes como R. Este lenguaje, ampliamente empleado en estadística, análisis de datos y ciencia de datos, brinda una plataforma flexible y eficiente para crear soluciones prácticas a partir de grandes volúmenes de información. El presente trabajo consiste en la realización de diez ejercicios prácticos en R, abordando distintos planteamientos que requieren el análisis, la codificación y la ejecución correcta de soluciones. Cada ejercicio incluye el desarrollo del problema, la presentación del código escrito, la evidencia de funcionamiento mediante capturas de pantalla y la organización de los scripts individuales. Este proyecto no solo permite afianzar los conocimientos adquiridos en la sintaxis y estructuras básicas de R, sino también fortalecer habilidades de documentación, organización de proyectos y manejo de herramientas de programación, contribuyendo así a una formación integral en el área del análisis de datos.



2. DESARROLLO.



1. 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.

#El programa es solicitar al usuario ingresar una temperatura
#y seleccionar la unidad de medida deseada
#("F" para Fahrenheit o "C" para Celsius).

#INGRESE LA TEMPERATURA:
temp <- as.numeric(readline("Ingrese un número (Temperatura) : "))
## Ingrese un número (Temperatura) :
#Según la opción elegida, el código convierte la temperatura ingresada a la unidad opuesta
#utilizando las fórmulas de conversión correspondientes:

unidad <- readline("Escriba F si desea en Fahrenheit o C si desea en Celsius : ")
## Escriba F si desea en Fahrenheit o C si desea en Celsius :
if (unidad == "F"){

#Finalmente, muestra en pantalla la temperatura original, su unidad y el valor convertido,
#redondeado a dos decimales para mayor claridad:
cat("Temperatura ingresada:",temp,"°",unidad, " ","Es igual a",round((temp - 32) * 5 / 9,2),"°", "C\n")
} else {
cat("Temperatura ingresada:",temp,"°",unidad, " ","Es igual a",round((temp * 9 / 5) + 32,2),"°", "F\n")
}
## Temperatura ingresada: NA °    Es igual a NA ° F

2. 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.

#Es un programa que calcula el pago total de un trabajador según las horas laboradas.

#Ingrese el número de horas:
#Primero, solicita al usuario ingresar el número de horas trabajadas y el valor por hora.
horas <- as.numeric(readline("Ingresa las horas trabajadas: "))
## Ingresa las horas trabajadas:
coste <- as.numeric(readline("Ingresa el valor por hora: "))
## Ingresa el valor por hora:
extra <- readline("¿Tienes horas extras trabajadas? (si/no): ")
## ¿Tienes horas extras trabajadas? (si/no):
#Luego pregunta si el trabajador tiene horas extras. Si la respuesta es afirmativa,
#se solicitan las horas extras trabajadas y el valor por hora extra, sumando ambos pagos.
if (extra == "si") {
horas_extra <- as.numeric(readline("Ingresa las horas extras: "))
coste_extra <- as.numeric(readline("Ingresa el valor por hora extra: "))
pago <- (horas * coste) + (horas_extra * coste_extra)
} else {
pago <- horas * coste
}

#Si no hay horas extras, el pago se calcula solo con las horas normales.
#Finalmente, el programa muestra el total a pagar, redondeado a dos decimales.
cat("El total a pagar es: $", round(pago, 2), "\n")
## El total a pagar es: $ NA

3. 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 6 suma de los n primeros enteros positivos puede ser calculada de la siguiente forma: \[ \text{suma} = \frac{n(n + 1)}{2} \]

#Este código calcula la suma de los primeros n números enteros positivos.

#Primero, solicita al usuario ingresar un número entero positivo n:
n <- as.numeric(readline("Ingresa un número entero positivo: "))
## Ingresa un número entero positivo:
#Luego, utiliza la fórmula matemática n(n+1)/2
#para calcular la suma de los primeros n números naturales.

suma <- (n * (n + 1)) / 2

#Finalmente, muestra el resultado de la suma en pantalla.
cat("La suma de los primeros", n, "números es:", suma, "\n")
## La suma de los primeros NA números es: NA

4. 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 donde es el índice de masa corporal calculado redondeado con dos decimales.

El índice de masa corporal (IMC) se calcula usando la fórmula:

\[ \mathrm{IMC} = \frac{\mathrm{peso \ (kg)}}{\mathrm{altura \ (m)}^2} \]

#Este programa calcula el Índice de Masa Corporal (IMC) de una persona.

#Primero, solicita al usuario que ingrese su peso en kilogramos y su estatura en metros:

#Luego, calcula el IMC utilizando la fórmula estándar:
peso <- as.numeric(readline("Introduce tu peso en kilogramos: "))
## Introduce tu peso en kilogramos:
estatura <- as.numeric(readline("Introduce tu estatura en metros: "))
## Introduce tu estatura en metros:
#imc <- peso / (altura^2):
imc <- peso / (estatura^2)

#Finalmente, el programa muestra el valor del IMC en pantalla.
#Este índice es utilizado para evaluar si el peso de una persona es saludable
#en relación con su estatura.
cat("Tu índice de masa corporal es", imc, "\n")
## Tu índice de masa corporal es NA

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.

La fórmula del interés compuesto es:

\[ \text{Capital Final} = \text{Cantidad Invertida} \times \left(1 + \frac{\text{Interés Anual}}{100}\right)^{\text{Número de Años}} \]

#Solicitar al usuario la cantidad a invertir
cantidad_invertir <- as.numeric(readline(prompt = "Ingrese la cantidad a invertir: "))
## 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
## Ingrese el interés anual (en porcentaje):
#Solicitar al usuario el número de años
num_anos <- as.numeric(readline(prompt = "Ingrese el número de años: "))
## Ingrese el número de años:
#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")
## 
## El capital obtenido después de NA años es NA

6. 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.

#Este programa permite convertir unidades de tiempo (horas, minutos, segundos)
#a otras unidades de tiempo seleccionadas por el usuario.

#Función para pedir tiempo y realizar la conversión:
convertir_tiempo <- function() {
#Solicitar al usuario el tipo de tiempo
cat("Ingrese el tiempo:\n")
tiempo <- as.numeric(readline("Tiempo: "))
cat("¿Qué unidad es? (1) Horas (2) Minutos (3) Segundos\n")
unidad_origen <- as.integer(readline("Ingrese el número de la unidad de origen: "))
cat("¿A qué unidad desea convertir? (1) Horas (2) Minutos (3) Segundos\n")
unidad_destino <- as.integer(readline("Ingrese el número de la unidad de destino: "))
#Conversión según la unidad de origen y la unidad de destino
 if (is.na(tiempo) || tiempo < 0) {
    cat("Tiempo inválido. Intente nuevamente.\n")
    return()
  }
  
  cat("¿Qué unidad es? (1) Horas (2) Minutos (3) Segundos\n")
  unidad_origen <- as.integer(readline("Ingrese el número de la unidad de origen: "))
  
  if (is.na(unidad_origen) || !(unidad_origen %in% 1:3)) {
    cat("Unidad de origen inválida.\n")
    return()
  }
  
  cat("¿A qué unidad desea convertir? (1) Horas (2) Minutos (3) Segundos\n")
  unidad_destino <- as.integer(readline("Ingrese el número de la unidad de destino: "))
  
  if (is.na(unidad_destino) || !(unidad_destino %in% 1:3)) {
    cat("Unidad de destino inválida.\n")
    return()
  }

  # Conversión
  if (unidad_origen == 1) { # Horas
    if (unidad_destino == 1) {
      resultado <- tiempo
    } else if (unidad_destino == 2) {
      resultado <- tiempo * 60
    } else {
      resultado <- tiempo * 3600
    }
  } else if (unidad_origen == 2) { # Minutos
    if (unidad_destino == 1) {
      resultado <- tiempo / 60
    } else if (unidad_destino == 2) {
      resultado <- tiempo
    } else {
      resultado <- tiempo * 60
    }
  } else { # Segundos
    if (unidad_destino == 1) {
      resultado <- tiempo / 3600
    } else if (unidad_destino == 2) {
      resultado <- tiempo / 60
    } else {
      resultado <- tiempo
    }
  }
#Mostrar el resultado
cat("El tiempo convertido es:", resultado, "\n")
}
#Llamar la función
convertir_tiempo()
## Ingrese el tiempo:
## Tiempo: 
## ¿Qué unidad es? (1) Horas (2) Minutos (3) Segundos
## Ingrese el número de la unidad de origen: 
## ¿A qué unidad desea convertir? (1) Horas (2) Minutos (3) Segundos
## Ingrese el número de la unidad de destino: 
## Tiempo inválido. Intente nuevamente.
## NULL

7. Escribir un programa en el que se digiten varios números y luego los números se presenten en pantalla ordenados

#Este programa solicita al usuario ingresar una lista de números separados por espacios.

#Convierte la entrada en un vector numérico usando la función strsplit() para separar
#los números y as.numeric() para convertirlos:
entrada <- readline(prompt = "Ingrese los números separados por espacio: ")
## Ingrese los números separados por espacio:
numeros <- as.numeric(unlist(strsplit(entrada, " ")))

#El programa ordena los números en orden ascendente utilizando la función sort().
numeros_ordenados <- sort(numeros)

#Mostrar los números ordenados
cat("Números ordenados:\n")
## Números ordenados:
print(numeros_ordenados)
## numeric(0)

8. Escribir un programa que calcule el factorial de un número que ha sido digitado por el usuario

#PEDIR LOS DATOS AL USUARIO Y CONVERTIRLO A NUMERO
library(svDialogs)

a <- dlgInput(message = "Ingrese un número")$res

# Verificar si se canceló o quedó vacío
if (is.null(a) || a == "") {
  dlg_message("No se ingresó ningún número. Cancelado.")
} else {
  fac_t <- as.numeric(a)
  
  # Verificar si la conversión fue exitosa
  if (is.na(fac_t)) {
    dlg_message("Por favor ingrese un número válido.")
  } else if (fac_t < 0) {
    dlg_message("Por favor ingrese un número positivo!")
  } else if (fac_t == 0) {
    dlg_message(paste("El factorial de", fac_t, "es:", 1))
  } else {
    factorial_total <- 1
    for (i in 1:fac_t) {
      factorial_total <- factorial_total * i
    }
#Los resultados y mensajes se muestran en ventanas flotantes utilizando
#la función dlg_message().
    dlg_message(paste("El factorial de", fac_t, "es:", factorial_total))
  }
}

9. Escribir un programa que pida un número e indique si el número es primo o no

# Pedir un número al usuario
entrada <- readline(prompt = "Ingrese un número para saber si es primo: ")
## Ingrese un número para saber si es primo:
numero <- as.integer(entrada)

# Verificar si el número es primo
if (is.na(numero)) {
  cat("Por favor, ingrese un número válido.\n")
} else {
  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 el resultado
if (es_primo) {
    cat(numero, "es un número primo.\n")
  } else {
    cat(numero, "NO es un número primo.\n")
  }
}
## Por favor, ingrese un número válido.

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

# Solicitar un número al usuario
entrada <- readline(prompt = "Ingrese un número para saber si es par o impar: ")
## Ingrese un número para saber si es par o impar:
numero <- as.integer(entrada)

if (is.na(numero)) {
  cat("Por favor, ingrese un número válido.\n")
} else {
  # Verificar si el número es par o impar
  
#Si el residuo es 0, el número es par; de lo contrario, es impar.
  if (numero %% 2 == 0) {
    cat("El número", numero, "es PAR.\n")
  } else {
    cat("El número", numero, "es IMPAR.\n")
  }
}
## Por favor, ingrese un número válido.

3. CONCLUSIÓN.

Estos ejercicios básicos en R fortalecen la lógica de programación, permiten familiarizarse con las estructuras fundamentales del lenguaje y preparan al estudiante para abordar problemas más avanzados en análisis de datos y estadística.