Develop Reference

How to generate random numbers from a range in c# [duplicate]

This question already has answers here:
Produce a random number in a range using C#
(7 answers)
Closed 5 years ago.
So I need to generate random numbers based on user set parameters, and make a basic math expression. They have 3 options; single, double, or triple digit numbers. So based on that I need to generate a random number from 0 to 9, 0 to 99, and 0 to 100.
So far I've read about the Random class. This is my poor attempt:
Random rnd = new Random();
int value = 0;
if (digits == 1)
{
rnd.Next(value);
q1Lbl.Text = value.ToString();
}

You need this overload of Random.Next():
public virtual int Next(
int minValue,
int maxValue
)
Where:
minValue = The inclusive lower bound of the random number returned.
maxValue = The exclusive upper bound of the random number returned.
maxValue must be greater than or equal to minValue.
Note the words inclusive and exclusive in the parameter descriptions. This means the minimum value can be returned in the possible values, while the maximum value will not be possible.
This is further clarified in the description of the return value:
Return Value - A 32-bit signed integer greater than or equal to
minValue and less than maxValue; that is, the range of return values
includes minValue but not maxValue. If minValue equals maxValue,
minValue is returned.
For example, to get single digit values between 0 and 9 (inclusive), you'd use:
int value = rnd.Next(0, 10); // return a value between 0 and 9 inclusive
To get double digits, you'd use:
int value = rnd.Next(10, 100); // return a value between 10 and 99 inclusive
Finally, to get triple digit numbers, you'd use:
int value = rnd.Next(100, 1000); // return a value between 100 and 999 inclusive

Random rnd = new Random();
int single = rnd.Next(1, 10); // 1 ~9
int double = rnd.Next(1, 100); // 1~99
int triple = rnd.Next(1,101); // 1~100
loop it if you want to achieve the values multiple times

There's an overload of the Next method, you only have to pass the range:
Random rnd = new Random();
rnd.Next(1,20); //Gives you a number between 1 and 20
Here you find the entire documentation https://www.google.com.co/search?q=next+random+c%23&oq=next+random&aqs=chrome.1.69i57j0l5.3144j0j7&sourceid=chrome&ie=UTF-8

Random Always Generates The Same Number

I'm using Random class to generate any random integer number but it always returns the same number
static Random rand = new Random();
public static int GetOrderID()
{
return rand.Next(Math.Abs(int.MinValue + 1), int.MaxValue);
}
notice that the random class is static and generated outside the function

What would you expect if
Math.Abs(int.MinValue + 1)
is equal to
int.MaxValue
so your range contains one number only.

It´s simple: Calling Math.Abs will delete the sign from the number. As the minimum integer is -2,147,483,648 its absolute value (incremented by 1) is 2,147,483,647 which equals the absolute value for int.MaxValue.
So when calling Math.Abs(int.MinValue + 1), int.MaxValue you allways get 2,147,483,647as return-value, right?
If you need any arbitrary int you may however use rand.Next(int.MinValue, int.MaxValue) without using Math.Abs. For any non-negative integer-number you can use the overload without any parameters.

Random number issue with Next method (.NET Framework)

I need to generate a lot of random numbers which must be anywhere between 1 and int.MaxValue. The arguments passed to the Next method of the Random class are not always the same. In one senario the arguments might be as follows:
Next(1, int.MaxValue);
In another they might as well be:
Next(1, 2);
The issue here is that whenever you pass values like 1 and 2 or 99 and 100, the lower number is always the "random" number returned by the method. The reason for this is because the method subtracts 1 from the maximum value (unless min and max are the same) and then gives you the random number. How would I go about generating a range of random numbers within a range of numbers, as stated above, without getting this predictable outcome?

You would need to pass the inclusive upper bound + 1, ie:
var result = rand.Next(1, 2+1); // Returns 1 or 2
var result2 = rand.Next(99, 101); // Returns 99 or 100
Note that this won't work for int.MaxValue, of course. There is no way to have Random directly return int.MaxValue. To get a [0,int.MaxValue] result, you would need to do:
var result = rand.Next(-1, int.MaxValue) + 1;

The upper bound is exclusive, not inclusive. Given that, the range [1,2) only contains one number, 1, not two.

From the documentation, the first parameter to Next(int, int) is "The inclusive lower bound", while the second is "The exclusive upper bound".
If you want to generate a random number that might be 1 or 2, you should use the following call:
rand.Next(1, 3)

Try this
using System;
namespace ConsoleApplication3
{
class Program
{
static readonly Random r = new Random();
static void Main(string[] args)
{
for (int i = 2; i <= 100; i++)
{
Console.WriteLine(GetRandom(i));
}
}
private static int GetRandom(int i)
{
return 1 + (r.Next(int.MaxValue)%i);
}
}
}
Cheers.

