EJERCICIOS:

  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.
# Comenzamos con un saludo para el usuario explicando brevemente qué vamos a hacer.
print("¡Bienvenido! Este programa convierte temperaturas entre grados Celsius y Fahrenheit.")
# Como primer paso pedimos la temperatura y la convertimos a número con as.numeric().
temp <- as.numeric(readline(prompt = "Ingrese el valor de la temperatura: "))
# El siguiente paso es pedir en qué unidad está la temperatura ingresada.
unidad <- readline(prompt = "Ingrese la unidad actual (C para Celsius, F para Fahrenheit): ")
# Creamos una estructura condicional (si / de lo contrario).
# Si la variable unidad es igual a "C" o "c" se ejecutará la primera instrucción.
if (unidad == "C" || unidad == "c") {
  # Como la unidad está en Celsius, planteamos la operación matemática para transformar a Fahrenheit.
  fahrenheit <- (temp * 9/5) + 32
  # Imprimimos el resultado concatenando el texto y redondeando ambos valores a 2 decimales.
  print(paste(round(temp, 2), "grados Celsius equivalen a", round(fahrenheit, 2), "grados Fahrenheit."))
  # De lo contrario, si la variable unidad es igual a "F" o "f", se ejecutará este bloque.
} else if (unidad == "F" || unidad == "f") {
  # Como la unidad está en Fahrenheit, planteamos la operación matemática para transformar a Celsius.
  celsius <- (temp - 32) * 5/9
  # Imprimimos el resultado concatenando el texto y redondeando ambos valores a 2 decimales.
  print(paste(round(temp, 2), "grados Fahrenheit equivalen a", round(celsius, 2), "grados Celsius."))
  # Si no se cumple ninguna de las condiciones anteriores (el usuario escribió otra letra o número).
} else {
  # Mostramos un mensaje de error indicando que la unidad ingresada no es válida.
  print("Unidad no válida. Por favor ingrese 'C' o 'F'.")
}
  1. 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
# Comenzamos con un saludo para el usuario explicando brevemente qué va a hacer el programa.
print("¡Bienvenido! Este programa calcula la paga por horas normales y horas extras.")
# Pedimos la cantidad de horas trabajadas y las convertimos a formato numérico.
horas <- as.numeric(readline(prompt = "Ingrese el número de horas trabajadas: "))
# Pedimos el valor o tarifa que se paga por cada hora normal y lo convertimos a número.
costo <- as.numeric(readline(prompt = "Ingrese el coste por hora normal: "))
# Calculamos el pago base multiplicando las horas por su respectivo costo.
sueldo <- horas * costo
# Mostramos en pantalla el subtotal correspondiente únicamente a las horas normales, redondeado a 2 decimales.
print(paste("La paga por horas normales es: $", round(sueldo, 2)))
# Preguntamos al usuario si realizó horas extras y guardamos su respuesta como texto ("Si" o "No").
extrassn <- readline(prompt = "¿Realizó horas extras? (Si/No): ")
# Creamos una estructura condicional: si la respuesta es "Si" o "si", se calcularán las horas extras.
if (extrassn == "Si" || extrassn == "si") {
  # Pedimos la cantidad de horas extras realizadas y las convertimos a número.
  horas_extras <- as.numeric(readline(prompt = "Ingrese el número de horas extras: "))
  # Pedimos el valor que se paga por cada hora extra y lo convertimos a número.
  costo_horex <- as.numeric(readline(prompt = "Ingrese el coste por hora extra: "))
  # Calculamos la paga total sumando la paga normal más el producto de las horas extras por su costo.
  paga_total <- sueldo + (horas_extras * costo_horex)
  # De lo contrario (si respondió "No" o cualquier otra palabra), no se suman horas extras.
} else {
  # La paga total será exactamente igual a la paga normal calculada al principio.
  paga_total <- sueldo
}
# Finalmente, imprimimos el monto total a pagar redondeado a 2 decimales.
print(paste("La paga total correspondiente es: $", round(paga_total, 2)))
  1. 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
