జావాలో యాదృచ్ఛిక సంఖ్యలు

1. సూడోరాండమ్ సంఖ్యలు

కొన్నిసార్లు ప్రోగ్రామర్ చాలా సులభమైన పనులను ఎదుర్కొంటాడు: "నిర్దిష్ట జాబితా నుండి యాదృచ్ఛిక చలనచిత్రాన్ని ఎంచుకోండి", "లాటరీ విజేతను ఎంచుకోండి", "వినియోగదారు అతని లేదా ఆమె స్మార్ట్‌ఫోన్‌ను షేక్ చేసినప్పుడు ప్లేజాబితాను షఫుల్ చేయండి", "సందేశాన్ని ఎన్‌క్రిప్ట్ చేయడానికి యాదృచ్ఛిక సంఖ్యను ఎంచుకోండి" , మొదలైనవి. ప్రతి సందర్భంలో, డెవలపర్ ఒక తార్కిక ప్రశ్న అడుగుతాడు: యాదృచ్ఛిక సంఖ్యను ఎలా పొందాలి?

వాస్తవానికి, యాదృచ్ఛిక సంఖ్యను పొందడం చాలా కష్టం. వాస్తవానికి, నిజమైన యాదృచ్ఛికత కోసం అన్ని అవసరాలను తీర్చే సంఖ్యలను రూపొందించడానికి ప్రత్యేక గణిత కోప్రాసెసర్‌లు కొన్ని కంప్యూటర్‌లలో నిర్మించబడటం చాలా కష్టం.

ప్రోగ్రామర్లు వారి స్వంత పరిష్కారంతో ముందుకు వచ్చారు: సూడోరాండమ్ సంఖ్యలు . సూడోరాండమ్ సంఖ్యలు ఒక రకమైన క్రమం, దీని సంఖ్యలు యాదృచ్ఛికంగా కనిపిస్తాయి. అయినప్పటికీ, జాగ్రత్తగా విశ్లేషణ చేయడం ద్వారా, ఒక నిపుణుడు క్రమంలో కొన్ని నమూనాలను కనుగొనవచ్చు. రహస్య పత్రాలను గుప్తీకరించడానికి ఇటువంటి సంఖ్యలు తగినవి కావు, అయితే అవి గేమ్‌లో డై రోల్‌ను అనుకరించడానికి సరిపోతాయి.

సూడోరాండమ్ సంఖ్యల క్రమాన్ని రూపొందించడానికి అనేక అల్గారిథమ్‌లు ఉన్నాయి. దాదాపు అన్నీ మునుపటి సంఖ్య మరియు కొన్ని అదనపు సహాయక సంఖ్యల ఆధారంగా తదుపరి యాదృచ్ఛిక సంఖ్యను ఉత్పత్తి చేస్తాయి.

1000ఉదాహరణకు, ఈ ప్రోగ్రామ్ పునరావృతం కాని సంఖ్యలను ప్రదర్శిస్తుంది :

public class Main
{
   public static int a = 41;
   public static int c = 11119;
   public static int m = 11113;
   public static int seed = 1;

   public static int getNextRandom()
   {
     seed = (a * seed + c) % m;
     return seed;
   }

   public static void main(String[] args)
   {
     for (int i = 0; i < 1000; i++)
     {
       System.out.println(getNextRandom());
     }
   }
}

మార్గం ద్వారా, మేము ఇక్కడ సూడోరాండమ్ సంఖ్యల గురించి మాట్లాడటం లేదు. మేము సూడోరాండమ్ సంఖ్యల క్రమం గురించి మాట్లాడుతున్నాము. ఒక్క సంఖ్యను చూస్తే అది యాదృచ్ఛికమా కాదా అని చెప్పలేము.

నిజానికి, యాదృచ్ఛిక సంఖ్యను పొందడానికి అనేక మార్గాలు ఉన్నాయి:

public static int getRandomNumber()
{
   return 4; // Here's a random number (we got it by rolling a die)
}

2.Math.random()

