# Using JavaScript Random in Different ways

JavaScript Math.random() is a Math function that returns a random floating-point number between [0, 1) that is, including 0 but excluding 1. In this tutorial, we will see the different ways in which we can use JavaScript Math.random() for different applications.

Before diving into the tutorial, let us recall some of the basic random function applications.

• #### Displaying a random number between the given range

To display a random number between the given range, including minimum range but excluding maximum, the following code snippet can be used.

```function random_range(low, high){
return Math.floor(low + Math.random()*(high-low))
}
```

Low and high are the ranges and it is assumed to be integers and not floating values.

• #### Displaying a random number between the given range, Inclusive

The following code snippet is used to display a random number between a given range where both min and max range is inclusive.

```function random_range(low, high){
return Math.floor(low + Math.random()*(high-low+1))
}
```

Here also, low and high ranges are assumed to be integers.

Now let’s move on to our tutorial.

### Generating an Array of Random Numbers between 0 (inclusive) and 1 (exclusive) in JavaScript

We can generate an n-dimensional array filled with random numbers in the range [0, 1). We will see how to generate them for 1-D and 2-D arrays.

• #### 1-D Array of Random numbers

This is a simple straightforward implementation. The function random1DArray takes size as an argument. Initially, we create an empty array. Then we iterate through the loop for size times and each time, we create a random number and push it to the array. Finally, we return the array.

```function random1DArray(size){
random_arr = [];
for( i=0; i<size; i++){
random_arr.push(Math.random());
}
return random_arr;
}

console.log(random1DArray(5));
```

Output

```[0.0952778139642434, 0.9189917848729967, 0.2605812184376721, 0.0032629562265031886, 0.6504691713009889]

```

• #### 2-D Array of Random numbers

This is another simple straightforward implementation. The function random2DArray takes the number of rows and columns as the argument. Initially, we create an empty array. Then we iterate through the loop for row times and for each iteration we run into another loop for column times and push a random number into the corresponding row and column of that array. Finally, we return the array.

```function random2DArray(row, col){
random_arr = [];
for( i=0; i<row; i++){
random_arr[i] = [];
for( j=0; j<col; j++){
random_arr[i].push(Math.random());
}
}
return random_arr;
}

console.log(random2DArray(2,3));```

Output

```[[0.5488288891993967, 0.0298192985486605, 0.11928803737803206],
[0.3147064790737486, 0.029036556122976176, 0.6606564516524003]]```

### Generating an Array of Random Numbers between Min and Max range

In the above application, we generated numbers between [0, 1). Here we will do the same for a given minimum (inclusive) and maximum (inclusive) ranges. Here, we will use the function random_range() function which is explained at the beginning of the article, to return a random integer between the two given ranges.

• #### 1-D Array of Random numbers

The function random1DArray takes 3 arguments namely size, min, and max. An empty array is created and it is looped through size times. Each time random_range function is called passing, min and max value to it. It then returns a random integer between the given range and the returned value is pushed into the array. Finally, the array is returned.

```function random_range(min, max){
return Math.floor(min + Math.random()*(max-min+1))
}

function random1DArray(size, min, max){
random_arr = [];
for( i=0; i<size; i++){
random_arr.push(random_range(min, max));
}
return random_arr;
}

console.log(random1DArray(size = 3, min = 2, max = 5));
```

Output

```[5, 2, 3]
```

• #### 2-D Array of Random numbers

This function, random2DArray takes 4 arguments – row, col, min, max. We iterate through the loop for row times and then column times and we call the random_range function to return a random integer. We push it to the array and return the array finally.

```function random_range(min, max){
return Math.floor(min + Math.random()*(max-min+1))
}

function random2DArray(row, col, min, max){
random_arr = [];
for( i=0; i<row; i++){
random_arr[i] = [];
for( j=0; j<col; j++){
random_arr[i].push(random_range(min, max));
}
}
return random_arr;
}

console.log(random2DArray(row = 2, col = 3, min = 5, max = 10));
```

Output

`[[8, 7, 6], [7, 5, 8]]`

### Generate a Random Array of size n from another Array

Using Javascript Math.random(), we can generate an array whose elements are derived randomly from another array. We can think of this scenario in 2 ways, that is, generating the array with replacement and generating the array without replacement.

• #### Generate Array with Replacement

Here, we can choose the elements from another array, any number of times. The function randomArray gets 2 arguments – arr which is the array and size which is the length array to be formed. We create an empty array and a loop to run for size times.  In each iteration, we call another function random_range which we discussed earlier. We pass length the of arr as an argument and a random integer between 0 and length of arr –1 is returned, and stored in a variable called index. Then in the arr array, the element present at the index position is pushed into the new array. Finally, the newly formed array is returned.

```function random_range(max){
min = 0;
return Math.floor(min + Math.random()*(max-min))
}

function randomArray(arr, size){
random_arr = [];
for( i=0; i<size; i++){
index = random_range(arr.length)
random_arr.push(arr[index]);
}
return random_arr;
}

console.log(randomArray([2, 5, 0, 7, 6, 4], 4));
```

Output

`[6, 0, 6, 7]`

• #### Generate Array without Replacement

This works almost the same as the above code except there is no replacement. It means once an element is chosen from the other array, it cannot be chosen again. The function randomArray takes 2 arguments – arr which is the array and size which is the length of the array to be formed. Initially, we check whether the length of arr is greater than or equal to size. If not, we cannot generate the array and print the appropriate message. Else we create an empty array and a loop to run for size times. We follow the same steps which we discussed for ‘with replacement’ except we remove the randomly chosen element from the original array. It can be done using splice() function of Javascript. This is to ensure that there will be no replacement. Finally, the newly formed array is returned.

```function random_range(max){
min = 0;
return Math.floor(min + Math.random()*(max-min))
}

function randomArray(arr, size){

if(size > arr.length){
console.log('Cannot Generate Array.');
return;
}
random_arr = [];
for( i=0; i<size; i++){
random_number = arr[random_range(arr.length)]
random_arr.push(random_number);
index = arr.indexOf(random_number);
arr.splice(index, 1);
}
return random_arr;
}

arr = [1, 2, 3, 5, 6]
console.log(randomArray(arr, 3))```

Output

`[[8, 7, 6], [7, 5, 8]]`