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




random integer (25)

मुझे यह उदाहरण मिला यादृच्छिक संख्याएं उत्पन्न करें :

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

import java.util.Random;

/** Generate random integers in a certain range. */
public final class RandomRange {

  public static final void main(String... aArgs){
    log("Generating random integers in the range 1..10.");

    int START = 1;
    int END = 10;
    Random random = new Random();
    for (int idx = 1; idx <= 10; ++idx){
      showRandomInteger(START, END, random);
    }

    log("Done.");
  }

  private static void showRandomInteger(int aStart, int aEnd, Random aRandom){
    if ( aStart > aEnd ) {
      throw new IllegalArgumentException("Start cannot exceed End.");
    }
    //get the range, casting to long to avoid overflow problems
    long range = (long)aEnd - (long)aStart + 1;
    // compute a fraction of the range, 0 <= frac < range
    long fraction = (long)(range * aRandom.nextDouble());
    int randomNumber =  (int)(fraction + aStart);    
    log("Generated : " + randomNumber);
  }

  private static void log(String aMessage){
    System.out.println(aMessage);
  }
} 

इस वर्ग का एक उदाहरण रन:

Generating random integers in the range 1..10.
Generated : 9
Generated : 3
Generated : 3
Generated : 9
Generated : 4
Generated : 1
Generated : 3
Generated : 9
Generated : 10
Generated : 10
Done.

