Sannolikhet

    randomInteger = random() % range

#include <random>
#include <iostream>
                                                                                                                                                                                                                   
#define PERCENT_WIN_CHANCE  8u
#define ROUNDS              100u

int main()
    {
    // Get some "real" random value, generated in HW on modern ARMs and x86                                                                                                                                        
    // CPUs. Reading this device is quite expensive.                                                                                                                                                               
    //                                                                                                                                                                                                             
    // https://en.wikipedia.org/wiki/RdRand                                                                                                                                                                        
    //                                                                                                                                                                                                             
    // On an Intel Core i7-7700K, 4500 MHz (45 x 100 MHz) processor (Kaby                                                                                                                                          
    // Lake-S microarchitecture), a single RDRAND or RDSEED instruction takes                                                                                                                                      
    // 110ns or 463 clock cycles, regardless of the operand size (16/32/64                                                                                                                                         
    // bits). This number of clock cycles applies to all processors with                                                                                                                                           
    // Skylake or Kaby Lake microarchitecture. On the Silvermont                                                                                                                                                   
    // microarchitecture processors, each of the instructions take around 1472                                                                                                                                     
    // clock cycles, regardless of the operand size; and on Ivy Bridge                                                                                                                                             
    // processors it takes up to 117 clock cycles.[18]                                                                                                                                                             
    //                                                                                                                                                                                                             
    // On an AMD Ryzen CPU, each of the instructions takes around 1200 clock                                                                                                                                       
    // cycles for 16-bit or 32-bit operand, and around 2500 clock cycles for a                                                                                                                                     
    // 64-bit operand.                                                                                                                                                                                             
    std::random_device rndDev;

    // As it is slow to read from random devices, such device should only be                                                                                                                                       
    // used to generate a good seed to a function that can generate a pseudo                                                                                                                                       
    // random series that satisfies the required statistical properties.                                                                                                                                           
    //                                                                                                                                                                                                             
    // This example uses Mersenne Twister:                                                                                                                                                                         
    // https://en.wikipedia.org/wiki/Mersenne_Twister                                                                                                                                                              
    std::mt19937 rndGen(rndDev());

    // Clamp the random number generated into an _uniform_ integer range                                                                                                                                            
    // [1..100] (represent minim chance to win for counting as a win in this                                                                                                                                       
    // example).                                                                                                                                                                                                   
    std::uniform_int_distribution<unsigned> dist(1, 100);

    // Run the simulation for ROUNDS rounds.                                                                                                                                                                       
    auto wins = 0u;
    for (auto round = 0u; round < ROUNDS; round++)
        {
        auto randomInt = dist(rndGen);
        if (randomInt <= PERCENT_WIN_CHANCE)
            {
            wins++;
            }
        }

    std::cout << wins
              << " wins in "  << ROUNDS
              << " rounds with "  << PERCENT_WIN_CHANCE << "% to win."
              << std::endl;
    }