जावा
खबरदार, यह एक ट्रिक सवाल है .....
जावा में अधिकांश लोग इस अनुक्रम को उत्पन्न करने में मदद करने के लिए math.random () का उपयोग करेंगे, लेकिन वे भ्रमित हो जाएंगे क्योंकि वे केवल सकारात्मक परिणाम प्राप्त करेंगे! random()दशमलव मान 0 से 1 तक (केवल स्वयं को छोड़कर) लौटाता है। इसलिए, आपको यह सुनिश्चित करने के लिए कुछ चालें चलानी होंगी कि आपको पूरे पूर्णांक रेंज (सकारात्मक और नकारात्मक) से यादृच्छिक मूल्यों का अच्छा वितरण प्राप्त हो।
इसके अलावा, आप बस गुणा नहीं कर सकते Math.random() और Integer.MAX_VALUEक्योंकि आप इसे कभी Integer.MAX_VALUEभी परिणाम के हिस्से के रूप में शामिल नहीं करेंगे! इसके अलावा, ऐसा करना तर्कसंगत होगा math.rand() * (Integer.MAX_VALUE + 1)ताकि आपको पूर्ण वितरण मिल जाए, लेकिन, निश्चित रूप से, यह काम नहीं करता है क्योंकि Integer.MAX_VALUE + 1अतिप्रवाह होगा, और बन जाएगाInteger.MIN_VALUE ! इसलिए, दुर्भाग्य से, सबसे अच्छा समाधान डेटा के बिट-वार हेरफेर का सहारा लेना है ...
तो, यहाँ 'n' यादृच्छिक मान उत्पन्न करने के लिए एक पूर्ण अनुक्रम Integer.MIN_VALUEहै Integer.MAX_VALUE(दोनों चरमों को सम्मिलित करता है (जो कि कठिन भाग है !!!!):
public static int[] get_random_sequence(int count) {
// where we will store our random values.
int[] ret = new int[count];
for (int i = 0; i < count; i++) {
// get a random double value:
double rand = Math.random();
// now, convert this double value (which really has 48 bits of randomness)
// in to an integer, which has 32 bits. Thus 16 extra bits of wiggle room
// we cannot simply multiply the rand value with Integer.MAX_VALUE
// because we will never actually get Integer.MAX_VALUE
// (since the rand will never exactly == 1.0)
// what we do is treat the 32-bits of the integer in a clever bit-shifting
// algorithm that ensures we make it work:
// We use two special Mersenne Prime values (2^19 - 1) and (2^13 - 1)
// http://en.wikipedia.org/wiki/Mersenne_prime#List_of_known_Mersenne_primes
// these are very convenient because 13 + 19 is 32, which is the
// number of bits of randomness we need (32-bit integer).
// Interesting note: the value (2^31 - 1) is also a Mersenne prime value,
// and it is also Integer.MAX_VALUE. Also, it is a double marsenne prime
// since 31 is also a marsenne prime... (2^(2^5 - 1) - 1). Math is Cool!!!
// 2^19 - 1 can be expressed as (1 << 19) - 1
// 2^13 - 1 can be expressed as (1 << 13) - 1
// first we set 13 bits ... multiply a 13-bit prime by the random number.
ret[i] = (int)(rand * (1 << 13) - 1);
// now shift those 13 random bits 19 bits left:
ret[i] <<= 19;
// now add in the 19 random bits:
ret[i] ^= (int)(rand * (1 << 19) - 1);
}
return ret;
}
यह उत्पादन जैसे:
[-368095066, -1128405482, 1537924507, -1864071334, -130039258, 2020328364, -2028717867, 1796954379, 276857934, -1378521391]
बेशक, ऊपर एक पूर्ण बीएस जवाब है। यह एक अच्छा विवरण नहीं देता है, और यह एक गंभीर बग (छिपाना ) ^=चाहिए |=। यह कम-से-कम बग को भी छिपाता है (ऑर्डर-पीएफ-पूर्वता का मतलब है कि हम वास्तव में एक प्रमुख मूल्य से बिल्कुल भी गुणा नहीं करते हैं!) फैंसी शब्दों, अभाज्य संख्याओं और बहुत सारी टिप्पणियों का उपयोग करके कोड पर भरोसा करने का कोई कारण नहीं है ... बेशक, यदि आप ऊपर करना चाहते हैं, तो आपको बस उपयोग करना चाहिएjava.util.Random.nextInt()