# Comenzamos con un saludo para el usuario explicando brevemente qué va a hacer el programa.
print("¡Bienvenido! Este programa calcula la suma de los enteros desde 1 hasta n.")
# Pedimos al usuario un número límite (n) y lo convertimos a número entero con as.integer().
n <- as.integer(readline(prompt = "Ingrese un número entero positivo (n): "))
# Creamos una condición para verificar que el número ingresado sea estrictamente mayor que 0 (positivo).
if (n > 0) {
  # Aplicamos la fórmula de Gauss para calcular la suma de todos los enteros desde 1 hasta n sin usar bucles.
  suma <- (n * (n + 1)) / 2
  # Mostramos en pantalla el resultado final concatenando el texto con el valor de n y la suma calculada.
  print(paste("La suma de los enteros desde 1 hasta", n, "es:", suma))
  # De lo contrario (si el número ingresado es 0, negativo o no es un número válido).
} else {
  # Mostramos un mensaje de advertencia pidiendo que se ingrese un número entero positivo válido.
  print("Por favor, ingrese un número entero positivo válido.")
}
  1. 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
# Comenzamos con un saludo explicando qué hace el programa.
print("¡Bienvenido! Este programa calcula tu Índice de Masa Corporal (IMC).")
# Pedimos el peso en kilogramos y la estatura en metros.
peso <- as.numeric(readline(prompt = "Ingrese su peso en kg: "))
estatura <- as.numeric(readline(prompt = "Ingrese su estatura en metros: "))
# Calculamos el IMC dividiendo el peso entre la estatura al cuadrado y redondeamos a 2 decimales.
imc <- round(peso / (estatura^2), 2)
# Mostramos el resultado en pantalla usando print() y paste().
print(paste("Tu índice de masa corporal es", imc))
  1. 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
# Comenzamos con un saludo para el usuario explicando brevemente qué va a hacer el programa.
print("¡Bienvenido! Este programa calcula el capital obtenido en una inversión.")
# Como primer paso, pedimos el monto inicial a invertir y lo convertimos a número con as.numeric().
cantidad <- as.numeric(readline(prompt = "Ingrese la cantidad a invertir: "))
# El siguiente paso es pedir el porcentaje de interés anual y convertirlo a formato numérico.
interes <- as.numeric(readline(prompt = "Ingrese el interés anual (en %): "))
# Pedimos el tiempo de duración de la inversión en años y también lo convertimos a número.
anios <- as.numeric(readline(prompt = "Ingrese el número de años: "))
# Planteamos la fórmula de interés compuesto: dividimos el interés entre 100, sumamos 1, elevamos a los años y multiplicamos por el capital inicial.
capital <- cantidad * (1 + (interes / 100))^anios
# Finalmente, imprimimos el resultado concatenando el texto con los años y el capital obtenido redondeado a 2 decimales.
print(paste("El capital obtenido tras", anios, "años es: $", round(capital, 2)))
  1. 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
