Home

# Java random number between 0 and 2

### Java Generate Random Number Between Two Given Values

1. Java doesn't have a Random generator between two values in the same way that Python does. It actually only takes one value in to generate the Random. What you need to do, then, is add ONE CERTAIN NUMBER to the number generated, which will cause the number to be within a range
2. First, import the class java.lang.Random. Create an object of the Random class. All the above methods return the next pseudorandom, homogeneously distributed value (corresponding method) from this random number generator's sequence. The nextDouble () and nextFloat () method generates random value between 0.0 and 1.0
3. ) + 1)) +

Java Math.random () method The java.lang.Math.random () is used to return a pseudorandom double type number greater than or equal to 0.0 and less than 1.0. The default random number always generated between 0 and 1. If you want to specific range of values, you have to multiply the returned value with the magnitude of the range The nextFloat () method returns the next random float value between 0.0 and 1. The nextInt () method returns the next random integer value with 2^32 possible int values. The nextInt (int bound) method returns the next random integer value in the range from 0 (inclusive) to the specified bound value (exclusive)

There are many ways to generate random numbers in Java e.g. Math.random() utility function, java.util.Random class or newly introduced T hreadLocalRandom and SecureRandom, added on JDK 1.7.Each has their own pros and cons but if your requirement is simple, you can generate random numbers in Java by using Math.random() method. This method returns a pseudorandom positive double value between 0.0. Math.random gives a random double value that is greater than or equal to 0.0 and less than 1.0. Let's use the Math.random method to generate a random number in a given range [min, max): public int getRandomNumber(int min, int max) { return (int) ((Math.random () * (max - min)) + min); } Why does that work Create random number: 2. Create two random number generators with the same seed: 3. Does Math.random() produce 0.0 and 1.0: 4. Random numbers between 1 and 100: 5. Random integers that range from from 0 to n: 6. Random.nextInt(n) returns a distributed int value between 0 (inclusive) and n (exclusive). 7. Round Java float and double numbers.

1. Use Math.random () to Generate Integers. Math.random () returns a double type pseudo-random number, greater than or equal to zero and less than one. randomNumber will give us a different random number for each execution. Let's say we want to generate random numbers within a specified range, for example, zero to four In JavaScript, you can use the Math. random () function to generate a pseudo-random floating number between 0 (inclusive) and 1 (exclusive). If you want to get a random number between 0 and 20, just multiply the results of Math.random () by 20: To generate a random whole number, you can use the following Math methods along with Math.random ()

### How to Generate Random Number in Java - Javatpoin

Random number can be generated using two ways. You can use Random class (in package java.util) or Using Math.random java class (however this will generate double in the range of 0.0 to 1.0 and not integers) 2. Using java.util.Random Class. The java.util.Random is really handy. It provides methods such as nextInt(), nextDouble(), nextLong() and nextFloat() to generate random values of different types.. When you invoke one of these methods, you will get a Number between 0 and the given parameter (the value given as the parameter itself is excluded) Java Program to Generate Random Numbers. This Java program generates random numbers within the provided range. This Java program asks the user to provide maximum range, and generates a number within the range. Scanner class and its function nextInt () is used to obtain the input, and println () function is used to print on the screen

### Java - Generate random integers in a range - Mkyong

1. Output: The Randomly generated integer is : -2052834321. java.util.Random.nextInt (int n) : The nextInt (int n) is used to get a random number between 0 (inclusive) and the number passed in this argument (n), exclusive. Declaration : public int nextInt (int n) Parameters : n : This is the bound on the random number to be returned
2. + 1) +
3. Features of this random picker. Lets you pick a number between 0 and 2. Use the start/stop to achieve true randomness and add the luck factor
4. Random Numbers: ***** 135 173 5 17 15. The output of above program would not be same everytime. It would generate any 5 random numbers between 0 and 200 whenever you run this code. For e.g. When I ran it second time, it gave me the below output, which is entirely different from the above one. Output 2
5. 2. Java Random number between 1 and 10. Sometimes we have to generate a random number between a range. For example, in a dice game possible values can be between 1 to 6 only. Below is the code showing how to generate a random number between 1 and 10 inclusive

