How to use javascript math.random() as a random number generator

Случайная дата и время

Даты и время-это не более чем 32-битные целые числа по сравнению с временем эпохи , поэтому мы можем генерировать случайные временные значения, следуя этому простому алгоритму:

  1. Сгенерируйте случайное 32-разрядное число, int
  2. Передайте сгенерированное случайное значение соответствующему конструктору даты и времени или конструктору

2.1. Ограниченный момент времени

java.время.I instant является одним из новых дополнений даты и времени в Java 8. Они представляют собой мгновенные точки на временной шкале.

Чтобы сгенерировать случайное Мгновенное между двумя другими, мы можем:

  1. Сгенерируйте случайное число между секундами эпохи заданных мгновений
  2. Создайте случайное Мгновенное , передав это случайное число в метод |/
public static Instant between(Instant startInclusive, Instant endExclusive) {
    long startSeconds = startInclusive.getEpochSecond();
    long endSeconds = endExclusive.getEpochSecond();
    long random = ThreadLocalRandom
      .current()
      .nextLong(startSeconds, endSeconds);

    return Instant.ofEpochSecond(random);
}

Чтобы добиться большей пропускной способности в многопоточных средах, мы используем ThreadLocalRandom для генерации случайных чисел.

Мы можем проверить, что сгенерированный Instant всегда больше или равен первому Instant и меньше второго Instant:

Instant hundredYearsAgo = Instant.now().minus(Duration.ofDays(100 * 365));
Instant tenDaysAgo = Instant.now().minus(Duration.ofDays(10));
Instant random = RandomDateTimes.between(hundredYearsAgo, tenDaysAgo);
assertThat(random).isBetween(hundredYearsAgo, tenDaysAgo);

Помните, конечно, что тестирование случайности по своей сути недетерминировано и, как правило, не рекомендуется в реальном приложении.

Аналогично, можно также сгенерировать случайный Мгновенный после или до другого:

public static Instant after(Instant startInclusive) {
    return between(startInclusive, Instant.MAX);
}

public static Instant before(Instant upperExclusive) {
    return between(Instant.MIN, upperExclusive);
}

2.2. Ограниченная дата

Один из java.util.Дата конструкторы принимают количество миллисекунд после эпохи. Таким образом, мы можем использовать тот же алгоритм для генерации случайной Даты между двумя другими:

public static Date between(Date startInclusive, Date endExclusive) {
    long startMillis = startInclusive.getTime();
    long endMillis = endExclusive.getTime();
    long randomMillisSinceEpoch = ThreadLocalRandom
      .current()
      .nextLong(startMillis, endMillis);

    return new Date(randomMillisSinceEpoch);
}

Точно так же мы должны быть в состоянии проверить это поведение:

long aDay = TimeUnit.DAYS.toMillis(1);
long now = new Date().getTime();
Date hundredYearsAgo = new Date(now - aDay * 365 * 100);
Date tenDaysAgo = new Date(now - aDay * 10);
Date random = LegacyRandomDateTimes.between(hundredYearsAgo, tenDaysAgo);
assertThat(random).isBetween(hundredYearsAgo, tenDaysAgo);

2.3. Неограниченный Момент времени

Чтобы сгенерировать полностью случайное Мгновенное , мы можем просто сгенерировать случайное целое число и передать его в метод ofEpochSecond() :

public static Instant timestamp() {
    return Instant.ofEpochSecond(ThreadLocalRandom.current().nextInt());
}

Использование 32-битных секунд, так как время эпохи генерирует более разумные случайные времена, поэтому мы используем метод nextInt() здесь .

Кроме того, это значение должно по-прежнему находиться между минимально и максимально возможным Мгновенные значения, которые может обрабатывать Java:

Instant random = RandomDateTimes.timestamp();
assertThat(random).isBetween(Instant.MIN, Instant.MAX);

2.4. Неограниченная Дата

Подобно ограниченному примеру, мы можем передать случайное значение в конструктор Date , чтобы сгенерировать случайную Дату:

public static Date timestamp() {
    return new Date(ThreadLocalRandom.current().nextInt() * 1000L);
}

Поскольку единица времени конструктора составляет миллисекунды, мы преобразуем 32-битные секунды эпохи в миллисекунды, умножив их на 1000.

Конечно, это значение все еще находится между минимально и максимально возможными Данными значениями:

