java - जावा में किसी विशिष्ट श्रेणी के भीतर यादृच्छिक पूर्णांक कैसे उत्पन्न करें?




random integer (20)

जावा 7 के रूप में, आपको अब Random उपयोग नहीं करना चाहिए। अधिकांश उपयोगों के लिए, पसंद का यादृच्छिक संख्या जेनरेटर अब ThreadLocalRandom

कांटा पूल और समांतर धाराओं में शामिल होने के लिए, SplittableRandom उपयोग SplittableRandom

जोशुआ ब्लोच प्रभावी जावा तीसरा संस्करण।

जावा 8 से शुरू हो रहा है

कांटा पूल और समांतर धाराओं में शामिल होने के लिए, SplittableRandom उपयोग SplittableRandom जो आमतौर पर तेज़ होता है, Random तुलना में बेहतर सांख्यिकीय स्वतंत्रता और एकरूपता गुण होता है।

सीमा [0, 1_000]: में एक यादृच्छिक int उत्पन्न करने के लिए [0, 1_000]:

int n = new SplittableRandom().nextInt(0, 1_001);

श्रेणी [0, 1_000]: में मानों की एक यादृच्छिक int[100] सरणी उत्पन्न करने के लिए [0, 1_000]:

int[] a = new SplittableRandom().ints(100, 0, 1_001).parallel().toArray();

यादृच्छिक मानों के स्ट्रीम को वापस करने के लिए:

IntStream stream = new SplittableRandom().ints(100, 0, 1_001);

https://code.i-harness.com

मैं एक विशिष्ट सीमा में एक यादृच्छिक int मान कैसे उत्पन्न करूं?

मैंने निम्नलिखित की कोशिश की है, लेकिन वे काम नहीं करते हैं:

प्रयास 1:

randomNum = minimum + (int)(Math.random() * maximum);
// Bug: `randomNum` can be bigger than `maximum`.

प्रयास 2:

Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt() % n;
randomNum =  minimum + i;
// Bug: `randomNum` can be smaller than `minimum`.

Multreadreaded वातावरण के लिए java.util.Random कक्षा के ThreadLocalRandom समकक्ष। एक यादृच्छिक संख्या उत्पन्न करना प्रत्येक धागे में स्थानीय रूप से किया जाता है। तो संघर्षों को कम करके हमारे पास बेहतर प्रदर्शन है।

int rand = ThreadLocalRandom.current().nextInt(x,y);

एक्स, वाई - अंतराल उदाहरण (1,10)


आप जावा 8 में संक्षेप में प्राप्त कर सकते हैं:

Random random = new Random();

int max = 10;
int min = 5;
int totalNumber = 10;

IntStream stream = random.ints(totalNumber, min, max);
stream.forEach(System.out::println);

आपके पहले समाधान का बस एक छोटा सा संशोधन पर्याप्त होगा।

Random rand = new Random();
randomNum = minimum + rand.nextInt((maximum - minimum) + 1);

Random कार्यान्वयन के लिए यहां और देखें


उपयोग:

Random ran = new Random();
int x = ran.nextInt(6) + 5;

पूर्णांक x अब यादृच्छिक संख्या है जिसका 5-10 का संभावित परिणाम है।


उपयोग:

minimum + rn.nextInt(maxValue - minvalue + 1)

एक और विकल्प अपाचे कॉमन्स का उपयोग कर रहा है:

import org.apache.commons.math.random.RandomData;
import org.apache.commons.math.random.RandomDataImpl;

public void method() {
    RandomData randomData = new RandomDataImpl();
    int number = randomData.nextInt(5, 10);
    // ...
 }

एक पासा रोलिंग के मामले में यह 1 से 6 (0 से 6 नहीं) के बीच यादृच्छिक संख्या होगी, इसलिए:

face = 1 + randomNumbers.nextInt(6);

जब आपको बहुत यादृच्छिक संख्या की आवश्यकता होती है, तो मैं एपीआई में यादृच्छिक वर्ग की अनुशंसा नहीं करता हूं। यह सिर्फ एक बहुत ही छोटी अवधि है। इसके बजाय मेर्सन ट्विस्टर आज़माएं। एक जावा कार्यान्वयन है


ध्यान दें कि यह दृष्टिकोण nextInt दृष्टिकोण से अधिक पक्षपातपूर्ण और कम कुशल है, https://.com/a/738651/360211