मैं एक विशिष्ट सीमा में एक यादृच्छिक 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`.

मुझे 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));
    }
}

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


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

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

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



उपयोग:

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

केवल यादृच्छिक के बजाय SecureRandom का उपयोग करना बेहतर है।

public static int generateRandomInteger(int min, int max) {
    SecureRandom rand = new SecureRandom();
    rand.setSeed(new Date().getTime());
    int randomNum = rand.nextInt((max - min) + 1) + min;
    return randomNum;
}

समावेशी / अनन्य सीमाओं के किसी संयोजन के साथ सीमा में यादृच्छिक ints उत्पन्न करने के लिए यहां एक सहायक वर्ग है:

import java.util.Random;

public class RandomRange extends Random {
    public int nextIncInc(int min, int max) {
        return nextInt(max - min + 1) + min;
    }

    public int nextExcInc(int min, int max) {
        return nextInt(max - min) + 1 + min;
    }

    public int nextExcExc(int min, int max) {
        return nextInt(max - min - 1) + 1 + min;
    }

    public int nextIncExc(int min, int max) {
        return nextInt(max - min) + min;
    }
}

int random = minimum + Double.valueOf(Math.random()*(maximum-minimun)).intValue();

या अपाचे कॉमन्स से RandomUtils पर एक नज़र डालें।


जावा 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);

ध्यान दें कि यह दृष्टिकोण 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))

उपयोग:

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

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


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

face = 1 + randomNumbers.nextInt(6);

जावा 1.7 या बाद में , ऐसा करने का मानक तरीका इस प्रकार है:

import java.util.concurrent.ThreadLocalRandom;

// nextInt is normally exclusive of the top value,
// so add 1 to make it inclusive
int randomNum = ThreadLocalRandom.current().nextInt(min, max + 1);

प्रासंगिक जावाडोक देखें। इस दृष्टिकोण का एक java.util.Random उदाहरण को स्पष्ट रूप से प्रारंभ करने की आवश्यकता नहीं है, जो गलत तरीके से उपयोग किए जाने पर भ्रम और त्रुटि का स्रोत हो सकता है।

हालांकि, इसके विपरीत बीज को स्पष्ट रूप से सेट करने का कोई तरीका नहीं है, इसलिए उन परिस्थितियों में परिणाम पुन: उत्पन्न करना मुश्किल हो सकता है जहां यह उपयोगी है जैसे खेल राज्यों या इसी तरह की जांच या सहेजना। उन परिस्थितियों में, नीचे दिखाए गए पूर्व-जावा 1.7 तकनीक का उपयोग किया जा सकता है।

जावा 1.7 से पहले , ऐसा करने का मानक तरीका इस प्रकार है:

import java.util.Random;

/**
 * Returns a pseudo-random number between min and max, inclusive.
 * The difference between min and max can be at most
 * <code>Integer.MAX_VALUE - 1</code>.
 *
 * @param min Minimum value
 * @param max Maximum value.  Must be greater than min.
 * @return Integer between min and max, inclusive.
 * @see java.util.Random#nextInt(int)
 */
public static int randInt(int min, int max) {

    // NOTE: This will (intentionally) not run as written so that folks
    // copy-pasting have to think about how to initialize their
    // Random instance.  Initialization of the Random instance is outside
    // the main scope of the question, but some decent options are to have
    // a field that is initialized once and then re-used as needed or to
    // use ThreadLocalRandom (if using at least Java 1.7).
    // 
    // In particular, do NOT do 'Random rand = new Random()' here or you
    // will get not very good / not very random results.
    Random rand;

    // nextInt is normally exclusive of the top value,
    // so add 1 to make it inclusive
    int randomNum = rand.nextInt((max - min) + 1) + min;

    return randomNum;
}

प्रासंगिक जावाडोक देखें। अभ्यास में, java.util.Random क्लास java.lang.Math.random() लिए अक्सर बेहतर है।

विशेष रूप से, कार्य को पूरा करने के लिए मानक लाइब्रेरी के भीतर सीधी एपीआई होने पर यादृच्छिक पूर्णांक पीढ़ी के पहिये को फिर से शुरू करने की कोई आवश्यकता नहीं है।


उपयोग करने के लिए यह विधियां सुविधाजनक हो सकती हैं:

यह विधि प्रदत्त न्यूनतम और अधिकतम मान के बीच एक यादृच्छिक संख्या लौटाएगी:

public static int getRandomNumberBetween(int min, int max) {
    Random foo = new Random();
    int randomNumber = foo.nextInt(max - min) + min;
    if (randomNumber == min) {
        // Since the random number is between the min and max values, simply add 1
        return min + 1;
    } else {
        return randomNumber;
    }
}

और यह विधि प्रदान किए गए न्यूनतम और अधिकतम मूल्य से एक यादृच्छिक संख्या लौटाएगी (इसलिए जेनरेट किया गया नंबर भी न्यूनतम या अधिकतम संख्या हो सकता है):

public static int getRandomNumberFrom(int min, int max) {
    Random foo = new Random();
    int randomNumber = foo.nextInt((max + 1) - min) + min;

    return randomNumber;
}

एक उदाहरण लेते हैं।

मान लीजिए कि मैं 5-10 के बीच एक संख्या उत्पन्न करना चाहता हूं:

int max = 10;
int min = 5;
int diff = max - min;
Random rn = new Random();
int i = rn.nextInt(diff + 1);
i += min;
System.out.print("The Random Number is " + i);

आइए इसे समझें ...

न्यूनतम मूल्य के साथ अधिकतम मूल्य और न्यूनतम के साथ अधिकतम आरंभ करें।

अब, हमें यह निर्धारित करने की आवश्यकता है कि कितने संभावित मूल्य प्राप्त किए जा सकते हैं। इस उदाहरण के लिए, यह होगा:

5, 6, 7, 8, 9, 10

तो, इसकी गणना अधिकतम - न्यूनतम + 1 होगी।

यानी 10 - 5 + 1 = 6

यादृच्छिक संख्या 0-5 के बीच एक संख्या उत्पन्न करेगा।

यानी 0, 1, 2, 3, 4, 5

यादृच्छिक संख्या में न्यूनतम मान जोड़ना उत्पादन करेगा:

5, 6, 7, 8, 9, 10

इसलिए हम वांछित सीमा प्राप्त करते हैं।


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

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

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


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);
}

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


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 हैं।

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


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

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

यहां एक साधारण नमूना है जो दिखाता है कि बंद [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;
    }
}

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

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) देखें


यहां कुछ आसान एक लाइनर हैं। लंबाई निर्धारित करने के लिए new Array(5) बदलें।

0-9a-z सहित

new Array(5).join().replace(/(.|$)/g, function(){return ((Math.random()*36)|0).toString(36);})

0-9a-zA-Z सहित

new Array(5).join().replace(/(.|$)/g, function(){return ((Math.random()*36)|0).toString(36)[Math.random()<.5?"toString":"toUpperCase"]();});




java random integer