Universidad Central del Ecuador

Facultad de Ciencias Económicas

Carrera de Estadística

Escudo de la Universidad Central del Ecuador
Escudo de la Universidad Central del Ecuador

TALLER-APE 1: Proceso de instalación y ejecución de R y R.Studio

GRUPO 2

Integrantes:

  • Caminos Leonardo
  • Cepa Johan
  • Guamán Alex
  • Gonzáles Joel
  • Sánchez Anthony

Curso: E3-001

1. INTRODUCCIÓN

El aprendizaje de la programación en R constituye una herramienta esencial dentro de la formación estadística, ya que permite integrar conceptos matemáticos con estrategias computacionales orientadas a la solución de problemas reales. En este informe se presentan de manera conjunta los resultados y procedimientos desarrollados en los Talleres 2 y 3, los cuales abarcan desde cálculos geométricos y operaciones algebraicas hasta la implementación de programas interactivos que emplean estructuras de control, funciones y manejo de datos en el lenguaje R.

El documento unificado tiene como propósito evidenciar el proceso progresivo de consolidación de habilidades en programación mediante la elaboración de ejercicios prácticos que incluyen conversiones de unidades, cálculos de áreas, resolución de ecuaciones cuadráticas, verificación de números primos, manipulaciones aritméticas y operaciones lógicas. Este enfoque permite fortalecer la comprensión tanto de los fundamentos matemáticos como del diseño algorítmico, promoviendo así el desarrollo de pensamiento computacional aplicado.

Asimismo, la utilización de RMarkdown y de paquetes como svDialogs facilita la interacción con el usuario y mejora la presentación de los resultados, fomentando la reproducibilidad y claridad metodológica. La integración de ambos talleres demuestra que la capacidad de traducir problemas matemáticos a código es clave para la estadística moderna, donde la automatización y la precisión son indispensables.

En conjunto, este informe sintetiza el avance académico obtenido en este proceso formativo, resaltando la importancia de la programación en R como medio para estructurar soluciones eficientes, documentadas y coherentes con las necesidades del análisis cuantitativo contemporáneo.

2. FUNDAMENTO TEÓRICO

La programación en R permite aplicar conceptos matemáticos y estadísticos de manera eficiente en la resolución de problemas prácticos. Según Wickham & Grolemund (2017), R es un entorno integrado ideal para implementar algoritmos que requieren precisión y reproducibilidad. En los talleres desarrollados, se aplicaron principios como el Teorema de Pitágoras, la fórmula cuadrática, el cálculo de áreas y perímetros, y el interés compuesto, los cuales constituyen la base de modelos más complejos en estadística y ciencia de datos.

Además, Burton (2019) destaca que la teoría de números —aplicada en ejercicios de identificación de números primos y pares— es fundamental para la optimización de algoritmos. La implementación de estructuras de control y manipulación de datos en R refleja la importancia de la lógica de programación en la automatización de tareas y validación de entradas de usuario.

3. OBJETIVO GENERAL

Integrar y aplicar los conceptos fundamentales de programación en R mediante el desarrollo de ejercicios prácticos enfocados en operaciones matemáticas, lógicas y estructurales, para generar un documento reproducible en RMarkdown que evidencie el uso adecuado de funciones, estructuras de control y manipulación de datos básicos.

4. OBJETIVOS ESPECÍFICOS

5. METODOLOGIA

El desarrollo del informe se llevó a cabo siguiendo un enfoque práctico, donde los ejercicios fueron reorganizados, integrados y documentados de forma coherente dentro de un solo archivo RMarkdown.

En primer lugar, se realizó un análisis de los ejercicios correspondientes para identificar los objetivos particulares, las estructuras de programación utilizadas y los conceptos matemáticos aplicados. Una vez revisado el contenido, se procedió a fusionar los ejercicios en una estructura única, clasificándolos según su naturaleza (cálculos geométricos, operaciones aritméticas, conversiones, lógica y control de flujo).

