किसी दिए गए संभाव्यता के साथ सच या गलत हो जाओ

मैं c ++ में एक फ़ंक्शन लिखने की कोशिश कर रहा हूं जो दी गई संभावना के आधार पर सत्य या गलत लौटाएगा। इसलिए, उदाहरण के लिए यदि संभाव्यता 0.634 थी, तो समारोह का 63.4% कार्य सही होगा। मैंने कुछ अलग चीजों की कोशिश की है, और असफल रहा। कोई मदद?

0
आपने बिल्कुल क्या प्रयास किया है?
जोड़ा लेखक jogojapan, स्रोत
जोड़ा लेखक jogojapan, स्रोत

2 उत्तर

#include 
bool prob_true(double p){
    return rand()/(RAND_MAX+1.0) < p;
}

तर्क:

rand() returns a random number between 0 and RAND_MAX (including both), with equal probability for each number. So by dividing the result by RAND_MAX we get a random number between 0 and 1. This allows us to choose a area of - in your example 63.4% of this segment, e.g. from 0 to 0.634 - and check if the result fell in that area.

Now comes the tricky part: we don't want to get both 0 and 1! Why? Because we want probability 0 to never be true, that's why we need the (rather than the <=p) - so that when p=0 you'll never get true.

However, if you can also have 1 as the result, then in the case where p=1 there is a very small chance you get false!

That's why instead of dividing by MAX_RAND you divide by MAX_RAND+1.0. Also note that I added 1.0 instead of 1 to turn the number into a double (otherwise I might get an overflow if MAX_RAND==INT_MAX)

Finally, here's an alternate implementation without the division:

#include 
bool prob_true(double p){
    return rand() < p * (RAND_MAX+1.0);
}
0
जोड़ा
@ बिटफिडलिंगकोडमोन्की दुह! इसे ठीक करना: /
जोड़ा लेखक rabensky, स्रोत
क्या आपको rand() कॉल करना चाहिए?
जोड़ा लेखक Fiddling Bits, स्रोत

यदि आप इसे C ++ 11 में करना चाहते हैं, तो आप अच्छे परिणाम प्रदान करने के लिए uniform_real_distribution के साथ संयुक्त अपने विभिन्न यादृच्छिक संख्या इंजन का उपयोग कर सकते हैं। निम्नलिखित कोड दर्शाता है:

#include 

std::knuth_b rand_engine; //replace knuth_b with one of the engines listed below
std::uniform_real_distribution<> uniform_zero_to_one(0.0, 1.0);

bool random_bool_with_prob( double prob ) //probability between 0.0 and 1.0
{
    return uniform_zero_to_one(rand_engine) >= prob;
}

वैकल्पिक रूप से, आप bernoulli_distribution का उपयोग कर सकते हैं, जो आपको निर्दिष्ट संभावना के साथ सीधे bool देता है। यह संभव है कि यह वापस करने की संभावना सच लौटने की संभावना है, इसलिए यह वही है जो आपको चाहिए:

#include 

std::knuth_b rand_engine; //replace knuth_b with one of the engines listed below

bool random_bool_with_prob( double prob ) //probability between 0.0 and 1.0
{
    std::bernoulli_distribution d(prob);
    return d(rand_engine);
}

यदि आपकी संभावना तय की गई है, तो आप इसे फ़ंक्शन से बाहर ले जा सकते हैं:

#include 

std::knuth_b rand_engine; //replace knuth_b with one of the engines listed below
std::bernoulli_distribution random_bool_generator( prob ); //replace "prob" with your probability

bool random_bool()
{
    return random_bool_generator( rand_engine );
}

या यदि आप अभी भी फैनसीयर प्राप्त करना चाहते हैं, तो आप उन्हें एक साथ जोड़ सकते हैं:

#include 
#include 

std::knuth_b rand_engine; //replace knuth_b with one of the engines listed below
std::bernoulli_distribution random_bool_generator( prob ); //replace "prob" with your probability

auto random_bool = std::bind( random_bool_generator, rand_engine )

// Now call random_bool() to get your random boolean with the specified probability.

आप किसी भी मानक इंजन के साथ knuth_b को प्रतिस्थापित कर सकते हैं:

  • std :: linear_congruential_engine
  • std :: mersenne_twister_engine
  • std :: subtract_with_carry_engine

या कई और, जो ऊपर के संस्करण हैं, विभिन्न तरीकों को पैरामीटरकृत करते हैं। मेरा संदर्भ निम्नलिखित सूचीबद्ध करता है:

  • std::default_random_engine (Implementation defined.)
  • std::minstd_rand0
  • std::minstd_rand
  • std::mt19937
  • std::mt19337_64
  • std::ranlux24_base
  • std::ranlux48_base
  • std::ranlux24
  • std::ranlux48
  • std::knuth_b

और यदि वह पर्याप्त नहीं है, तो कुछ मानक एडाप्टर हैं जो यादृच्छिक संख्या अनुक्रम को आगे बढ़ा सकते हैं:

  • std::discard_block_engine which adapts an engine by discarding a given number of generated values each time.
  • std::independent_bits_engine which adapts an engine to produce random values with a specified number of bits. (Not important to your particular need.)
  • std::shuffle_order_engine which adapts an engine by permutation of the order of their generated values.

The generators in the second list are derived from the base generators in the first list, either with specific parameters, adaptors or both. For example, knuth_b is equivalent to shuffle_order_engine< linear_congruential_engine< uint32_t, 16807, 0, 2147483647>, 256>, according to my reference book. (The C++ Standard Library, Second Edition, by Nicolai Josuttis, a great reference work.)

आप इस संक्षिप्त परिचय सहित ऑनलाइन अधिक जानकारी प्राप्त कर सकते हैं: http: //en.wikipedia .org/wiki/सी ++ 11 # Extensible_random_number_facility

There's more documentation here: http://en.cppreference.com/w/cpp/numeric/random

आप बीज प्रदान करने के लिए उपरोक्त rand_engine की घोषणा को संशोधित करना चाहते हैं। उपरोक्त उदाहरण डिफ़ॉल्ट बीज का उपयोग करता है। यदि आप एक अलग बीज चाहते हैं तो इसे बीज कैसे करें इसके लिए cppreference.com देखें।

0
जोड़ा
@ ब्लास्टफर्नस: आप सही हैं। किसी भी तरह से मुझे याद आया। मैं ऊपर संपादित करूँगा।
जोड़ा लेखक Joe Z, स्रोत
std :: bernoulli_distribution करेगा ठीक है कि उसे std :: uniform_real_distribution से बेहतर क्या चाहिए।
जोड़ा लेखक Blastfurnace, स्रोत