# Comenzamos con un saludo para el usuario explicando brevemente qué va a hacer el programa.
print("¡Bienvenido! Este programa convierte unidades de tiempo entre horas, minutos y segundos.")
# Como primer paso, pedimos la cantidad numérica de tiempo y la convertimos con as.numeric().
valor <- as.numeric(readline(prompt = "Ingrese la cantidad de tiempo: "))
# Pedimos la unidad en la que se encuentra originalmente el tiempo ingresado.
origen <- readline(prompt = "Unidad de origen (horas, minutos, segundos): ")
# Pedimos la unidad final a la que el usuario desea transformar el tiempo.
destino <- readline(prompt = "Unidad de destino (horas, minutos, segundos): ")
# Creamos una condición principal para validar que la unidad de origen escrita sea correcta (aceptando minúsculas, capitalizada o mayúsculas).
if (origen == "horas" || origen == "Horas" || origen == "HORAS" ||
    origen == "minutos" || origen == "Minutos" || origen == "MINUTOS" ||
    origen == "segundos" || origen == "Segundos" || origen == "SEGUNDOS") {
  # Paso 1: Llevamos todo a una unidad base común (segundos).
  # Si la unidad de origen corresponde a horas, multiplicamos el valor por 3600.
  if (origen == "horas" || origen == "Horas" || origen == "HORAS") {
    segundos <- valor * 3600
    # De lo contrario, si la unidad de origen corresponde a minutos, multiplicamos el valor por 60.
  } else if (origen == "minutos" || origen == "Minutos" || origen == "MINUTOS") {
    segundos <- valor * 60
    # Si no fue horas ni minutos, entonces ya está en segundos y conservamos el valor tal como está.
  } else {
    segundos <- valor
  }
  # Paso 2: Convertimos desde segundos hacia la unidad de destino solicitada e imprimimos.
  # Si el destino es horas, dividimos los segundos acumulados entre 3600.
  if (destino == "horas" || destino == "Horas" || destino == "HORAS") {
    resultado <- segundos / 3600
    # Imprimimos la equivalencia redondeando el valor inicial a 2 decimales y el resultado a 4 decimales.
    print(paste(round(valor, 2), origen, "equivalen a", round(resultado, 4), destino))
    # De lo contrario, si el destino es minutos, dividimos los segundos entre 60.
  } else if (destino == "minutos" || destino == "Minutos" || destino == "MINUTOS") {
    resultado <- segundos / 60
    # Imprimimos la equivalencia formateada con round() y paste().
    print(paste(round(valor, 2), origen, "equivalen a", round(resultado, 4), destino))
    # De lo contrario, si el destino es segundos, el resultado es directamente el valor en segundos.
  } else if (destino == "segundos" || destino == "Segundos" || destino == "SEGUNDOS") {
    resultado <- segundos
    # Imprimimos la equivalencia en pantalla.
    print(paste(round(valor, 2), origen, "equivalen a", round(resultado, 4), destino))
    # Si el texto ingresado en destino no coincide con ninguna opción válida, mostramos un mensaje de error.
  } else {
    print("La unidad de destino ingresada no es válida.")
  }
  # Si la unidad de origen inicial no coincidió con ninguna opción válida, mostramos este mensaje de advertencia.
} else {
  print("La unidad de origen ingresada no es válida.")
}
  1. Escribir un programa en el que se digiten varios números y luego los números se presenten en pantalla ordenados
# Comenzamos con un saludo para el usuario explicando brevemente qué va a hacer el programa.
print("¡Bienvenido! Este programa ordena n números de menor a mayor.")
# Pedimos al usuario la cantidad total de números que va a ingresar y la convertimos a entero con as.integer().
n <- as.integer(readline(prompt = "¿Cuántos números desea ingresar?: "))
# Creamos una estructura condicional para verificar que la cantidad ingresada sea mayor que 0.
if (n > 0) {
  # Inicializamos un vector vacío donde iremos almacenando cada uno de los números ingresados.
  numeros <- c()
  # Iniciamos un bucle 'for' que se repetirá desde 1 hasta llegar al valor de n.
  for (i in 1:n) {
    # En cada vuelta del bucle, pedimos un número mostrando su posición actual (i) y lo convertimos a formato numérico.
    num <- as.numeric(readline(prompt = paste("Ingrese el número", i, ": ")))
    # Concatenamos el nuevo número ingresado al final del vector 'numeros' para ir acumulándolos.
    numeros <- c(numeros, num)
  }
  # Utilizamos la función sort() para ordenar todos los elementos del vector de menor a mayor.
  numeros_ordenados <- sort(numeros)
  # Imprimimos un mensaje descriptivo previo a mostrar los resultados.
  print("Números ordenados de menor a mayor:")
  # Imprimimos en pantalla el vector ya ordenado de forma ascendente.
  print(numeros_ordenados)
  # De lo contrario (si el usuario ingresó 0 o un número negativo como cantidad).
} else {
  # Mostramos un mensaje de advertencia pidiendo que ingrese una cantidad válida mayor que 0.
  print("Por favor, ingrese una cantidad válida mayor que 0.")
}
  1. Escribir un programa que calcule el factorial de un número que ha sido digitado por el usuario