इसे पूरा करने के लिए एक मानक पैटर्न है:

Min + (int)(Math.random() * ((Max - Min) + 1))

Java मैथ लाइब्रेरी फ़ंक्शन Math.random () श्रेणी [0,1) में एक डबल मान उत्पन्न करता है। ध्यान दें कि इस श्रेणी में 1 शामिल नहीं है।

पहले मूल्यों की एक विशिष्ट श्रेणी प्राप्त करने के लिए, आपको उन मूल्यों की सीमा के गुणा से गुणा करना होगा जिन्हें आप कवर करना चाहते हैं।

Math.random() * ( Max - Min )

यह रेंज [0,Max-Min) में एक मान देता है, जहां 'मैक्स-मिन' शामिल नहीं है।

उदाहरण के लिए, यदि आप [5,10) चाहते हैं, तो आपको पांच पूर्णांक मानों को कवर करने की आवश्यकता है ताकि आप इसका उपयोग कर सकें

Math.random() * 5

यह सीमा [0,5) में एक मान वापस करेगा, जहां 5 शामिल नहीं है।

अब आपको इस श्रेणी को उस सीमा तक स्थानांतरित करने की आवश्यकता है जिसे आप लक्षित कर रहे हैं। आप न्यूनतम मान जोड़कर ऐसा करते हैं।

Min + (Math.random() * (Max - Min))

अब आपको श्रेणी [Min,Max) में एक मूल्य मिलेगा। हमारे उदाहरण के बाद, इसका मतलब है [5,10) :

5 + (Math.random() * (10 - 5))

लेकिन, इसमें अभी भी Max शामिल नहीं है और आपको दोहरा मूल्य मिल रहा है। Max मान को शामिल करने के लिए, आपको अपने रेंज पैरामीटर (Max - Min) 1 जोड़ना होगा और फिर int को कास्टिंग करके दशमलव भाग को छोटा करना होगा। यह के माध्यम से पूरा किया जाता है:

Min + (int)(Math.random() * ((Max - Min) + 1))

आखिर तुमने इसे हासिल कर ही लिया है। श्रेणी [Min,Max] , या उदाहरण के अनुसार एक यादृच्छिक पूर्णांक मान [5,10] :

5 + (int)(Math.random() * ((10 - 5) + 1))

मुझे min + rng.nextInt(max - min + 1)) होने के लिए क्षमा करें, लेकिन बहुमत द्वारा सुझाए गए समाधान, यानि, min + rng.nextInt(max - min + 1)) , इस तथ्य के कारण खतरनाक लगता है कि:

  • rng.nextInt(n) Integer.MAX_VALUE तक नहीं पहुंच सकता है।
  • (max - min) min नकारात्मक होने पर अतिप्रवाह हो सकता है।

एक मूर्खतापूर्ण समाधान किसी भी min <= max [ Integer.MIN_VALUE , Integer.MAX_VALUE ] के भीतर सही परिणाम लौटाएगा। निम्नलिखित निष्पक्ष कार्यान्वयन पर विचार करें:

int nextIntInRange(int min, int max, Random rng) {
   if (min > max) {
      throw new IllegalArgumentException("Cannot draw random int from invalid range [" + min + ", " + max + "].");
   }
   int diff = max - min;
   if (diff >= 0 && diff != Integer.MAX_VALUE) {
      return (min + rng.nextInt(diff + 1));
   }
   int i;
   do {
      i = rng.nextInt();
   } while (i < min || i > max);
   return i;
}

हालांकि अक्षम, ध्यान दें कि while लूप में सफलता की संभावना हमेशा 50% या उससे अधिक होगी।



यदि आप ऊपर दिए गए अधिकांश वोटों के साथ उत्तर का प्रयास करना चाहते हैं, तो आप बस इस कोड का उपयोग कर सकते हैं:

public class Randomizer
{
    public static int generate(int min,int max)
    {
        return min + (int)(Math.random() * ((max - min) + 1));
    }

    public static void main(String[] args)
    {
        System.out.println(Randomizer.generate(0,10));
    }
}

यह सिर्फ साफ और सरल है।


यहां एक साधारण नमूना है जो दिखाता है कि बंद [min, max] सीमा से यादृच्छिक संख्या कैसे उत्पन्न करें, जबकि min <= max is true