Cada ejercicio fue replanteado de manera sistemática mediante los siguientes pasos:

  1. Planteamiento del problema: se redactó una descripción breve y precisa que contextualiza el propósito del ejercicio.

  2. Desarrollo del código en R: se implementó la solución correspondiente utilizando funciones, operadores, estructuras condicionales y, cuando fue necesario, interacción con el usuario mediante el paquete svDialogs.

  3. Pruebas y verificación: cada programa fue ejecutado con diferentes valores de entrada para comprobar su correcto funcionamiento y validar la lógica del código.

  4. Documentación en RMarkdown: se integró el texto explicativo junto con el código y los resultados generados, garantizando la reproducibilidad del documento.

  5. Estandarización del formato: se unificó el estilo de presentación y se ajustó la redacción para mantener coherencia entre los ejercicios provenientes de ambos talleres.

Finalmente, el informe completo fue preparado para su publicación en RPubs, asegurando que el contenido sea legible, estructurado y adecuado para su consulta en línea.

6. DESARROLLO

Para resolver todos los ejercicios, instalaremos el paquete svDialogs, con esto podremos hacer mas dinamicos cada codigo.

#install.packages("svDialogs")

Ejercicios taller 2

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

Se desea desarrollar un programa en R que solicite al usuario los valores de los dos catetos de un triángulo rectángulo y calcule la longitud de la hipotenusa aplicando el Teorema de Pitágoras, que establece que el cuadrado de la hipotenusa es igual a la suma de los cuadrados de los catetos.

# llamar al paquete
library(svDialogs)
## Warning: package 'svDialogs' was built under R version 4.5.2
#solicitar datos al usuario
cateto1 <- as.numeric(dlgInput("Ingrese el primer cateto:")$res)
cateto2 <- as.numeric(dlgInput("Ingrese el segundo cateto:")$res)
# calcular valor de hipotenusa
hipotenusa <- sqrt(cateto1^2 + cateto2^2)
print(paste("La hipotenusa es:", hipotenusa))
## [1] "La hipotenusa es: NA"

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

Se requiere un programa que resuelva ecuaciones cuadráticas de la forma ax^2+bx+c=0 El usuario debe ingresar los coeficientes lo que se debe hacer el usuario es ingresar los coeficientes a,b,c El cálculo involucra:

1.Determinar el discriminate (b^2-4ac)

2.Calcular las raíces reales usando la fórmula cuadrática, considerando casos donde el discriminante sea negativo

3.Mostrar las soluciones X1 Y X2

# # Pedir valores al usuario
a <- as.numeric(dlgInput("Ingresa el coeficiente a:")$res)
b <- as.numeric(dlgInput("Ingresa el coeficiente b:")$res)
c <- as.numeric(dlgInput("Ingresa el coeficiente c:")$res)

# Calcular soluciones
discriminante <- b^2 - 4*a*c
x1 <- (-b + sqrt(pmax(0, discriminante))) / (2*a)
x2 <- (-b - sqrt(pmax(0, discriminante))) / (2*a)

cat("Soluciones: x1 =", x1, ", x2 =", x2)
## Soluciones: x1 = NA , x2 = NA

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

El objetivo del programa es calcular automáticamente el área y el perímetro de un rectángulo, interactuando con el usuario mediante ventanas emergentes para obtener los valores de la base y la altura.

#Llamar al paquete
library(svDialogs)

base <- dlgInput(message = "Ingrese el valor de la base:")$res
base <- as.numeric(base)
altura <- dlgInput(message = "Ingrese el valor de la altura:")$res
altura <- as.numeric(altura)

area <- (base * altura) / 2
print(paste("El área de su triángulo rectángulo es:", area))
## [1] "El área de su triángulo rectángulo es: NA"

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

Desarrollar un programa en R que calcule automáticamente el área y perímetro de un rectángulo, interactuando con el usuario mediante ventanas emergentes para obtener los valores de base y altura, y mostrando los resultados de forma clara y organizada.