Random doubles: 0.13077348615666562 Random doubles: 0.09247016928442775 3) java.util.concurrent.ThreadLocalRandom class This class is introduced in java 1.7 to generate random numbers of type integers, doubles, booleans etc. Below program explains how to use this class to generate random numbers random number generator java range 1-1000 random number generator java without repetition How to generate unique random numbers in java - InstanceOfJava This is the java programming blog on OOPS Concepts , servlets jsp freshers and 1, 2,3 years expirieance java interview questions on java with explanation for interview examination Getting a random number between two values This example returns a random number between the specified values. The returned value is no lower than (and may possibly equal) min, and is less than (and not equal) max. function getRandomArbitrary(min, max) { return Math.random() * (max - min) + min;

### Java Math.random() Method with Examples - Javatpoin

• The Java Math.random () method is used to generate a pseudorandom number, which is a number created with a formula that simulates randomness. The pseudorandom number will be greater than or equal to 0.0 and less than 1.0. In other words, the number generated by Math.random is always between 0 and 1, and is a floating-point number
• * To generate random number between 1 to 100 use following code System . out . println ( Random numbers between 1 and 100 are, ) ; for ( int i = 0 ; i < 5 ; i ++
• random.nextInt () to Generate a Random Number Between 1 and 10. java.util.Random is a package that comes with Java, and we can use it to generate a random number between a range. In our case, the range is 1 to 10. This package has a class Random that allows us to generate multiple types of numbers, whether it is an int or a float
• The above statement will return us a random number between 0.0 and 19. That is because multiplying 0.0 - 0.99 with 20 and casting the result back to int will give us range of the 0 to 19. Step 2: Step 1 gives us a random number between 0 and 19. But we want a random number starting from 10, not 0. Let's add that number to the result
• Using the random.uniform() function.. The random.uniform() function is perfectly suited to generate a random number between the numbers 0 and 1, as it is utilized to return a random floating-point number between two given numbers specified as the parameters for the function.. This function is contained within the random module of Python that needs to be imported to the Python code first

### How to generate random numbers in Jav

• The numbers generated are fractions, so they will be either float or double values. Using the rand() function to generate random number between 0 and 1 in C++. The rand() function is used to generate a random number in C++. To work with this function we need to import the random library in C++. We can specify the range for the rand() function.. To generate random number between 0 and 1, we use.
• JavaScript Random Integers. Math.random () used with Math.floor () can be used to return random integers. There is no such thing as JavaScript integers. We are talking about numbers with no decimals here. Example. // Returns a random integer from 0 to 9: Math.floor(Math.random() * 10); Try it Yourself »
• 6. Apache Commons - RandomSource. 1. Using Math.random () method: Math class of java.util package can be used to generate random number, this method returns double type random numbers in the range 0.0 (included) to 1.0 (not included). Every run generates different random within the range. Run 2: 0.1579075367108116. 2
• In Java, there is a method random() in the Math class, which returns a double value between 0.0 and 1.0. Note that the default random numbers are always generated in between 0 and 1. If you want to get the specific range of values, the you have to multiple the retruned value with the magnitue of the range
• Learn how to generate random numbers in Java - both unbounded as well as within a given interval. 2.2. Random Long With Apache Commons Math. Let's take a look at generating the random Long with a cleaner API and Commons Math

### How to Generate Random Number between 1 to 10 - Java

• Generate Random Number Inclusive and Exclusive in Java. Random numbers can be generated using the java.util.Random class or Math.random () static method. There is no need to reinvent the random integer generation when there is a useful API within the standard Java JDK. Unless you really really care for performance then you can probably write.
• Normally, we are using the following ways to generate a random number in Java. 1. ThreadLocalRandom (JDK 1.7) //Generate number between 0-9 int index = ThreadLocalRandom.current ().nextInt ( 10 ); 2. Random () //Generate number between 0-9 Random random = new Random (); int index = random.nextInt ( 10 ); 3
• An algorithm that produces uniformly distributed random integer values can be the basis of other random number generators. For example, method java.util.Random.nextFloat() returns a uniformly distributed random float value between 0 and 1 by first generating a random positive 24-bit integer value and then dividing that value by 2 24 . Uniformly.
• Description: Generates random numbers. Each time the random() function is called, it returns an unexpected value within the specified range. If only one parameter is passed to the function, it will return a float between zero and the value of the high parameter. For example, random(5) returns values between 0 and 5 (starting at zero, and up to, but not including, 5) rand() effectively generates an integer in the range [0, 2^53-1], retries if the result was 0, and then divides the integer now in the range [1, 2^53-1] by 2^53 to give the random value. It is not possible to get higher precision than that over any range that starts above 1 The java.lang.Math.random() method returns a pseudorandom double type number greater than or equal to 0.0 and less than 1.0. . When this method is first called, it creates a single new pseudorandom-number generator, exactly as if by the expression new java.util.Random

Program: How to get random number between 0 to 1 in java? Description: Math.random() method returns a double value with a positive sign, greater than or equal to 0.0 and less than 1.0 By default Math.random() always generates numbers between 0.0 to 1.0, but if we want to get numbers within a specific range then we have to multiple the return value with the magnitude of the range. Example:- If we want to generate number between 1 to 100 using the Math.random() then we must multiply the returned value by 100 Hint: We can use Math.random() * 3 to generate a random number in between 0 and 3, including 0 and excluding 3. We can then cast this value to an int so that our random numbers only include 0, 1, and 2 - no decimals in between In Java there are a few ways to do this and the two popular ways would be: * java.util.Random [code]import java.util.Random; public class generateRandom{ public. Description. The nextDouble() method is used to get the next pseudorandom, uniformly distributed double value between 0.0 and 1.0 from this random number generator's sequence.. Declaration. Following is the declaration for java.util.Random.nextDouble() method.. public double nextDouble() Parameters. NA. Return Value. The method call returns the next pseudorandom, uniformly distributed double. New Random Number Generation Features in Java 8. Java 8 has introduced a new method ints() in the java.util.Random class. The ints() method returns an unlimited stream of pseudorandom int values. You can limit the random numbers between a specified range by providing the minimum and the maximum values Java Number Exercises [29 exercises with solution] 1. Write a Java program to check whether a given number is an ugly number. Go to the editor In number system, ugly numbers are positive numbers whose only prime factors are 2, 3 or 5 Uniform random numbers. Write a program Stats5.java that prints five uniform random values between 0 and 1, their average value, and their minimum and maximum value. Use Math.random(), Math.min(), and Math.max().; Three-sort. Write a program ThreeSort.java that takes three int values from the command line and prints them in ascending order. Use Math.min() and Math.max()

The random method generates a random number that is greater than or equal to 0 and always less than 1 (i.e. 0 = number 1). Thus, when we convert the multiplication to an int value, as I have done in the example, it will end up being 1 less than the size specified.For example, if the list size is 5 and the random number is 0.9999, the. public static boolean between (int i, int minValueInclusive, int maxValueInclusive) { return (i >= minValueInclusive && i <= maxValueInclusive); } However you want to write it, if you ever need Java source code to determine whether an integer is between a certain range, I hope this code is helpful. java. function

To get the random number. generateRandomInteger(100, 200); The solution works for use-cases as below. I am listing them in detail as the accepted answer and other solutions failed in some of them. Between 2 positive integers, ex 100, 200 generateRandomInteger(100, 200) Between 0 and positive integers, ex 0, 200 generateRandomInteger(0, 200 The uniform [0,1) pseudo random number generator in the java.lang.Math class . The method random() returns a uniform [0,1) pseudo random number . That means it can return any values between 0 and 1, including 0. but not including 1 Learn how to create random numbers in Java using the math and random classes as well as a few tricks Java 8 introduced to randomization. Double between 0.0 and 1.0: SimpleRandomNumber = 0. This problem has been solved! 2.13.2: Get random numbers. JAVA. Type two statements using nextInt () to print two random integers between (and including) 0 and 9. End with a newline. Ex: 5 7 Note: For this activity, using one statement may yield different output (due to the interpreter calling randGen.nextInt () in a different order)

### Generating Random Numbers in a Range in Java Baeldun

1. The Math.random() function returns a floating-point, pseudo-random number in the range 0 to less than 1 (inclusive of 0, but not 1) with approximately uniform distribution over that range — which you can then scale to your desired range. The implementation selects the initial seed to the random number generation algorithm; it cannot be chosen or reset by the user
2. Returns a pseudorandom, uniformly distributed int value between 0 (inclusive) and the specified value (exclusive), drawn from this random number generator's sequence. The general contract of nextInt is that one int value in the specified range is pseudorandomly generated and returned. All bound possible int values are produced with (approximately) equal probability
3. The getComp() will generate choice taken by the computer by choosing a number randomly between 0-2 which will represent the index in the array of choices. Hence, we will use Random class to generate this number. java.util package contains Random class. An instance of Random class is used to generate random numbers
4. and max value. Java Core provides 5 classes to do that: java.util.Random; java.lang.Math; java.util.concurrent.ThreadLocalRandom; java.security.SecureRando

This Java tutorial for beginners explains how to generate random numbers with the random method in the Math class.������ Subscribe To Get More Tutorials: http://.. Description. The nextInt(int n) method is used to get a pseudorandom, uniformly distributed int value between 0 (inclusive) and the specified value (exclusive), drawn from this random number generator's sequence.. Declaration. Following is the declaration for java.util.Random.nextInt() method.. public int nextInt(int n) Parameters. n − This is the bound on the random number to be returned Generate a Random Number Between 1 and User-Defined Value in JavaScript Generate a Random Number Between Two Numbers in JavaScript This tutorial will learn how to generate a random number between two numbers in JavaScript. We will use the method Math.random() that generates a random floating number between 0.0 and 0.999

Download Code. 2. Using Random class. Kotlin offers the Random class in the kotlin.random package, which can generate random numbers. You can use its nextInt() function to get a pseudorandom integer value between 0 (inclusive) and the specified value (exclusive).. Following is a simple example demonstrating usage of this function, which generates a pseudorandom number between start and end 5.2.1 Case Study: Guessing Numbers Write a program that randomly generates an integer between 0 and 100, inclusive. The program prompts the user to enter a number continuously until the number matches the randomly generated number. For each user input, the program tells the user whether the inpu Generating random numbers within a range . The rand() function generates random numbers that can be any integer value. But, to generate random numbers within a specific range, we have a formula that returns a random number between given ranges. Formula: number = (rand() % (upper - lower + 1)) + lower. Program to generate random numbers from 1 to Here we randomly were given numbers between 0 and RAND_MAX. What if we only wanted numbers between 1 and 10? We will need to scale the results. To do this we can use the modulus (%) operator. Any integer modulus 10 will produce a number from 0-9. In other words, if we divide a number by 10, the remainder has to be from 0 to 9 Assume that months are specified as an integer between 1 and 12 (1 for January, 2 for February, and so on) and that the day of the month is a number between 1 and 31. If the date falls between 12/16 and 3/15, you should return Winter. If the date falls between 3/16 and 6/15, you should return Spring

So now, to get a random value you would do the following: const x = Math.random () * (max - min) Here x is the random value. Currently, max is excluded from the interval. To make it inclusive, add 1. Also, you need to add the min back that was subtracted earlier to get a value between [min, max). const x = Math.random () * (max - min + 1) + min Program to generate random numbers in Java. Download Random Numbers program class file. Method nextInt (x) returns an integer in the range of 0 to x (both inclusive), x must be positive. To generate random float's use nextFloat, which returns a floating-point number between 0.0 to 1.0 ### Random number between 0 AND 10 : Random « Development

1. Native. 1.3. abstract class Random. (source) An abstract class that is implemented by random number generator algorithms. The companion object Random.Default is the default instance of Random. To get a seeded instance of random generator use Random function. import kotlin.math.sin import kotlin.random.Random import kotlin.test.assertTrue fun.
2. You can also use the Random class for such tasks as generating random T:System.Boolean values, generating random floating point values with a range other than 0 to 1, generating random 64-bit integers, and randomly retrieving a unique element from an array or collection.For these and other common tasks, see the How do you use System.Random to section
3. We can generate float random numbers by casting the return value of the rand function to 'float'. Thus the following will generate a random number between float 0.0 and 1.0 (both inclusive). cout<<static_cast <float> (rand()) / static_cast <float> (RAND_MAX); Similarly, the below line will generate a random number between 1.2 and 3.

For God's sake, can someone please, CLEARLY, tell me how to generate a random INTEGER between 0 and 1 (i.e. 0 or 1). I have searched all over the net, and no one has put a good working code. I hate C++ and anyone who proposed/coded the rand() function/class/library Get-Random 3951433 Example 2: Get a random integer between 0 and 99 Get-Random -Maximum 100 47 Example 3: Get a random integer between -100 and 99 Get-Random -Minimum -100 -Maximum 100 56 Example 4: Get a random floating-point number. This command gets a random floating-point number greater than or equal to 10.7 and less than 20.92 There are two common ways to generate random numbers in Java. calling r.nextInt(6) will actually return random numbers ranging from 0 to 5. Since a die has 1 to 6 as its faces, we need to add a 1 to the returned value to end up with a random number ranging between 1 to 6 to be stored in the variable number

### Java Random Number Generator - How to Generate Integers

The Excel RANDBETWEEN function returns a random integer between given numbers. RANDBETWEEN is a volatile function recalculates when a worksheet is opened or changed. In the example shown, the formula in B5 is: = RANDBETWEEN(1,100) This formula is then copied down from B5 to B11. The result is random numbers between 1-100 Random number generation can be controlled with SET.SEED() functions. SET.SEED() command uses an integer to start the random number of generations. Further, the generated random number sequence can be saved and used later. For example, We will use the code to sample 10 numbers between 1 and 100 and repeat it a couple of times C Basic Declarations and Expressions: Exercise-66 with Solution. Write a C program that generates 50 random numbers between -0.5 and 0.5 and writes them in a file rand.dat. The first line of ran.dat contains the number of data and the next 50 lines contains the 50 random numbers

1) The Math.random () returns a double value between 0 and 1, which can be used to generate random integers but not suitable. 2) The preferred way to generate random integer values is by using the nextInt (bound) method of java.util.Random class. This method returns a pseudorandom, uniformly distributed int value between 0 (inclusive) and the. The output would contain 50 randomly generated numbers between 0 and 20. An instance of the output of the above code has been displayed here: Random Number: 1, Value = 6. Random Number: 2, Value = 1. Random Number: 3, Value = 6. Random Number: 4, Value = 5. Random Number: 5, Value = 9. Random Number: 6, Value = 15. Random Number: 7, Value = 5. Step 2. Secret number. To propose a secret number, we declare a variable secretNumber of type int and use Math.random () function to give it random value in range 1..1000. public class NumberGuessingGame {. public static void main (String [] args) {. int secretNumber; secretNumber = (int) (Math.random() * 999 + 1) So, if you want to random number between 2 number. Example random 1 - 50 import java.util.Random; /** * @author somkiat.p * * TODO To change the template for this generated type comment go to * Window - Preferences - Java - Code Generation - Code and Comments.

### How to generate random numbers in JavaScrip

1. The bottom number is applied as is, however the formula subtracts 1 from the top number given that we add on a number derived from the RAND function, which returns a random decimal or integer number between 0 and 1. In this example we are returning a random number between 5 and 25, with decimal points
2. Question: 1 // DebugSix4.java 2 // Displays 5 Random Numbers Between 3 // (and Including) User-specified Values 4 Import Java.util.Scanner; 5 Public Class DebugSix4 6 { 7 Public Static Void Main(String[] Args) 8 { 9 Int High, Low, Count; 10 Final Int NUM = 5; 11 Scanner Input = New Scanner(System.in); 12 // Prompt User To Enter High And Low Values 13 System.out.print(This..
3. For example, to get a random number between 1 and 10, including 10, enter 1 in the first field and 10 in the second, then press Get Random Number. Our randomizer will pick a number from 1 through 10 at random. To generate a random number between 1 and 100, do the same, but with 100 in the second field of the picker
4. Random number generator in java can be implemented through the following methods: Using Random class of java Java.util.random class of java provides many methods which can be used for creating a random number generator in java. To use methods of this class we first need to create objects of this class. nexInt(), nextDouble(), nextLong() etc are.
5. .
6. d that Math.random() generates numbers between 0 and 1. By default, 0 would be the start value and 1 would be the end value. So, if x = start and y = end, you would do the following:. add x so the starting point changes from the default 0 to x; multiply by y-x so the ending point changes from the default 1 to y; when using Math.floor(), remember to +1 to y-x to accomodate the.
7. dot net perls. Random. Java programs sometimes need a source of random numbers. Consider generating a user ID—a random source of digits could help. Class notes. In Java we use the Random class (from java.util.Random) and Math.random. These types return pseudo-random numbers, which are good enough for most programs. Math.random ### How to Generate Random Numbers in Jav

9. . Activity: 2.9.1 ActiveCode (random1) You can use Math.random and a cast to integer to return a random integer between some starting and ending value. The code below will create a random integer from 0 to 9. Remember that casting a double value to integer (int) will throw away any values after the decimal point Logic -> Use Random Function to get value between 0 and 1. If < 0.5 then tails or heads O/P -> Percentage of Head vs Tails Leap Year I/P -> Year, ensure it is a 4 digit number. Use Java Scanner Class Logic -> create 2 dimensional array in memory to read in M rows and N cols O/P -> Print function to print 2 Dimensional Array. In Java use.

### Random Number Generation with Java - ProgrammerFriend

The code generates random numbers and displays them. long randNumber; void setup() { Serial.begin(9600); // if analog input pin 0 is unconnected, random analog // noise will cause the call to randomSeed() to generate // different seed numbers each time the sketch runs The one mistake in the code abve would apeare in the statement of generating the random number becase the result would be a random number between 1 and 20 but the index of the iruginal array can be 0 to 19 so we can fix that by editing the statement to i = Math.floor(Math.rand() * (20 - n)) Possible 2 digit combinations. 100 (~ 100.0) Random 2 Digit Number Generator Pick Random Numbers. Magic Filters. ×. Add magic filter add_circle_outline. Done. Display Font. × Random Number Functions Before Swift 4.2. Swift has three typical functions for random numbers: arc4random() returns a random number between zero and 2 32 -1 arc4random_uniform(_:) returns a random number between zero and the first parameter, minus one.drand48() returns a random Double between 0.0 and 1.0 Both arc4random() and arc4random_uniform(_:) use the UInt32 type instead of the more.

### Java Program to Generate Random Numbers - W3school

This is one way (not very efficient) to do it in C#. Given more time, I'd refactor it to be more efficient. [code]static void Main(string[] args) { var numbers = new List<int>(); var numberOfNumbersYouWant = 4; // This has to be less than 11. Let me see if i can explain this! Math.floor(Math.random() * (max - min + 1)) is generating a whole number between the range of 0 to 8. The (max - min + 1) is the logic that creates the range. When you add the + min at the end you are adding the +2 to your range and end up with a random number from 2 to 10 To generate a random number in JavaScript, simply use the following code: ? 1. var randomnumber=Math.floor (Math.random ()*11) where 11 dictates that the random number will fall between 0-10. To increase the range to, say, 100, simply change 11 to 101 instead Random Numbers on a Computer . First off, it is not really possible (nor desirable) to have real random numbers. What we want is a repeatable sequence of seemingly random numbers that satisfy certain properties, such as the average value of a list of random numbers between say, 0 and 1000, should be 500 ### Java.util.Random.nextInt() in Java - GeeksforGeek

(This indicates a weakness of our example generator: If the random numbers are between 0 and 99 then one would like every number between 0 and 99 to be a possible member of the sequence. The parameters P 1 , P 2 , and N determine the characteristics of the random number generator, and the choice of x 0 (the seed ) determines the particular. The Odd Numbers are: 1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 99 Related Pos   Answer: It's easy and useful to generate random decimals or whole numbers. See below steps to do get the whole number:-Use Math.random() to generate a random decimal. Multiply that random decimal by 100 or any number. Use another function, Math.floor() to round the number down to its nearest whole number Using the examples below, we will introduce you ways to get random numbers in other ranges than 0-1. The first one will return a random number between 0 and 100: Example. Math .random () * 100; Try it Live. Now, the example below will return a random number between 100 and 500: Example. ( Math .random () * 400) + 100; Try it Live This method will behave in the following ways: maxExcusive is exclusive, so for example Random.Range(0, 10) will return a value between 0 and 9, each with approximately equal probability.; If minInclusive and maxExclusive are equal, then the exclusive rule is ignored and minInclusive will be returned.; If minInclusive is greater than maxExclusive, then the numbers are automatically swapped Create a random number generator. Create an empty set to hold the unique values. Keep adding random numbers from 0-999 to the set until it's size is 50. Convert the set into an array. Print the array in a grid format with 5 rows and 10 columns :random.uniform(10) # Float between 0.0 and 1.0:random.uniform() For further information, read the Erlang section. Erlang . Random number generator. The method is attributed to B.A. Wichmann and I.D.Hill, in 'An efficient and portable pseudo-random number generator', Journal of Applied Statistics. AS183. 1982. Also Byte March 1987 For example if you are drawing random integer numbers where each number is between 0 and 100 then on average: If you draw 10 numbers then you should expect around 6% to be duplicates. If you draw 100 numbers then just over 63% will be duplicates i.e. matching one or more of the other 99 numbers