आप इसे छेद वर्ग में फ़ील्ड के रूप में पुन: उपयोग कर सकते हैं, जिसमें एक ही स्थान पर सभी Random.class विधियां भी हो Random.class

परिणाम उदाहरण:

RandomUtils random = new RandomUtils();
random.nextInt(0, 0); // returns 0
random.nextInt(10, 10); // returns 10
random.nextInt(-10, 10); // returns numbers from -10 to 10 (-10, -9....9, 10)
random.nextInt(10, -10); // throws assert

सूत्रों का कहना है:

import junit.framework.Assert;
import java.util.Random;

public class RandomUtils extends Random {

    /**
     * @param min generated value. Can't be > then max
     * @param max generated value
     * @return values in closed range [min, max].
     */
    public int nextInt(int min, int max) {
        Assert.assertFalse("min can't be > then max; values:[" + min + ", " + max + "]", min > max);
        if (min == max) {
            return max;
        }

        return nextInt(max - min + 1) + min;
    }
}

nextint(n) विधि का उपयोग करके न्यूनतम और अधिकतम के अंतर के लिए एक यादृच्छिक संख्या उत्पन्न करें और फिर परिणाम में न्यूनतम संख्या जोड़ें:

Random rn = new Random();
int result = rn.nextInt(max - min + 1) + min;
System.out.println(result);

Math.RandomJava में Math.Random वर्ग 0-आधारित है। तो, अगर आप ऐसा कुछ लिखते हैं:

Random rand = new Random();
int x = rand.nextInt(10);

x 0-9 समावेशी के बीच होगा।

इसलिए, 25 आइटमों के निम्नलिखित सरणी को देखते हुए, 0 (सरणी का आधार) और array.length बीच एक यादृच्छिक संख्या उत्पन्न करने के लिए कोड होगा:

String[] i = new String[25];
Random rand = new Random();
int index = 0;

index = rand.nextInt( i.length );

चूंकि i.length 25 वापस आ जाएगा, nextInt( i.length ) 0-24 की सीमा के बीच एक संख्या वापस कर देगा। दूसरा विकल्प Math.Random साथ जा रहा है जो एक ही तरीके से काम करता है।

index = (int) Math.floor(Math.random() * i.length);

बेहतर समझने के लिए, फोरम पोस्ट रैंडम इंटरवल (archive.org) देखें


java-8 उन्होंने Random क्लास में विधि ints(int randomNumberOrigin, int randomNumberBound) पेश किया।

उदाहरण के लिए यदि आप सीमा [0, 10] में पांच यादृच्छिक पूर्णांक (या एक एकल) उत्पन्न करना चाहते हैं, तो बस करें:

Random r = new Random();
int[] fiveRandomNumbers = r.ints(5, 0, 11).toArray();
int randomNumber = r.ints(1, 0, 11).findFirst().getAsInt();

पहला पैरामीटर केवल IntStream जेनरेट किया गया आकार इंगित करता है (जो एक असीमित IntStream उत्पन्न करने वाली ओवरलोडेड विधि है)।

यदि आपको कई अलग-अलग कॉल करने की आवश्यकता है, तो आप स्ट्रीम से एक अनंत आदिम इटरेटर बना सकते हैं:

public final class IntRandomNumberGenerator {

    private PrimitiveIterator.OfInt randomIterator;

    /**
     * Initialize a new random number generator that generates
     * random numbers in the range [min, max]
     * @param min - the min value (inclusive)
     * @param max - the max value (inclusive)
     */
    public IntRandomNumberGenerator(int min, int max) {
        randomIterator = new Random().ints(min, max + 1).iterator();
    }

    /**
     * Returns a random number in the range (min, max)
     * @return a random number in the range (min, max)
     */
    public int nextInt() {
        return randomIterator.nextInt();
    }
}

आप इसे double और long मानों के लिए भी कर long हैं।

आशा करता हूँ की ये काम करेगा! :)


 rand.nextInt((max+1) - min) + min;

private static Random random = new Random();    

public static int getRandomInt(int min, int max){
  return random.nextInt(max - min + 1) + min;
}

या

public static int getRandomInt(Random random, int min, int max)
{
  return random.nextInt(max - min + 1) + min;
}

public static Random RANDOM = new Random(System.nanoTime());

public static final float random(final float pMin, final float pMax) {
    return pMin + RANDOM.nextFloat() * (pMax - pMin);
}





integer