Date MIN_DATE = new Date(Long.MIN_VALUE);
Date MAX_DATE = new Date(Long.MAX_VALUE);
Date random = LegacyRandomDateTimes.timestamp();
assertThat(random).isBetween(MIN_DATE, MAX_DATE);

Java Math.random() Example

Java program to demonstrate Math.random() method. We will take a loop and call the Math.random() method multiple times. In each execution, it gives a different double value with a positive sign, greater than or equal to 0.0 and less than 1.0.

Output:-

0.61921576963401330.08796048507589238

Each time we get different floating-point values ranges from 0.0 to 1.0.

Note:- There are infinite floating-point numbers are possible between 0.0 to 1.0, but double data type gives only up to 15 to 16 decimal point precision.

If we import the Math class statically and then we can invoke random() method without calling through it’s class name.

Output:-

0.2644603504223617

The “import static java.lang.Math.*;” statement will import all static members of the Math class. But if we want to import only the random() method of the Math class, not another static method and variables of Math class then we can use the “import static java.lang.Math.random;” statement. Learn more about static import in Java

Случайная Дата

До сих пор мы генерировали случайные временные значения, содержащие как компоненты даты, так и компоненты времени. Аналогично, мы можем использовать концепцию дней эпохи для генерации случайных временных чисел только с компонентами даты.

День эпохи равен количеству дней, прошедших с 1 января 1970 года. Поэтому, чтобы сгенерировать случайную дату, нам просто нужно сгенерировать случайное число и использовать это число в качестве дня эпохи.

3.1. Ограниченные

Нам нужна временная абстракция, содержащая только компоненты даты, поэтому java.time.LocalDate кажется хорошим кандидатом:

public static LocalDate between(LocalDate startInclusive, LocalDate endExclusive) {
    long startEpochDay = startInclusive.toEpochDay();
    long endEpochDay = endExclusive.toEpochDay();
    long randomDay = ThreadLocalRandom
      .current()
      .nextLong(startEpochDay, endEpochDay);

    return LocalDate.ofEpochDay(randomDay);
}

Здесь мы используем метод для преобразования каждого LocalDate в соответствующий день эпохи. Аналогичным образом, мы можем проверить правильность этого подхода:

LocalDate start = LocalDate.of(1989, Month.OCTOBER, 14);
LocalDate end = LocalDate.now();
LocalDate random = RandomDates.between(start, end);
assertThat(random).isBetween(start, end);

3.2. Неограниченный

Чтобы генерировать случайные даты независимо от любого диапазона, мы можем просто генерировать случайный день эпохи:

public static LocalDate date() {
    int hundredYears = 100 * 365;
    return LocalDate.ofEpochDay(ThreadLocalRandom
      .current().nextInt(-hundredYears, hundredYears));
}

Наш генератор случайных дат выбирает случайный день из 100 лет до и после эпохи. Опять же, обоснование этого заключается в том, чтобы генерировать разумные значения данных:

LocalDate randomDay = RandomDates.date();
assertThat(randomDay).isBetween(LocalDate.MIN, LocalDate.MAX);

Using Random class

You can use java.util.Random to generate random numbers in java.You can generate integers, float, double, boolean etc using Random class.

Let’s understand with the help of example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

packageorg.arpit.java2blog;

import java.util.Random;

publicclassRandomClassGeneratorMain{

publicstaticvoidmain(Stringargs){

Random randomGenerator=newRandom();

System.out.println(«============================»);

System.out.println(«Generating 5 random integers»);

System.out.println(«============================»);

for(inti=;i<5;i++){

System.out.println(randomGenerator.nextInt());

}

System.out.println(«============================»);

System.out.println(«Generating 5 random double»);

System.out.println(«============================»);

for(inti=;i<5;i++){

System.out.println(randomGenerator.nextDouble());

}

System.out.println(«============================»);

System.out.println(«Generating 5 random floats»);

System.out.println(«============================»);

for(inti=;i<5;i++){

System.out.println(randomGenerator.nextFloat());

}

System.out.println(«============================»);

System.out.println(«Generating 5 random booleans»);

System.out.println(«============================»);

for(inti=;i<5;i++){

System.out.println(randomGenerator.nextBoolean());

}

}

}
 

Output:

============================
Generating 5 random integers
============================
1342618771
-1849662552
1719085329
2141641685
-819134727
============================
Generating 5 random doubles
============================
0.1825454639005325
0.5331492085899436
0.830900901839756
0.8490109501015005
0.7968080535091425
============================
Generating 5 random floats
============================
0.9831014
0.24019146
0.11383718
0.42760438
0.019532561
============================
Generating 5 random booleans
============================
false
false
true
true
false