#llamar a la libreria
library(svDialogs)
#solicitar datos al usuario
base <- as.numeric(dlg_input("Base del rectángulo:")$res)
altura <- as.numeric(dlg_input("Altura del rectángulo:")$res)
#calcular area y perimetro
area <- base * altura
perimetro <- 2 * (base + altura)

mensaje <- paste("Con base", base, "y altura", altura,
                "Área =", area,
                "Perímetro =", perimetro)

print(mensaje)
## [1] "Con base NA y altura NA Área = NA Perímetro = NA"

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

Se desea desarrollar un programa en R que permita al usuario ingresar tres notas correspondientes a un examen o evaluación. Las notas deben estar en el rango de 0 a 20. Una vez que el usuario ingrese las notas, el programa deberá verificar que todas se encuentren dentro de este rango válido. Si alguna de las notas es inválida, el programa mostrará un mensaje de error indicando que las notas deben estar entre 0 y 20.

Si todas las notas son válidas, el programa calculará el promedio de las tres notas y mostrará el resultado en pantalla. El promedio se calculará sumando las tres notas y dividiendo el resultado entre 3.

# Llamar a la librería
library(svDialogs)

# Solicitar las notas al usuario
print("Ingrese sus notas, deben ser entre 0 y 20")
## [1] "Ingrese sus notas, deben ser entre 0 y 20"
# Solicitar las tres notas
nota1 <- as.numeric(dlgInput("Ingrese la primera nota")$res)
nota2 <- as.numeric(dlgInput("Ingrese la segunda nota")$res)
nota3 <- as.numeric(dlgInput("Ingrese la tercera nota")$res)

# Verificar si alguna de las notas es NULL o NA
if (is.na(nota1) | is.na(nota2) | is.na(nota3)) {
  print("Por favor, ingrese un valor válido para todas las notas.")
} else {
  # Validar las tres notas
  if (all(c(nota1, nota2, nota3) >= 0 & c(nota1, nota2, nota3) <= 20)) {
    # Si todas las notas son válidas
    promedio <- (nota1 + nota2 + nota3) / 3
    print(paste("El promedio de sus notas es:", promedio))
  } else {
    # Si alguna de las notas no es válida
    print("Alguna de sus notas no es válida.")
  }
}
## [1] "Por favor, ingrese un valor válido para todas las notas."

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

El programa debe calcular el área y el perímetro de una circunferencia dado su radio

Área: A=πR^2 Perímetro: P=2πR

# Pedir el radio al usuario
radio <- as.numeric(dlgInput("Ingresa el radio de la circunferencia")$res)

# Calcular el área y perímetro
area <- pi * radio^2
perimetro <- 2 * pi * radio

# resultados
cat("RESULTADOS:\n")
## RESULTADOS:
cat("Radio =", radio, "\n")
## Radio = NA
cat("Área =", area, "\n")
## Área = NA
cat("Perimetro =", perimetro)
## Perimetro = NA

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

El objetivo del programa es calcular automáticamente el área y el perímetro de un trapecio, interactuando con el usuario mediante ventanas emergentes para obtener los valores de la base mayor, la base menor y la altura.

#Llamar al paquete
library(svDialogs)
# Solicitar datos al usuario
base_mayor <- dlgInput(message = "Ingrese el valor de la base Mayor:")$res
base_mayor <- as.numeric(base_mayor)
base_menor <- dlgInput(message = "Ingrese el valor de la base Menor:")$res
base_menor <- as.numeric(base_menor)
altura <- dlgInput(message = "Ingrese el valor de la altura:")$res
altura <- as.numeric(altura)

# Calculo del area
area <- ((base_mayor + base_menor) * altura) / 2

# Calculo del perimetro 
lado <- sqrt(((base_mayor - base_menor) / 2)^2 + altura^2)
perimetro <- base_mayor + base_menor + 2 * lado

