Tracks
/
R
R
/
Ejercicios
/
Diario del capitán
Diario del capitán

Diario del capitán

Ejercicio de aprendizaje

Introducción

Muchos programas necesitan valores (aparentemente) aleatorios para simular eventos del mundo real.

Entre los ejemplos comunes y conocidos se incluyen:

  • Lanzar una moneda: un valor aleatorio que es "H" o "T".
  • La tirada de un dado: un número entero aleatorio del 1 al 6.
  • Barajar una baraja de cartas: un orden aleatorio de una lista de cartas.

Generar valores verdaderamente aleatorios con una computadora es un desafío técnico sorprendentemente difícil, así que puedes ver estos resultados mencionados como «seudoaleatorios».

Importante: Este Concepto no cubre los números aleatorios criptográficamente seguros, que son un desafío mucho más difícil.

Sin embargo, R se deriva de un paquete de estadística y a menudo se usa para simulaciones, así que ofrece una gran variedad de formas de generar valores aleatorios. Los resultados son más que suficientes para la mayoría de las aplicaciones de modelado, simulación y juegos.

Muestreo con o sin reemplazo

Imagina que tienes una bolsa con 3 bolas rojas y 4 bolas verdes, y sacas una bola al azar de la bolsa. Para obtener una segunda bola, hay dos posibilidades:

  1. Devuelves la primera bola a la bolsa y agitas bien todo antes de sacar otra. El número de bolas ahora es el mismo que antes (7), y la proporción de rojas a verdes también es la misma.
  2. Dejas la primera bola sobre la mesa antes de sacar una segunda. Ahora solo hay 6 bolas en la bolsa, y la proporción de rojas a verdes depende del color de la primera bola.

El escenario 1 es con reemplazo, el escenario 2 es sin reemplazo, y dan resultados diferentes.

Valores discretos con sample

Para elegir entre un número limitado de valores discretos, se puede usar sample() con o sin reemplazo. Esto es útil para números enteros, strings, etc.

sample(1:10, 5) # no repeats by default
#> [1] 8 3 4 2 6

sample(1:10, 5, replace = TRUE) # repeats are OK
#> [1] 10 10  7 10  9

languages <- c("Fortran", "R", "Python", "Julia")
sample(languages, 1)
#> [1] "Python"

sample(c("H", "T"), 5, replace = TRUE) # coin flips
#> [1] "T" "T" "H" "H" "H"

sample(c(TRUE, FALSE), 5, replace = TRUE) # alternative coin flips
#> [1] FALSE  TRUE FALSE  TRUE  TRUE

El muestreo encaja bien en las canalizaciones de datos. Por ejemplo, para generar strings alfanuméricos aleatorios:

library(stringr)

c(letters, LETTERS, 0:9) |> sample(50) |> str_flatten()
#> [1] "5tX71jhbM9zUmKrpENBQyGYaZdJPVAx06leSF2s8gcfw3OviIH"

Barajar

Varios otros lenguajes tienen una función especial para barajar una secuencia.

R no tiene una función para barajar. ¿Por qué?

Para entenderlo, observa de nuevo la función sample.

La forma completa es sample(x, size, replace = FALSE, prob = NULL), donde x es (normalmente) la secuencia de la que se muestrea y size es el número de elementos que se eligen.

Ya hablamos de replace, cuyo valor predeterminado es el muestreo sin reemplazo. Por ahora, ignora prob, que te permite dar pesos desiguales a los distintos elementos de x.

¿Qué pasa si omitimos size y solo damos x?

x <- letters[1:6]
x
#> [1] "a" "b" "c" "d" "e" "f"
sample(x)
#> [1] "e" "a" "f" "b" "c" "d"

Al estilo típico de R, el patrón es vector de entrada, vector de salida, y size toma como valor predeterminado length(x).

«Muestrear todos los elementos de x sin reemplazo» es solo una forma más técnica de decir «barajar x».

Por eso, no hay una función shuffle, ¡porque sample ya hace exactamente lo que necesitamos!

Trabajar con distribuciones