# Comenzamos con un saludo para el usuario explicando brevemente qué va a hacer el programa.
print("¡Bienvenido! Este programa calcula el factorial de un número.")
# Pedimos al usuario un número entero mayor o igual a cero y lo convertimos a formato entero con as.integer().
num <- as.integer(readline(prompt = "Ingrese un número entero no negativo: "))
# Creamos una estructura condicional para verificar si el número ingresado es menor que 0 (negativo).
if (num < 0) {
  # Si es negativo, mostramos un mensaje indicando que matemáticamente no existe el factorial para ese valor.
  print("El factorial no está definido para números negativos.")
  # De lo contrario (si el número es 0 o positivo), procedemos a realizar el cálculo.
} else {
  # Calculamos el factorial del número directamente utilizando la función integrada factorial() de R.
  fact <- factorial(num)
  # Finalmente, imprimimos el resultado concatenando el texto con el número ingresado y su factorial calculado.
  print(paste("El factorial de", num, "es:", fact))
}
  1. Escribir un programa que pida un número e indique si el número es primo o no
# Comenzamos con un saludo para el usuario explicando brevemente qué va a hacer el programa.
print("¡Bienvenido! Este programa verifica si un número entero es primo.")
# Pedimos un número entero al usuario y lo convertimos a formato entero con as.integer().
num <- as.integer(readline(prompt = "Ingrese un número entero: "))
# Creamos una condición inicial: por definición matemática, los números menores o iguales a 1 no son primos.
if (num <= 1) {
  # Imprimimos directamente que el número ingresado no es primo.
  print(paste("El número", num, "NO es primo."))
  # De lo contrario (si el número es mayor que 1), evaluamos sus divisores.
} else {
  # Inicializamos una variable contador en 0 para registrar cuántos divisores exactos tiene el número.
  divisores <- 0
  # Iniciamos un bucle 'for' que probará todos los números enteros (i) desde 1 hasta el número ingresado (num).
  for (i in 1:num) {
    # Usamos el operador módulo (%%) para verificar si el residuo de dividir 'num' entre 'i' es igual a 0 (división exacta).
    if (num %% i == 0) {
      # Si la división es exacta, incrementamos en 1 nuestro contador de divisores.
      divisores <- divisores + 1
    }
  }
  # Una vez terminado el bucle, verificamos si el total de divisores exactos encontrados es exactamente 2 (el 1 y él mismo).
  if (divisores == 2) {
    # Si solo tuvo 2 divisores, imprimimos en pantalla que el número sí es primo.
    print(paste("El número", num, "ES primo."))
    # De lo contrario (si tuvo más de 2 divisores, es decir, es un número compuesto).
  } else {
    # Imprimimos en pantalla que el número no es primo.
    print(paste("El número", num, "NO es primo."))
  }
}

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

# Comenzamos con un saludo para el usuario explicando brevemente qué va a hacer el programa.
print("¡Bienvenido! Este programa determina si un número entero es par o impar.")
# Pedimos un número entero al usuario y lo convertimos a formato entero con as.integer().
num <- as.integer(readline(prompt = "Ingrese un número entero: "))
# Creamos una estructura condicional: usamos el operador módulo (%%) para verificar si el residuo de dividir el número entre 2 es igual a 0.
if (num %% 2 == 0) {
  # Si el residuo es 0, la división entre 2 es exacta, por lo que imprimimos en pantalla que el número es PAR.
  print(paste("El número", num, "es PAR."))
  # De lo contrario (si el residuo es distinto de 0, es decir, 1 o -1).
} else {
  # Imprimimos en pantalla que el número es IMPAR.
  print(paste("El número", num, "es IMPAR."))
}