print(paste("El area de su trapecio es:", area))
## [1] "El area de su trapecio es: NA"
print(paste("El perimetro de su trapecio es:", perimetro))
## [1] "El perimetro de su trapecio es: NA"

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

Se desea desarrollar un programa en R que permita al usuario ingresar dos números y determine cuál de los dos es el mayor y cuál es el menor. Si ambos números son iguales, el programa debe mostrar un mensaje que indique que los números son iguales.

# Llamar a la librería
library(svDialogs)

# Solicitar datos al usuario
numero1 <- as.numeric(dlgInput("Ingrese el primer numero")$res)
numero2 <- as.numeric(dlgInput("Ingrese el segundo numero")$res)

# Verificar si alguna de las entradas es NA (no numérica o cancelada)
if (is.na(numero1) | is.na(numero2)) {
  print("Por favor, ingrese números válidos para ambos valores.")
} else {
  # Determinar cuál es mayor y cuál es menor
  if (numero1 > numero2) {
    print(paste("El número", numero1, "es mayor, el número", numero2, "es menor"))
  } else if (numero1 < numero2) {
    print(paste("El número", numero2, "es mayor, el número", numero1, "es menor"))
  } else {
    print(paste("Ambos números son iguales"))
  }
}
## [1] "Por favor, ingrese números válidos para ambos valores."

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

Calcular el área y perímetro de un rectángulo mediante la interacción con el usuario a través de ventanas emergentes, mostrando los resultados de forma organizada.

# Llamar a la librería
library(svDialogs)

# Solicitar datos al usuario
num1 <- as.numeric(dlgInput("Primer número:")$res)
num2 <- as.numeric(dlgInput("Segundo número:")$res)

# Verificar si alguna de las entradas es NA
if (is.na(num1) | is.na(num2)) {
  print("Por favor, ingrese números válidos para ambos valores.")
} else {
  # Calculos
  suma <- num1 + num2
  resta <- num1 - num2
  multiplicacion <- num1 * num2

  # Condición para evitar errores en la división
  if (num2 != 0) {
    division <- num1 / num2
  } else {
    division <- "No se puede dividir entre cero"
  }

  # Crear mensaje
  mensaje <- paste("Con los números", num1, "y", num2,
                   "\nSuma =", suma,
                   "\nResta =", resta,
                   "\nMultiplicación =", multiplicacion,
                   "\nDivisión =", division)

  # Imprimir mensaje
  print(mensaje)
}
## [1] "Por favor, ingrese números válidos para ambos valores."

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.

Se necesita crear un programa en R que pida al usuario una cantidad en dólares y determine el valor del IVA (12%) correspondiente, además de calcular el total a pagar (suma del valor ingresado más el IVA).

#llamar a la libreria
library(svDialogs)
#solicitar datos al usuario
cantidad <- as.numeric(dlgInput("Ingrese la cantidad en dólares:")$res)
# calcular el nuevo valor
iva <- cantidad * 0.12
total <- cantidad + iva

print(paste("la cantidad a pagar es:", total, "$"))
## [1] "la cantidad a pagar es: NA $"

Ejercicios taller 3

EJERCICIO 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 debe permitir la conversión bidireccional entre las escalas de temperatura Fahrenheit y Celsius. El usuario proporcionará un valor numérico de temperatura y especificará la unidad de medida original, y el sistema devolverá el equivalente en la otra escala.

Las fórmulas de conversión se derivan de la relación lineal entre ambas escalas:

De Fahrenheit a Celsius: C = (F - 32) × 5/9

De Celsius a Fahrenheit: F = (C × 9/5) + 32

# Cargar el paquete necesario
#library(svDialogs)

# Solicitar temperatura y unidad a
#temperatura <- dlgInput("Ingrese la temperatura:")$res
#unidad <- dlgInput("¿Es Fahrenheit (F) o Celsius (C)? Ingrese F o C:")$res