జావాలో, Mathతరగతి యాదృచ్ఛిక సంఖ్యను అందించే ప్రత్యేక పద్ధతిని కలిగి ఉంది. మరియు మీరు ఊహించినట్లుగా, పద్ధతి అంటారు random. సాధారణంగా, ఈ పద్ధతిని పిలవడం ఇక్కడ కనిపిస్తుంది:

Math.random()

0ఈ పద్దతి ఎటువంటి పారామీటర్‌లను తీసుకోదు మరియు నుండి పరిధిలోని సూడోరాండమ్ వాస్తవ సంఖ్యను అందిస్తుంది 1. 1వ సంఖ్య కూడా పరిధిలో చేర్చబడలేదు.

ఉదాహరణ:

public class Main
{
   public static void main(String[] args)
   {
     for (int i = 0; i < 10; i++)
     {
       System.out.println(Math.random());
     }
   }
} 

0.9703753971734451
0.09979423801773157
0.994048474709053
0.2852203204171295
0.13551248551226025
0.3128547131272822
0.5342480554101412
0.6817369932044817
0.1840767788961758
0.06969563435451254

కానీ ఈ పద్ధతి మీకు అవసరమైనది కాకపోతే ఏమి చేయాలి? మీరు ఆరు-వైపుల డైని రోలింగ్ చేయడాన్ని అనుకరించే ప్రోగ్రామ్‌ను వ్రాయాలనుకుంటున్నారని అనుకుందాం. మీరు 0..1 పరిధిలోని వాస్తవ సంఖ్యలకు బదులుగా 1..6 పరిధిలో యాదృచ్ఛిక పూర్ణాంకాలను ఎలా పొందుతారు?

ఇది నిజానికి చాలా సులభం.

[0, 1)ముందుగా, మీరు పరిధిని మ్యాప్ చేయాలి [0, 6). random()దీన్ని చేయడానికి, ఫలితాన్ని దానితో గుణించండి 6. వాస్తవానికి, పూర్ణాంకాలను పొందడానికి, మీరు పూర్తి చేయాలి:

public class Main
{
   public static int getRandomDieNumber()
   {
      return (int) (Math.random() * 6);
   }

   public static void main(String[] args)
   {
      for (int i = 0; i < 10; i++)
      {
         int x = getRandomDieNumber();
         System.out.println(x);
      }
   }
}

5
2
3
3
2
4
1
1
5
0

getRandomDieNumber()పరిధిని కలుపుకొని యాదృచ్ఛిక పూర్ణాంకాన్ని అందిస్తుంది 0..5. కానీ అది సెట్‌లో నంబర్‌గా ఉండదు 1, 2, 3, 4, 5, 6. ఇది సెట్‌లో ఒక సంఖ్య అవుతుంది 0, 1, 2, 3, 4, 5.

మీకు కావలసినది సెట్‌లోని సంఖ్యలు అయితే 1, 2, 3, 4, 5, 6, యాదృచ్ఛిక సంఖ్యలకు ఒకదాన్ని జోడించండి:

public class Main
{
   public static int getRandomDieNumber()
   {
      return (int) (Math.random() * 6) + 1;
   }

   public static void main(String[] args)
   {
     for (int i = 0; i < 10; i++)
     {
       int x = getRandomDieNumber();
       System.out.println(x);
     }
   }
}

3
2
1
3
6
5
6
1
6
6

ఇప్పుడు అది పరిపూర్ణమైనది!

3. Randomతరగతి

Randomజావాలో సూడోరాండమ్ సంఖ్యల క్రమాన్ని కప్పి ఉంచే ప్రత్యేక తరగతి ఉంది . మీరు తరగతి యొక్క అనేక వస్తువులను సృష్టించవచ్చు Random. ఈ వస్తువులు ప్రతి దాని స్వంత సూడోరాండమ్ సంఖ్యల క్రమాన్ని ఉత్పత్తి చేస్తాయి.

ఇది చాలా ఆసక్తికరమైన పద్ధతులతో కూడిన సూపర్ ఆసక్తికరమైన తరగతి. సరళమైన వాటితో ప్రారంభిద్దాం.