API

  • : Utilizes
  • : Utilizes
  • : Utilizes
  • : Produces a new Mersenne Twister. Must be seeded before use.

Or you can make your own!

interfaceEngine{next()number;}

Any object that fulfills that interface is an .

  • : Seed the twister with an initial 32-bit integer.
  • : Seed the twister with an array of 32-bit integers.
  • : Seed the twister with automatic information. This uses the current Date and other entropy sources.
  • : Produce a 32-bit signed integer.
  • : Discard random values. More efficient than running repeatedly.
  • : Return the number of times the engine has been used plus the number of discarded values.

One can seed a Mersenne Twister with the same value () or values () and discard the number of uses () to achieve the exact same state.

If you wish to know the initial seed of , it is recommended to use the function to create the seed manually (this is what does under-the-hood).

constseed=createEntropy();constmt=MersenneTwister19937.seedWithArray(seed);useTwisterALot(mt);constclone=MersenneTwister19937.seedWithArray(seed).discard(mt.getUseCount());

Random.js also provides a set of methods for producing useful data from an engine.

  • : Produce an integer within the inclusive range . can be at its minimum -9007199254740992 (-2 ** 53). can be at its maximum 9007199254740992 (2 ** 53).
  • : Produce a floating point number within the range . Uses 53 bits of randomness.
  • : Produce a boolean with a 50% chance of it being .
  • : Produce a boolean with the specified chance causing it to be .
  • : Produce a boolean with / chance of it being true.
  • : Return a random value within the provided within the sliced bounds of and .
  • : Same as .
  • : Shuffle the provided (in-place). Similar to .
  • : From the array, produce an array with elements that are randomly chosen without repeats.
  • : Same as
  • : Produce an array of length with as many rolls.
  • : Produce a random string using numbers, uppercase and lowercase letters, , and of length .
  • : Produce a random string using the provided string as the possible characters to choose from of length .
  • or : Produce a random string comprised of numbers or the characters of length .
  • : Produce a random string comprised of numbers or the characters of length .
  • : Produce a random within the inclusive range of . and must both be s.

An example of using would be as such:

constengine=MersenneTwister19937.autoSeed();constdistribution=integer(,99);functiongenerateNaturalLessThan100(){returndistribution(engine);}

Producing a distribution should be considered a cheap operation, but producing a new Mersenne Twister can be expensive.

An example of producing a random SHA1 hash:

var engine = nativeMath;var distribution =hex(false);functiongenerateSHA1(){returndistribution(engine,40);}

Java Random Number Generator

Let’s look at some examples to generate a random number in Java. Later on, we will also look at ThreadLocalRandom and SecureRandom example program.

1. Generate Random integer

Yes, it’s that simple to generate a random integer in java. When we create the Random instance, it generates a long seed value that is used in all the method calls. We can set this seed value in the program, however, it’s not required in most of the cases.

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.

The argument in the is excluded, so we have to provide argument as 11. Also, 0 is included in the generated random number, so we have to keep calling nextInt method until we get a value between 1 and 10. You can extend the above code to generate the random number within any given range.

7. Generate Random byte array

We can generate random bytes and place them into a user-supplied byte array using Random class. The number of random bytes produced is equal to the length of the byte array.

8. ThreadLocalRandom in multithreaded environment

Here is a simple example showing ThreadLocalRandom usage in a multithreaded environment.

Below is a sample output of my execution of the above program.

We can’t set seed value for ThreadLocalRandom instance, it will throw .

ThreadLocalRandom class also has some extra utility methods to generate a random number within a range. For example, to generate a random number between 1 and 10, we can do it like below.

ThreadLocalRandom has similar methods for generating random long and double values.

9. SecureRandom Example

You can use SecureRandom class to generate more secure random numbers using any of the listed providers. A quick SecureRandom example code is given below.

That’s all about generating a random number in Java program.

You can download the example code from our GitHub Repository.

Usage

In your project, run the following command:

npm install random-js

or

yarn add random-js

In your code:

import{Random}from"random-js";constrandom=newRandom();constvalue=random.integer(1,100);
const{Random}=require("random-js");constrandom=newRandom();constvalue=random.integer(1,100);

Or to have more control:

constRandom=require("random-js").Random;constrandom=newRandom(MersenneTwister19937.autoSeed());constvalue=random.integer(1,100);