# Convertir a numérico 
#temperatura <- as.numeric(temperatura)
#if (is.na(temperatura)) {
#  stop("Error: La temperatura debe ser un valor numérico")
#}

# Realizar la conversión según la unidad 
#if (unidad == "F" || unidad == "f") {
#  celsius <- (temperatura - 32) * 5/9
#  cat("Temperatura convertida:", round(celsius, 1), "°C\n")
#} else if (unidad == "C" || unidad == "c") {
#  fahrenheit <- (temperatura * 9/5) + 32
#  cat("Temperatura convertida:", round(fahrenheit, 1), "°F\n")
#} else {
#  stop("Error: Unidad no válida. Debe ingresar F o C")
#}

EJERCICIO 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

El programa debe pedir cuántas horas trabajó la persona y cuánto gana por cada una. Si también trabajó horas extra, debe pedir cuántas fueron y cuánto se paga cada hora extra.

Luego, la paga total se calcula con la fórmula:

Paga Total = (Horas Normales×Costo por Hora) + (Horas Extra×Costo Extra)

horas <- as.numeric(readline("Horas trabajadas: "))
## Horas trabajadas:
costo <- as.numeric(readline("Costo por hora: "))
## Costo por hora:
extra <- tolower(readline("¿Horas extra? (si/no): "))
## ¿Horas extra? (si/no):
if(extra == "si"){
  h_extra <- as.numeric(readline("Horas extra: "))
  c_extra <- as.numeric(readline("Costo hora extra: "))
  paga <- horas * costo + h_extra * c_extra
} else {
  paga <- horas * costo
}

cat("Tu paga total es: $", paga, "\n")
## Tu paga total es: $ NA

Ejercicio 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 suma de los n primeros enteros positivos puede ser calculada de la siguiente forma: suma=(n(n+1))/2

Desarrollar un programa en R que solicite al usuario, mediante una ventana emergente, un número entero positivo n y calcule automáticamente la suma de todos los enteros desde 1 hasta n utilizando la fórmula suma = n(n+1)/2. El programa debe mostrar el resultado de forma clara y organizada.

# Llamar al paquete
library(svDialogs)

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

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

print(paste("La suma de los enteros desde 1 hasta", n, "es:", suma))
## [1] "La suma de los enteros desde 1 hasta NA es: NA"

Ejercicio 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

Se desea desarrollar un programa en R que solicite al usuario su peso en kilogramos y su estatura en metros mediante ventanas de entrada, y posteriormente calcule su índice de masa corporal aplicando la fórmula IMC = peso / (estatura²). El resultado deberá almacenarse en una variable y mostrarse en pantalla redondeado a dos decimales.

library(svDialogs)

peso_input <- dlg_input("Ingrese su peso en kilogramos:")$res
peso <- as.numeric(peso_input)

estatura_input <- dlg_input("Ingrese su estatura en metros:")$res
estatura <- as.numeric(estatura_input)

imc <- peso / (estatura^2)

imc_redondeado <- round(imc, 2)

print(paste("Tu índice de masa corporal es", imc_redondeado))
## [1] "Tu índice de masa corporal es NA"

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

Se puede utilizar la fórmula del interés compuesto, que es la que generalmente se aplica para calcular el capital obtenido en una inversión con un interés anual constante. Según (fernando_2025?), el interés compuesto permite que el capital crezca de manera exponencial a lo largo del tiempo.

La fórmula es: A = P * (1 + (r/100))^t

donde:

A es el capital final (el dinero que tendrás después de los años).

P es el capital inicial o cantidad a invertir.

r es la tasa de interés anual (en porcentaje).

t es el número de años.

# Llamar al paquete
library(svDialogs)
P <- dlgInput(message = "¿cuanto dinero desea invertir?")$res
P <- as.numeric(P)

r <- dlgInput(message = "¿a que tasa desea invertir?, colocar en decimales")$res
r <- as.numeric(r)