double nextDouble()

ఈ పద్ధతి పరిధిలో యాదృచ్ఛిక వాస్తవ సంఖ్యను అందిస్తుంది 0.0- 1.0. ఇది పద్ధతికి చాలా పోలి ఉంటుంది Math.random(). మరియు ఆశ్చర్యపోనవసరం లేదు, ఎందుకంటే పద్ధతి ఒక వస్తువుపై పద్ధతిని Math.random()పిలుస్తుంది .nextDouble()Random

float nextFloat()

ఈ పద్ధతి పద్ధతికి చాలా పోలి ఉంటుంది nextDouble(), కానీ తిరిగి వచ్చిన యాదృచ్ఛిక సంఖ్య a float. ఇది కూడా పరిధిలో ఉంది 0.0- 1.0. మరియు, ఎల్లప్పుడూ జావాలో, పరిధి సంఖ్యను కలిగి ఉండదు 1.0.

Random r = new Random();
float f = r.nextFloat();

int nextInt(int max)

ఈ పద్ధతి పరిధిలో యాదృచ్ఛిక పూర్ణాంకాన్ని అందిస్తుంది [0, max). 0పరిధిలో చేర్చబడింది, కానీ maxకాదు.

మరో మాటలో చెప్పాలంటే, మీరు సెట్‌లో యాదృచ్ఛిక సంఖ్యను పొందాలనుకుంటే 1, 2, 3, 4, 5, 6, మీరు తిరిగి వచ్చిన యాదృచ్ఛిక సంఖ్యకు ఒకదాన్ని జోడించాలి:

Random r = new Random();
int x = r.nextInt(6) + 1;

int nextInt()

ఈ పద్ధతి మునుపటి మాదిరిగానే ఉంటుంది, కానీ ఇది ఏ పారామితులను తీసుకోదు. కాబట్టి దాని రిటర్న్ విలువల పరిధి ఎంత? నుండి . -2 billion_+2 billion

బాగా, ఖచ్చితంగా చెప్పాలంటే, -2147483648నుండి +2147483647.

long nextLong()

ఈ పద్ధతి పద్ధతిని పోలి ఉంటుంది nextInt(), కానీ రిటర్న్ విలువ s యొక్క మొత్తం సాధ్యమైన పరిధిలో ఎక్కడో పడిపోతుంది long.

boolean nextBoolean()

ఈ పద్ధతి యాదృచ్ఛిక booleanవిలువను అందిస్తుంది: falseలేదా true. మీరు యాదృచ్ఛిక బూలియన్ విలువల యొక్క సుదీర్ఘ క్రమాన్ని పొందవలసి వచ్చినప్పుడు ఇది చాలా సౌకర్యవంతంగా ఉంటుంది.

void nextBytes(byte[] data)

ఈ పద్ధతి ఏదీ తిరిగి ఇవ్వదు (రిటర్న్ రకం కాబట్టి void). బదులుగా, ఇది పాస్ చేసిన శ్రేణిని యాదృచ్ఛిక విలువలతో నింపుతుంది. యాదృచ్ఛిక డేటాతో నిండిన పెద్ద బఫర్ మీకు అవసరమైనప్పుడు ఇది చాలా ఉపయోగకరంగా ఉంటుంది.

double nextGaussian()

ఈ పద్ధతి పరిధిలో యాదృచ్ఛిక వాస్తవ సంఖ్యను అందిస్తుంది 0.0- 1.0. అయితే, ఈ శ్రేణిలో సంఖ్యలు సమానంగా పంపిణీ చేయబడవు. బదులుగా, వారు సాధారణ పంపిణీని అనుసరిస్తారు .

పరిధి ( ) మధ్యలో ఉన్న విలువలు 0.5పరిధి చివర్లలోని విలువల కంటే ఎక్కువగా కనిపిస్తాయి.

మా విషయంలో, విలువ పంపిణీ యొక్క గరిష్ట స్థాయి ఉంటుంది0.5