It is recommended to create one shared engine and/or instance per-process rather than one per file.

Download and place it in your project, then use one of the following patterns:

define(function(require){var Random =require("random");returnnewRandom.Random(Random.MersenneTwister19937.autoSeed());});define(function(require){var Random =require("random");returnnewRandom.Random();});define("random",function(Random){returnnewRandom.Random(Random.MersenneTwister19937.autoSeed());});

Download and place it in your project, then add it as a tag as such:

<scriptsrc="lib/random-js.min.js"><script><script>var random =newRandom.Random();alert("Random value from 1 to 100: "+random.integer(1,100));</script>

The Rolling Dice Game

In this section, we will create a really simple mini dice game. Two players enter their name and will roll the dice. The player whose dice has a higher number will win the round.

First, create a function that simulates the action for rolling the dice.

Inside the function body, call the function with and as the arguments. This will give you any random number between 1 and 6 (both inclusive) just like how real dice would work.

Next, create two input fields and a button as shown below:

When the ‘Roll Dice’ button is clicked, get the player names from the input fields and call the function for each player.

You can validate the players’ name fields and prettify the markup with some CSS. For the purpose of brevity, I’m keeping it simple for this guide.

That is it. You can check out the demo here.

Java Random Number Generator

Let’s look at some examples to generate a random number in Java. Later on, we will also look at ThreadLocalRandom and SecureRandom example program.

1. Generate Random integer

Yes, it’s that simple to generate a random integer in java. When we create the Random instance, it generates a long seed value that is used in all the method calls. We can set this seed value in the program, however, it’s not required in most of the cases.

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.

The argument in the is excluded, so we have to provide argument as 11. Also, 0 is included in the generated random number, so we have to keep calling nextInt method until we get a value between 1 and 10. You can extend the above code to generate the random number within any given range.

7. Generate Random byte array

We can generate random bytes and place them into a user-supplied byte array using Random class. The number of random bytes produced is equal to the length of the byte array.

8. ThreadLocalRandom in multithreaded environment

Here is a simple example showing ThreadLocalRandom usage in a multithreaded environment.

Below is a sample output of my execution of the above program.

We can’t set seed value for ThreadLocalRandom instance, it will throw .

ThreadLocalRandom class also has some extra utility methods to generate a random number within a range. For example, to generate a random number between 1 and 10, we can do it like below.

ThreadLocalRandom has similar methods for generating random long and double values.

9. SecureRandom Example

You can use SecureRandom class to generate more secure random numbers using any of the listed providers. A quick SecureRandom example code is given below.

That’s all about generating a random number in Java program.

You can download the example code from our GitHub Repository.

Random Date

Up until now, we generated random temporals containing both date and time components. Similarly, we can use the concept of epoch days to generate random temporals with just date components.

An epoch day is equal to the number of days since the 1 January 1970. So in order to generate a random date, we just have to generate a random number and use that number as the epoch day.

3.1. Bounded

We need a temporal abstraction containing only date components, so java.time.LocalDate seems a good candidate:

Here we’re using the  method to convert each LocalDate to its corresponding epoch day. Similarly, we can verify that this approach is correct:

3.2. Unbounded

In order to generate random dates regardless of any range, we can simply generate a random epoch day:

Our random date generator chooses a random day from 100 years before and after the epoch. Again, the rationale behind this is to generate reasonable date values:

JavaScript

JS Array
concat()
constructor
copyWithin()
entries()
every()
fill()
filter()
find()
findIndex()
forEach()
from()
includes()
indexOf()
isArray()
join()
keys()
length
lastIndexOf()
map()
pop()
prototype
push()
reduce()
reduceRight()
reverse()
shift()
slice()
some()
sort()
splice()
toString()
unshift()
valueOf()

JS Boolean
constructor
prototype
toString()
valueOf()

JS Classes
constructor()
extends
static
super

JS Date
constructor
getDate()
getDay()
getFullYear()
getHours()
getMilliseconds()
getMinutes()
getMonth()
getSeconds()
getTime()
getTimezoneOffset()
getUTCDate()
getUTCDay()
getUTCFullYear()
getUTCHours()
getUTCMilliseconds()
getUTCMinutes()
getUTCMonth()
getUTCSeconds()
now()
parse()
prototype
setDate()
setFullYear()
setHours()
setMilliseconds()
setMinutes()
setMonth()
setSeconds()
setTime()
setUTCDate()
setUTCFullYear()
setUTCHours()
setUTCMilliseconds()
setUTCMinutes()
setUTCMonth()
setUTCSeconds()
toDateString()
toISOString()
toJSON()
toLocaleDateString()
toLocaleTimeString()
toLocaleString()
toString()
toTimeString()
toUTCString()
UTC()
valueOf()