Los ejemplos anteriores describían casos en los que todos los resultados son igualmente probables. Por ejemplo, sample(1:100) tiene la misma probabilidad de dar cualquier número entero del 1 al 100.

Esto se llama una distribución uniform.

Muchas situaciones del mundo real son mucho menos simples que esto. Por eso, los estadísticos han creado una gran variedad de distributions para describir matemáticamente los resultados del «mundo real».

Números de punto flotante

Distribución uniforme

Para una distribución de números de punto flotante con el mismo peso, usa runif() (concéntrate en «random-uniform» y lucha contra la tendencia natural pero equivocada de leerlo como «run if»). Se pueden especificar tanto min como max, pero sus valores predeterminados son 0 y 1.

runif(5)  # generate 5 values
#> [1] 0.3038506 0.3527959 0.3319309 0.4846354 0.4386279

# generate 5 non-negative values <= 100.0
runif(5, max = 100)
#> [1] 79.70762 51.62232 52.85281 71.08571 63.94380

Instrucciones

Mary es muy fan de la serie de televisión Star Trek: The Next Generation. A menudo juega juegos de rol de lápiz y papel, en los que ella y sus amigos fingen ser la tripulación de la Starship Enterprise.

El personaje de Mary es el capitán Picard, lo que significa que tiene que llevar la bitácora del capitán. Le encanta la parte creativa del juego, pero no le gusta generar datos aleatorios al momento.

Ayuda a Mary creando generadores aleatorios para los datos que aparecen con frecuencia en la bitácora del capitán.

1. Genera planetas aleatorios

La Starship Enterprise se encuentra con muchos planetas en sus viajes. Los planetas del universo de Star Trek se dividen en categorías según sus propiedades. Por ejemplo, la Tierra es un planeta de clase M. Todas las clases planetarias posibles son: D, H, J, K, L, M, N, R, T y Y.

Implementa la función random_planet_class. Debe devolver la cantidad requerida de clases planetarias de forma aleatoria, como un vector. Se aceptan clases duplicadas, y pueden ser necesarias para vectores largos.

random_planet_class(number_needed)
#> "K"

2. Genera un número de registro de nave aleatorio

¡La Enterprise (número de registro NCC-1701) no es la única nave que anda volando por ahí! Cuando se encuentra con otra nave, Mary necesita anotar en la bitácora el número de registro de esa nave.

Los números de registro empiezan con el prefijo «NCC-» y luego usan un número del 1000 al 9999 (inclusive).

Implementa la función random_ship_registry_number, que devuelve un número de registro de nave aleatorio.

random_ship_registry_number()
#> "NCC-1947"

3. Ordena aleatoriamente una flota de naves

Una versión del juego implica interactuar con otras naves, y Mary necesita una selección.

Existe una lista completa de naves posibles, pero en cada partida solo se necesitan unas pocas, y deben elegirse de forma aleatoria.

Implementa la función shuffle_starships(starships), que toma un vector de números de registro de naves únicos y devuelve un vector de la misma longitud con las naves en orden aleatorio. Así, a Mary le resultará fácil tomar una selección aleatoria de cualquier tamaño desde el inicio del vector.

Los valores del resultado deben tomarse de starships, sin duplicados.

shuffle_starships(c("NCC-5011", "NCC-1228", "NCC-7039", "NCC-3978", "NCC-1476"))
#> [1] "NCC-1476" "NCC-7039" "NCC-3978" "NCC-5011" "NCC-1228"

4. Genera una fecha estelar aleatoria

¿De qué sirve una bitácora si no incluye fechas?

Una fecha estelar es un número de punto flotante. Las aventuras de la Starship Enterprise de la primera temporada de The Next Generation transcurren entre las fechas estelares 41000.0 y 42000.0. El «4» representa el siglo XXIV y el «1», la primera temporada.

Implementa la función random_stardate, que devuelve un número de punto flotante entre 41000.0 y 42000.0.

random_stardate()
#> 41037.6
Editar en GitHub El enlace se abre en una ventana o una pestaña nuevas
R Exercism

¿Todo listo para empezar Diario del capitán?

Regístrate en Exercism para aprender y dominar R con 21 conceptos111 ejercicios y mentoría humana real, todo gratis.