t <- dlgInput(message = "¿cuantos años desea que dure su inversion?")$res
t <- as.numeric(t)

# calculo del capital final
A <-  P * (1 + (r))^t

print(paste("Usted terminara recimiendo:", round(A, 2), "dolares"))
## [1] "Usted terminara recimiendo: NA dolares"

Ejercicio 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

Para entender cómo realizar este programa, primero se debe saber las conversiones entre las distintas unidades de tiempo. En el caso de las horas, una hora es equivalente a 60 minutos o a 3600 segundos. Un minuto es equivalente a 1/60 horas o a 60 segundos. Un segundo es equivalente a 1/60 minutos o a 1/3600 segundos.

Cuando el usuario ingrese un valor de tiempo en una unidad (por ejemplo, horas), el programa debe convertir esa cantidad a la unidad solicitada (minutos o segundos).

# Llamar al paquete
library(svDialogs)
tiempo <- dlgInput(message = "Ingrese su valor horario (pueden ser horas, minutos, segundos)")$res
tiempo <- as.numeric(tiempo)

calculo <- dlgInput("¿Es hora, minuto o segundo? Ingrese hora, minuto, segundo")$res
resultado <- NA
convertir <- NA

if (calculo == "hora"){
  convertir <- dlgInput("¿A que unidad desea convertir? Ingrese minuto o segundo")$res
  if (convertir == "minuto"){
    resultado <- tiempo*60
  } else if (convertir == "segundo") {
    resultado <- tiempo*3600
  }
} else if (calculo == "minuto"){
  convertir <- dlgInput("¿A que unidad desea convertir? Ingrese hora o segundo")$res
  if (convertir == "hora"){
    resultado <- tiempo/60
  } else if (convertir == "segundo") {
    resultado <- tiempo*60
  }
} else if (calculo == "segundo"){
  convertir <- dlgInput("¿A que unidad desea convertir? Ingrese hora o minuto")$res
  if (convertir == "hora"){
    resultado <- tiempo/3600
  } else if (convertir == "minuto") {
    resultado <- tiempo/60
  }
}

print(paste("El resultado de la conversion es:", resultado, convertir))
## [1] "El resultado de la conversion es: NA NA"

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

Se desea desarrollar un programa en R que solicite al usuario ingresar varios números separados por comas mediante una ventana de entrada, procese esa cadena de texto convirtiéndola en un vector numérico y, posteriormente, ordene dichos valores de menor a mayor. Finalmente, el programa deberá mostrar en pantalla la lista de números ya ordenada.

library(svDialogs)

# Pedir números separados por comas
entrada <- dlg_input("Ingrese varios números separados por comas:")$res

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

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

# Crear mensaje de salida
print(paste("Los números ordenados son:", paste(numeros_ordenados, collapse = ", ")))
## [1] "Los números ordenados son: "

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

Desarrollar un programa en R que calcule el factorial de un número ingresado por el usuario mediante una ventana emergente, realizando el proceso de multiplicación sucesiva y mostrando el resultado final de forma clara y organizada.

# Llamar al paquete
#library(svDialogs)

# Realice un programa que calcule el factorial de un número ingresado por el usuario
#num <- dlgInput(message = "Ingrese un número para calcular su factorial:")$res
#num <- as.numeric(num)

#factorial_resultado <- 1

#for(i in 1:num){factorial_resultado <- factorial_resultado * i}

#print(paste("El factorial de", num, "es:", factorial_resultado))

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

El programa debe pedirle al usuario un número y analizarlo para saber si es primo. Un número es primo cuando solo se puede dividir entre 1 y él mismo. Al final, el programa debe decirle al usuario, de forma sencilla y humana, si su número es primo o no.

#n <- as.numeric(readline("Dime un número y te digo si es primo: "))

#primo <- n > 1 && all(n %% 2:(n-1) != 0)

#if(primo){
#  cat(" Sí, ", n, " es un número primo.\n", sep = "")
#} else {
#  cat(" No, ", n, " no es primo.\n", sep = "")
#}

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