JS Error
name
message

JS Global
decodeURI()
decodeURIComponent()
encodeURI()
encodeURIComponent()
escape()
eval()
Infinity
isFinite()
isNaN()
NaN
Number()
parseFloat()
parseInt()
String()
undefined
unescape()

JS JSON
parse()
stringify()

JS Math
abs()
acos()
acosh()
asin()
asinh()
atan()
atan2()
atanh()
cbrt()
ceil()
clz32()
cos()
cosh()
E
exp()
expm1()
floor()
fround()
LN2
LN10
log()
log10()
log1p()
log2()
LOG2E
LOG10E
max()
min()
PI
pow()
random()
round()
sign()
sin()
sqrt()
SQRT1_2
SQRT2
tan()
tanh()
trunc()

JS Number
constructor
isFinite()
isInteger()
isNaN()
isSafeInteger()
MAX_VALUE
MIN_VALUE
NEGATIVE_INFINITY
NaN
POSITIVE_INFINITY
prototype
toExponential()
toFixed()
toLocaleString()
toPrecision()
toString()
valueOf()

JS OperatorsJS RegExp
constructor
compile()
exec()
g
global
i
ignoreCase
lastIndex
m
multiline
n+
n*
n?
n{X}
n{X,Y}
n{X,}
n$
^n
?=n
?!n
source
test()
toString()

(x|y)
.
\w
\W
\d
\D
\s
\S
\b
\B
\0
\n
\f
\r
\t
\v
\xxx
\xdd
\uxxxx

JS Statements
break
class
continue
debugger
do…while
for
for…in
for…of
function
if…else
return
switch
throw
try…catch
var
while

JS String
charAt()
charCodeAt()
concat()
constructor
endsWith()
fromCharCode()
includes()
indexOf()
lastIndexOf()
length
localeCompare()
match()
prototype
repeat()
replace()
search()
slice()
split()
startsWith()
substr()
substring()
toLocaleLowerCase()
toLocaleUpperCase()
toLowerCase()
toString()
toUpperCase()
trim()
valueOf()

Игра в кости с использованием модуля random в Python

Далее представлен код простой игры в кости, которая поможет понять принцип работы функций модуля random. В игре два участника и два кубика.

  • Участники по очереди бросают кубики, предварительно встряхнув их;
  • Алгоритм высчитывает сумму значений кубиков каждого участника и добавляет полученный результат на доску с результатами;
  • Участник, у которого в результате большее количество очков, выигрывает.

Код программы для игры в кости Python:

Python

import random

PlayerOne = «Анна»
PlayerTwo = «Алекс»

AnnaScore = 0
AlexScore = 0

# У каждого кубика шесть возможных значений
diceOne =
diceTwo =

def playDiceGame():
«»»Оба участника, Анна и Алекс, бросают кубик, используя метод shuffle»»»

for i in range(5):
#оба кубика встряхиваются 5 раз
random.shuffle(diceOne)
random.shuffle(diceTwo)
firstNumber = random.choice(diceOne) # использование метода choice для выбора случайного значения
SecondNumber = random.choice(diceTwo)
return firstNumber + SecondNumber

print(«Игра в кости использует модуль random\n»)

#Давайте сыграем в кости три раза
for i in range(3):
# определим, кто будет бросать кости первым
AlexTossNumber = random.randint(1, 100) # генерация случайного числа от 1 до 100, включая 100
AnnaTossNumber = random.randrange(1, 101, 1) # генерация случайного числа от 1 до 100, не включая 101

if( AlexTossNumber > AnnaTossNumber):
print(«Алекс выиграл жеребьевку.»)
AlexScore = playDiceGame()
AnnaScore = playDiceGame()
else:
print(«Анна выиграла жеребьевку.»)
AnnaScore = playDiceGame()
AlexScore = playDiceGame()

if(AlexScore > AnnaScore):
print («Алекс выиграл игру в кости. Финальный счет Алекса:», AlexScore, «Финальный счет Анны:», AnnaScore, «\n»)
else:
print(«Анна выиграла игру в кости. Финальный счет Анны:», AnnaScore, «Финальный счет Алекса:», AlexScore, «\n»)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