You can get int.MaxValue by adding 1 after getting random int:
var result = rand.Next(1, int.MaxValue) + 1;

How about a method that takes the lower and upper limits and gives you what you're looking for?
Example:
public int GetRandom(int lower, int upper)
{
return upper == int.MaxValue ? rand.Next(lower - 1, upper) + 1 : rand.Next(lower, upper + 1);
}
If the upper limit is int.MaxValue, it shifts the range down by 1 and then adds it back after it gives the random number. Otherwise, it adds 1 to the upper limit and then gives you the random number.
Then when you use it, you'll just do something like:
var randomOne = GetRandom(1, 2);
var randomTwo = GetRandom(99,int.MaxValue);

Generate a Random Int32 for the full range of possible numbers

If I wanted to generate a random number for all possible numbers an Int32 could contain would the following code be a reasonable way of doing so? Is there any reason why it may not be a good idea? (ie. a uniform distribution at least as good as Random.Next() itself anyway)
public static int NextInt(Random Rnd) //-2,147,483,648 to 2,147,483,647
{
int AnInt;
AnInt = Rnd.Next(System.Int32.MinValue, System.Int32.MaxValue);
AnInt += Rnd.Next(2);
return AnInt;
}

You could use Random.NextBytes to obtain 4 bytes, then use BitConverter.ToInt32 to convert those to an int.
Something like:
byte[] buf = new byte[4];
Rnd.NextBytes(buf);
int i = BitConverter.ToInt32(buf,0);

Your proposed solution will slightly skew the distribution. The minValue and maxValue will occur less frequently than the interior values. As an example, assume that int has a MinValue of -2 and a MaxValue of 1. Here are the possible initial values, with each followed by the resulting values after the Random(2):
-2: -2 -1
-1: -1 0
0: 0 1
half of the negative -2 values will get modified up to -1, and only half of 0 will get modified up to 1. So the values -2 and 1 will occur less frequently than -1 and 0.
Damien's solution is good. Another choice would be:
if (Random(2) == 0) {
return Random(int.MinValue, 0);
} else {
return 1 + Random(-1, int.MaxValue);
}
another solution, similar to Damiens approach, and faster than the previous one would be
int i = r.Next(ushort.MinValue, ushort.MaxValue + 1) << 16;
i |= r.Next(ushort.MinValue, ushort.MaxValue + 1);

A uniform distribution does not mean you get each number exactly once. For that you need a permutation
Now, if you need a random permutation of all 4-billion numbers you're a bit stuck. .NET does not allow objects to be larger than 2GBs. You can work around that, but I assume that's not really what you need.
If you less numbers (say, 100, or 5 million, less than a few billions) without repetitions, you should do this:
Maintain a set of integers, starting empty. Choose a random number. If it's already in the set, choose another random number. If it's not in the set, add it and return it.
That way you guarantee each number will be returned only once.

I have a class where I get random bytes into a 8KB buffer and distribute numbers from by converting them from the random bytes. This gives you the full int distribution. The 8KB buffer is used to you do not need to call NextBytes for every new random byte[].
// Get 4 bytes from the random buffer and cast to int (all numbers equally this way
public int GetRandomInt()
{
CheckBuf(sizeof(int));
return BitConverter.ToInt32(_buf, _idx);
}
// Get bytes for your buffer. Both random class and cryptoAPI support this
protected override void GetNewBuf(byte[] buf)
{
_rnd.NextBytes(buf);
}
// cyrptoAPI does better random numbers but is slower
public StrongRandomNumberGenerator()
{
_rnd = new RNGCryptoServiceProvider();
}

c# probability and random numbers

I want to trigger an event with a probability of 25% based on a random number generated between 1 and 100 using:
int rand = random.Next(1,100);
Will the following achieve this?
if (rand<=25)
{
// Some event...
}
I thought I would use a number between 1 and 100 so I can tweak the probabilities later on - e.g. adjust to 23% by using
if (rand<=23) {...}

The biggest error you are making is it should be random.Next(0,100) as the documentation states
minValue: The inclusive lower bound of the random number returned.
maxValue: The exclusive upper bound of the random number returned. maxValue must be greater than or equal to minValue.
Emphisis mine, exclusive means it does not include number you passed in, so my code generates the range 0-99 and your code generates the range 1-99.
So change your code to
int rand = random.Next(0,100)
if (rand < 25) //25%
{
// Some event...
}
//other code
if (rand < 23) //23%
{
// Some event...
}
The change from <= to < is because you are now using the exclusive upper bounds range

The second argument of Next(int, int) is the exclusive upper bound of the desired range of results. You should therefore use this:
if (random.Next(0, 100) < 25)
or, if you must use 1-based logic,
if (random.Next(1, 101) <= 25)

You can also use this code (usually for percentage calculations double between 0 and 1 is used):
double rand = random.NextDouble();
if(rand < .25)
{
...