Parcours
/
R
R
/
Exercices
/
Journal de bord du capitaine
Journal de bord du capitaine

Journal de bord du capitaine

Exercice d'apprentissage

Introduction

De nombreux programmes ont besoin de valeurs (apparemment) aléatoires pour simuler des événements du monde réel.

Parmi les exemples courants et bien connus :

  • Un lancer de pièce : une valeur aléatoire qui vaut "H" ou "T".
  • Le lancer d'un dé : un entier aléatoire de 1 à 6.
  • Le mélange d'un jeu de cartes : un ordre aléatoire d'un tableau de cartes.

Générer de vraies valeurs aléatoires avec un ordinateur est un défi technique étonnamment difficile, c'est pourquoi on voit parfois ces résultats qualifiés de « pseudo-aléatoires ».

Important : ce concept ne couvre pas les nombres aléatoires cryptographiquement sûrs, qui représentent un défi bien plus difficile.

Cependant, R est issu d'un logiciel de statistiques et sert souvent à des simulations : il offre donc une grande variété de façons de générer des valeurs aléatoires. Ces résultats sont largement suffisants pour la plupart des applications en modélisation, en simulation et dans les jeux.

Échantillonnage avec ou sans remise

Imagine que l'on a un sac contenant 3 boules rouges et 4 boules vertes, et que l'on tire une boule au hasard dans le sac. Pour obtenir une deuxième boule, deux possibilités s'offrent à nous :

  1. Remettre la première boule dans le sac et bien secouer le tout avant d'en tirer une autre. Le nombre de boules est maintenant le même qu'avant (7), et le rapport entre le rouge et le vert est lui aussi identique.
  2. Mettre de côté la première boule sur la table avant d'en tirer une seconde. Il ne reste alors que 6 boules dans le sac, et le rapport rouge/vert dépend de la couleur de la première boule.

Le scénario 1 se fait avec remise, le scénario 2 sans, et ils donnent des résultats différents.

Valeurs discrètes avec sample

Pour choisir parmi un nombre limité de valeurs discrètes, on peut utiliser sample() avec ou sans remise. C'est utile pour les entiers, les 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

L'échantillonnage s'intègre bien dans les pipelines de données. Par exemple, pour générer des strings alphanumériques aléatoires :

library(stringr)

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

Mélange

Plusieurs autres langages disposent d'une fonction spéciale pour mélanger une séquence.

R n'a pas de fonction de mélange. Pourquoi ?

Pour le comprendre, regardons à nouveau la fonction sample.

Sa forme complète est sample(x, size, replace = FALSE, prob = NULL), où x est (en général) la séquence dans laquelle on tire et size le nombre d'éléments à choisir.

On a déjà vu replace, dont la valeur par défaut correspond à un tirage sans remise. Pour l'instant, ignorons prob, qui permet de donner des poids inégaux aux différents éléments de x.

Que se passe-t-il si on omet size et qu'on ne fournit que x ?

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

Dans le style typique de R, le schéma est vecteur en entrée, vecteur en sortie, et size vaut par défaut length(x).

« Tirer tous les éléments de x sans remise » est juste une façon plus technique de dire « mélanger x ».

Ainsi, il n'y a pas de fonction shuffle, car sample fait déjà exactement ce dont on a besoin !

Travailler avec les distributions

Les exemples ci-dessus décrivaient des cas où tous les résultats ont la même probabilité. Par exemple, sample(1:100) a autant de chances de donner n'importe quel entier de 1 à 100.

On parle alors d'une distribution uniform.

Beaucoup de situations du monde réel sont bien moins simples que cela. C'est pourquoi les statisticiens ont créé une grande variété de distributions pour décrire mathématiquement les résultats du « monde réel ».

Nombres à virgule flottante

Distribution uniforme

Pour une distribution équipondérée de nombres à virgule flottante, utilise runif() (pense à « random-uniform » et résiste à la tendance naturelle mais fausse à le lire « run if »). On peut préciser min et max, mais ils valent 0 et 1 par défaut.

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

Instructions

Mary est une grande fan de la série télévisée Star Trek : The Next Generation. Elle joue souvent à des jeux de rôle sur table, où elle et ses amis incarnent l'équipage du Starship Enterprise.

Le personnage de Mary est le capitaine Picard, ce qui signifie qu'elle doit tenir le journal de bord du capitaine. Elle adore la partie créative du jeu, mais n'aime pas générer des données aléatoires à la volée.

Aide Mary en créant des générateurs aléatoires pour les données qui apparaissent souvent dans le journal de bord.

1. Génère des planètes aléatoires

Le Starship Enterprise rencontre de nombreuses planètes au cours de ses voyages. Dans l'univers de Star Trek, les planètes sont réparties en catégories selon leurs propriétés. Par exemple, la Terre est une planète de classe M. Toutes les classes planétaires possibles sont : D, H, J, K, L, M, N, R, T et Y.

Implémente la fonction random_planet_class. Elle doit renvoyer aléatoirement le nombre demandé de classes planétaires, sous forme de vecteur. Les classes en double sont acceptables, et peuvent être nécessaires pour de longs vecteurs.

random_planet_class(number_needed)
#> "K"

2. Génère un numéro d'immatriculation de vaisseau aléatoire

L'Enterprise (numéro d'immatriculation NCC-1701) n'est pas le seul vaisseau spatial en circulation ! Lorsqu'il croise un autre vaisseau, Mary doit noter le numéro d'immatriculation de ce vaisseau.

Les numéros d'immatriculation commencent par le préfixe « NCC- », puis comportent un nombre compris entre 1000 et 9999 (inclus).

Implémente la fonction random_ship_registry_number qui renvoie un numéro d'immatriculation de vaisseau aléatoire.

random_ship_registry_number()
#> "NCC-1947"

3. Mélange une flotte de vaisseaux

Une version du jeu consiste à interagir avec d'autres vaisseaux, et Mary a besoin d'une sélection.

Il existe une liste complète de vaisseaux possibles, mais seuls quelques-uns sont nécessaires à chaque partie, et ils doivent être choisis au hasard.

Implémente la fonction shuffle_starships(starships), qui prend un vecteur de numéros d'immatriculation de vaisseaux uniques et renvoie un vecteur de même longueur avec les vaisseaux dans un ordre aléatoire. Il sera alors facile pour Mary de prendre une sélection aléatoire de n'importe quelle taille depuis le début du vecteur.

Les valeurs du résultat doivent être extraites de starships, sans doublon.

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. Génère une date stellaire aléatoire

À quoi bon un journal s'il n'inclut pas de dates ?

Une date stellaire est un nombre décimal. Les aventures du Starship Enterprise de la première saison de The Next Generation se déroulent entre les dates stellaires 41000.0 et 42000.0. Le « 4 » correspond au 24e siècle, le « 1 » à la première saison.

Implémente la fonction random_stardate qui renvoie un nombre décimal compris entre 41000.0 et 42000.0.

random_stardate()
#> 41037.6
Modifie via GitHub Le lien s'ouvre dans une nouvelle fenêtre ou un nouvel onglet
R Exercism

Prêt à commencer Journal de bord du capitaine ?

Inscris-toi sur Exercism pour apprendre et maîtriser R avec 21 concepts111 exercices, et un vrai mentorat humain, le tout gratuitement.