importrandom

PlayerOne=»Анна»

PlayerTwo=»Алекс»

AnnaScore=

AlexScore=

 
# У каждого кубика шесть возможных значений

diceOne=1,2,3,4,5,6

diceTwo=1,2,3,4,5,6

defplayDiceGame()

«»»Оба участника, Анна и Алекс, бросают кубик, используя метод shuffle»»»

foriinrange(5)

#оба кубика встряхиваются 5 раз

random.shuffle(diceOne)

random.shuffle(diceTwo)

firstNumber=random.choice(diceOne)# использование метода choice для выбора случайного значения

SecondNumber=random.choice(diceTwo)

returnfirstNumber+SecondNumber

print(«Игра в кости использует модуль random\n»)

 
#Давайте сыграем в кости три раза

foriinrange(3)

# определим, кто будет бросать кости первым

AlexTossNumber=random.randint(1,100)# генерация случайного числа от 1 до 100, включая 100

AnnaTossNumber=random.randrange(1,101,1)# генерация случайного числа от 1 до 100, не включая 101

if(AlexTossNumber>AnnaTossNumber)

print(«Алекс выиграл жеребьевку.»)

AlexScore=playDiceGame()

AnnaScore=playDiceGame()

else

print(«Анна выиграла жеребьевку.»)

AnnaScore=playDiceGame()

AlexScore=playDiceGame()

if(AlexScore>AnnaScore)

print(«Алекс выиграл игру в кости. Финальный счет Алекса:»,AlexScore,»Финальный счет Анны:»,AnnaScore,»\n»)

else

print(«Анна выиграла игру в кости. Финальный счет Анны:»,AnnaScore,»Финальный счет Алекса:»,AlexScore,»\n»)

Вывод:

Shell

Игра в кости использует модуль random

Анна выиграла жеребьевку.
Анна выиграла игру в кости. Финальный счет Анны: 5 Финальный счет Алекса: 2

Анна выиграла жеребьевку.
Анна выиграла игру в кости. Финальный счет Анны: 10 Финальный счет Алекса: 2

Алекс выиграл жеребьевку.
Анна выиграла игру в кости. Финальный счет Анны: 10 Финальный счет Алекса: 8

1
2
3
4
5
6
7
8
9
10

Игравкостииспользуетмодульrandom

 
Аннавыигралажеребьевку.

Аннавыигралаигрувкости.ФинальныйсчетАнны5ФинальныйсчетАлекса2

 
Аннавыигралажеребьевку.

Аннавыигралаигрувкости.ФинальныйсчетАнны10ФинальныйсчетАлекса2

 
Алексвыигралжеребьевку.

Аннавыигралаигрувкости.ФинальныйсчетАнны10ФинальныйсчетАлекса8

Вот и все. Оставить комментарии можете в секции ниже.

Java Math.random() between 1 to N

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.

Java program to generate floating-point numbers between 1 to 100.

Output:-

10.48550810115520481.26887023085449

The above program generates floating-point numbers but if we want to generate integer numbers then we must type cast the result value.

Java program to generate integer numbers between 1 to 100.

Output:-

2070

Generating Javascript Random Numbers

Javascript creates pseudo-random numbers with the function . This function takes no parameters and creates a random decimal number between 0 and 1. The returned value may be 0, but it will never be 1.

You can use to create whole numbers (integers) or numbers with decimals (floating point numbers). Since creates floating point numbers by default, you can create a random floating point number simply by multiplying your maximum acceptable value by the result from . Therefore, to create a pseudo-random number between 0 and 2.5:

Creating a pseudo-random integer is a little more difficult; you must use the function to round your computed value down to the nearest integer. So, to create a random number between 0 and 10:

Java Math Library

The Java Math class includes a number of features used to perform mathematical functions on numbers. For instance, the Math library includes the method that is used to round a number and the method that is used to calculate the power of a number.

In order to use the Java Math library, we must first import it into our code. We can do so using an import statement like this:

For this tutorial, we are going to use one method from the Math library:

81% of participants stated they felt more confident about their tech job prospects after attending a bootcamp. Get matched to a bootcamp today.

Find Your Bootcamp Match

The average bootcamp grad spent less than six months in career transition, from starting a bootcamp to finding their first job. Start your career switch today.

Find Your Bootcamp Match

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Adblock
detector