El problema de determinar si un número es par o impar se fundamenta en la teoría básica de números y la propiedad de divisibilidad. Matemáticamente, esta clasificación depende exclusivamente del comportamiento del número cuando se divide entre 2, específicamente del residuo que resulta de dicha división.

# Pedir al usuario que ingrese un número
numero <- as.numeric(readline("Ingresa un número para saber si es par o impar: "))
## Ingresa un número para saber si es par o impar:
# Verificar si el valor ingresado es válido
if (is.na(numero)) {
  cat("Por favor, ingresa un número válido.\n")
} else {
  # Verificar si el número es par
  if (numero %% 2 == 0) {
    cat("El número", numero, "es par.\n")
  } else {
    cat("El número", numero, "es impar.\n")
  }
}
## Por favor, ingresa un número válido.

7. CONCLUSIONES Y RECOMENDACIONES

7.1. CONCLUSIONES

La integración de los Talleres 2 y 3 permitió evidenciar un proceso progresivo de consolidación de habilidades en programación con R, pasando de ejercicios básicos de geometría y álgebra hacia aplicaciones más complejas que incluyeron estructuras de control, funciones y manipulación de datos. Este avance demostró que la traducción de problemas matemáticos a código fortalece el pensamiento computacional y la capacidad de diseñar algoritmos reproducibles, competencias esenciales en la formación estadística contemporánea. Asimismo, el uso de RMarkdown garantizó una documentación clara y organizada, lo que asegura la reproducibilidad y coherencia metodológica en la presentación de resultados, mientras que la incorporación del paquete svDialogs aportó dinamismo e interactividad, reforzando la importancia de validar entradas y automatizar cálculos en entornos prácticos. Los ejercicios desarrollados abarcaron un amplio espectro de aplicaciones, desde cálculos geométricos y resolución de ecuaciones cuadráticas hasta conversiones de unidades, sumatorias, factoriales, IMC, interés compuesto y clasificación de números, lo que refleja la capacidad del lenguaje R para integrar teoría matemática con práctica computacional. En conjunto, el trabajo confirma que la programación en R no solo constituye una herramienta técnica, sino también un medio pedagógico que afianza la comprensión matemática y fomenta la precisión en el análisis cuantitativo, consolidando así competencias fundamentales para el ejercicio estadístico moderno.

7.2. RECOMENDACIONES

• Verificación de fórmulas y algoritmos: se sugiere revisar minuciosamente las expresiones matemáticas antes de su implementación en código, para evitar errores de cálculo y asegurar la validez de los resultados.

• Pruebas con múltiples entradas: cada programa debe ser evaluado con distintos valores de entrada, incluyendo casos límite, con el fin de garantizar robustez y confiabilidad en la ejecución.

• Uso sistemático de comentarios en el código: mantener un estilo de programación documentado facilita la comprensión, la revisión y la futura reutilización de los programas.

• Estandarización del formato en RMarkdown: continuar unificando la presentación de planteamientos, código y resultados, lo que asegura claridad metodológica y coherencia en informes publicados en RPubs.

• Profundización en estructuras avanzadas: se recomienda ampliar el uso de funciones personalizadas, ciclos y validaciones, para abordar problemas más complejos y fortalecer la capacidad de abstracción algorítmica.

• Práctica continua: mantener la resolución sistemática de ejercicios permitirá afianzar las competencias adquiridas y preparar el terreno para aplicaciones estadísticas de mayor nivel, como análisis de datos y modelado predictivo.

Referencias

D.M. Burton (2019). Elementary number theory. McGraw-Hill
R Core Team (2024). R: A language and environment for statistical computing. R Foundation for Statistical Computing
K.H. Rosen (2019). Discrete mathematics and its applications. McGraw-Hill
RStudio Team RMarkdown: Dynamic documents for r.
H. Wickham, & G. Grolemund (2017). R for data science. O’Reilly Media