ஜாவாவில் ரேண்டம் எண்கள்

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(), ஆனால் திரும்பிய ரேண்டம் எண் ஒரு 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