C++ Academy · Leçon

Exemples pratiques

Dés, mélanges et échantillonnage

Exemples pratiques est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Lancer des dés

Un dé à six faces est une uniform_int_distribution(1, 6) alimentée par un moteur initialisé avec un seed.

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen(2026);
    std::uniform_int_distribution<int> die(1, 6);
    for (int i = 0; i < 5; ++i) std::cout << die(gen) << ' ';
    std::cout << '\n';
    return 0;
}

Additionner deux dés

Lancer deux dés et additionner leurs résultats produit la plage familière de 2 à 12, avec un maximum à 7.

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen(1);
    std::uniform_int_distribution<int> die(1, 6);
    int total = die(gen) + die(gen);
    std::cout << "two dice sum: " << total << '\n';
    return 0;
}

Lancer une pièce

Une pièce équilibrée est une bernoulli_distribution(0.5). Comptez le nombre de faces sur de nombreux lancers.

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen(7);
    std::bernoulli_distribution coin(0.5);
    int heads = 0;
    for (int i = 0; i < 100; ++i) if (coin(gen)) ++heads;
    std::cout << heads << " heads out of 100\n";
    return 0;
}

Mélanger un jeu de cartes

std::shuffle réordonne aléatoirement une plage à l’aide de votre moteur ; c’est le remplacement moderne de random_shuffle, qui a été supprimé.

#include <iostream>
#include <random>
#include <algorithm>
#include <vector>

int main() {
    std::vector<int> cards{1, 2, 3, 4, 5};
    std::mt19937 gen(3);
    std::shuffle(cards.begin(), cards.end(), gen);
    for (int c : cards) std::cout << c << ' ';
    std::cout << '\n';
    return 0;
}

Sélectionner un gagnant aléatoire

Sélectionnez un élément en générant un indice aléatoire dans la plage.

#include <iostream>
#include <random>
#include <vector>
#include <string>

int main() {
    std::vector<std::string> names{"Ann", "Ben", "Cara", "Dan"};
    std::mt19937 gen(9);
    std::uniform_int_distribution<int> pick(0, names.size() - 1);
    std::cout << "winner: " << names[pick(gen)] << '\n';
    return 0;
}

Échantillonnage sans remise

std::sample tire k éléments distincts d’une plage, ce qui convient parfaitement à une loterie ou à la sélection de questions pour un quiz.

#include <iostream>
#include <random>
#include <algorithm>
#include <vector>

int main() {
    std::vector<int> pool{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::vector<int> picked;
    std::mt19937 gen(4);
    std::sample(pool.begin(), pool.end(), std::back_inserter(picked), 3, gen);
    for (int x : picked) std::cout << x << ' ';
    std::cout << '\n';
    return 0;
}

Caractères de mot de passe aléatoires

Utilisez un indice dans un jeu de caractères avec une distribution uniforme pour construire une chaîne aléatoire.

#include <iostream>
#include <random>
#include <string>

int main() {
    const std::string chars = "abcdefghijklmnopqrstuvwxyz";
    std::mt19937 gen(13);
    std::uniform_int_distribution<int> pick(0, chars.size() - 1);
    std::string pw;
    for (int i = 0; i < 8; ++i) pw += chars[pick(gen)];
    std::cout << pw << '\n';
    return 0;
}

Choix pondéré

std::discrete_distribution sélectionne des indices selon les poids fournis, de sorte que les résultats fréquents apparaissent plus souvent.

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen(6);
    std::discrete_distribution<int> d{10, 1, 1}; // index 0 is heaviest
    int counts[3] = {0};
    for (int i = 0; i < 120; ++i) counts[d(gen)]++;
    std::cout << counts[0] << ' ' << counts[1] << ' ' << counts[2] << '\n';
    return 0;
}

Simuler une marche aléatoire

Avancez aléatoirement vers la gauche ou la droite et suivez la position finale : il s’agit d’une simulation stochastique simple.

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen(2);
    std::bernoulli_distribution step(0.5);
    int pos = 0;
    for (int i = 0; i < 1000; ++i) pos += step(gen) ? 1 : -1;
    std::cout << "final position: " << pos << '\n';
    return 0;
}

Lancer jusqu’à obtenir un six

Bouclez jusqu’à ce qu’un événement se produise pour modéliser des essais ; ici, vous comptez le nombre de lancers nécessaires pour obtenir un six.

#include <iostream>
#include <random>

int main() {
    std::mt19937 gen(15);
    std::uniform_int_distribution<int> die(1, 6);
    int rolls = 0;
    while (die(gen) != 6) ++rolls;
    std::cout << "extra rolls before a six: " << rolls << '\n';
    return 0;
}

Générer des données de test

Les distributions remplissent rapidement un vecteur de valeurs aléatoires pour tester des algorithmes.

#include <iostream>
#include <random>
#include <vector>

int main() {
    std::mt19937 gen(21);
    std::uniform_int_distribution<int> d(1, 50);
    std::vector<int> data(5);
    for (int& v : data) v = d(gen);
    for (int v : data) std::cout << v << ' ';
    std::cout << '\n';
    return 0;
}

Vérification rapide

Testez votre compréhension de l’aléatoire en pratique.

Récapitulatif

Vous avez utilisé <random> en pratique :

dés, pièces et gagnants à l’aide de distributions uniformes et de Bernoulli
std::shuffle pour réordonner et std::sample pour tirer sans remise
discrete_distribution pour les choix pondérés, ainsi que des simulations comme les marches aléatoires

Vous disposez maintenant d’une boîte à outils complète pour les conteneurs associatifs, le hachage, les entrées-sorties de fichiers et l’aléatoire en C++.

Questions Fréquemment Posées

La leçon « Exemples pratiques » est-elle gratuite ?

Oui — le texte complet de « Exemples pratiques » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Exemples pratiques » ?

Dés, mélanges et échantillonnage Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Exemples pratiques » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C++ Academy