# 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'.")
}
# 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)))
# 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.")
}
# 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))
# 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)))
# 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.")
}
# 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.")
}
# 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))
}
# 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."))
}