Перестаньте использовать unityengine.random

std::generate

Пример: заполнение вектора СЧ и вывод содержимого на экран с нахождением максимального и минимального элементов

#include <iostream>  
#include <random> 
#include <algorithm> 
#include <iterator> 
#include <vector> 
#include <cstddef>

int main() 
{ 
    std::mt19937 gen { std::random_device()() }; 
    std::uniform_int_distribution<int> uid(, 100); 
    const std::size_t N = 50; 
    std::vector<int> v(N); 
    // генерируем 50 СЧ 
    std::generate(v.begin(), v.begin() + N, () -> int 
        { return uid(gen); } ); 
    // выводимсодержимоевекторанаэкран 
    std::copy(v.begin(), v.begin() + N, std::ostream_iterator<int> (std::cout, » «) ); 
    auto mm = std::minmax_element(v.begin(), v.begin() + N); 
    std::cout << «\nMin: » << *mm.first << «\nMax: » << *mm.second << std::endl; 
} 

Using the random number generator to choose prizes for users

You can easily imitate dice rolling by using a random number generator.

Let’s say you are organizing a prize giveaway for your users. However, the prizes need to be selected randomly while also keeping users entertained. A random dice roll is a solid option.

The following example of the C++ code shows how the roll dice feature lets you randomly pick prizes for your users (according to the number rolled). For this aim, you should also use the switch statement to present different outcomes:

Example Copy

The code example above represents a simple way of using the random number generator for real purposes. To learn more about the way such generators come to life, continue reading this tutorial.

Что такое случайные числа?

Случайные числа представляют собой произвольные данные, которые были получены в результате автоматической генерации компьютерной программой. Подобная информация используется во многих видах программного обеспечения, где необходимо иметь дело с непредсказуемыми величинами. Ярким примером тому являются игровые автоматы либо казино, в которых каждый раз генерируется новая выигрышная комбинация чисел. Также данный подход применяется в криптографических целях для создания надежных паролей.

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

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

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

Реализации случайных чисел в Python

Язык программирования Python содержит в себе несколько разных модулей, применяемых для генерации псевдослучайных величин. Все они, как правило, используют в своих целях текущее системное время, которое установлено на компьютере. Это гарантирует получение разных последовательностей значений при каждом новом обращении к генератору. Среди инструментов, которые предназначены для работы с псевдослучайными числами, находится довольно обширная библиотека random, а также функции numpy.random и os.urandom.

Особенности их применения:

• Стандартный модуль random в Python 3 включает множество методов для генерации как целых, так и вещественных чисел, а также последовательностей с определенными параметрами.
• Функция numpy.random используется для заполнения массивов случайными величинами.
• Функция os.urandom предоставляет набор из случайных байтов, что применимо в криптографии.

В модуле random есть класс SystemRandom, внутри реализации которого идет обращение как раз к os.urandom. В этом альтернативном генераторе реализованы те же функции, но их уже можно применять в криптографии.

Наиболее широкое применение получила в Python библиотека random. Поэтому далее мы ее и рассмотрим подробно.

Random.hpp

Класс, который реализован здесь использует синглетон Майерса, чтобы сделать статические методы получения случайных значений в определённом диапазоне. Гораздо же проще вызывать в нужном месте один статический метод класса, чем каждый раз предварительно инициализировать все генераторы случайных чисел. Сам класс работает как с целочисленными типами, так и типами значений с плавающей запятой.

#ifndef RANDOM_HPP
#define RANDOM_HPP

#include <random>

namespace details
{
    /// True if type T is applicable by a std::uniform_int_distribution
    template<class T>
    struct is_uniform_int {
        static constexpr bool value =
                std::is_same<T,              short>::value ||
                std::is_same<T,                int>::value ||
                std::is_same<T,               long>::value ||
                std::is_same<T,          long long>::value ||
                std::is_same<T,     unsigned short>::value ||
                std::is_same<T,       unsigned int>::value ||
                std::is_same<T,      unsigned long>::value ||
                std::is_same<T, unsigned long long>::value;
    };

    /// True if type T is applicable by a std::uniform_real_distribution
    template<class T>
    struct is_uniform_real {
        static constexpr bool value =
                std::is_same<T,       float>::value ||
                std::is_same<T,      double>::value ||
                std::is_same<T, long double>::value;
    };
}

class Random
{
    template <class T> using IntDist = std::uniform_int_distribution<T>;
    template <class T> using RealDist = std::uniform_real_distribution<T>;

public:
    template <class T>
    static typename std::enable_if<details::is_uniform_int<T>::value, T>::type get(T from = std::numeric_limits<T>::min(), T to = std::numeric_limits<T>::max())
    {
        if (from > to) std::swap(from, to);
        IntDist<T> dist{from, to};
        return dist(instance().engine());
    }

    template <class T>
    static typename std::enable_if<details::is_uniform_real<T>::value, T>::type get(T from = std::numeric_limits<T>::min(), T to = std::numeric_limits<T>::max())
    {
        if (from > to) std::swap(from, to);
        RealDist<T> dist{from, to};
        return dist(instance().engine());
    }

    std::mt19937& engine() { return m_mt; }

protected:
    static Random& instance()
    {
        static Random inst;
        return inst;
    }

private:
    std::random_device m_rd; // Устройство генерации случайных чисел
    std::mt19937 m_mt;       // Стандартный генератор случайных чисел

    Random() : m_mt(m_rd()) {}
    ~Random() {}
    Random(const Random&) = delete;
    Random& operator = (const Random&) = delete;
};

#endif // RANDOM_HPP

main.cpp

А теперь применение

#include <QCoreApplication>

#include "Random.hpp"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    std::cout << "Random STD  - ";
    for (int i = 0; i < 15; ++i)
    {
        std::cout << Random::get(15, 43) << " ";
    }
    std::cout << std::endl;
    return a.exec();
}

Вывод

Random STD  - 38 29 36 38 21 32 33 39 31 15 33 16 36 38 35

В данном случае мы действительно получим случайный вывод чисел, а также числа не будут повторяться при каждом запуске программы. Что касается случайности, то я убедился в этом лично, когда для генерации уровня в игре применил данный класса Random. Каждый раз расстановка объектов в игре не повторялась. Чего очень сложно было достичь с использованием qrand .

Так что из ништяков C++11 можно выделить достаточно качественную генерацию псевдослучайных чисел.

Зачем нужны функции getstate() и setstate() ?

Если вы получили предыдущее состояние и восстановили его, тогда вы сможете оперировать одними и теми же случайными данными раз за разом. Помните, что использовать другую функцию random в данном случае нельзя. Также нельзя изменить значения заданных параметров. Сделав это, вы измените значение состояния .

Для закрепления понимания принципов работы и в генераторе случайных данных Python рассмотрим следующий пример:

Python

import random

number_list =

print(«Первая выборка «, random.sample(number_list,k=5))

# хранит текущее состояние в объекте state
state = random.getstate()

print(«Вторая выборка «, random.sample(number_list,k=5))

# Восстанавливает состояние state, используя setstate
random.setstate(state)

#Теперь будет выведен тот же список второй выборки
print(«Третья выборка «, random.sample(number_list,k=5))

# Восстанавливает текущее состояние state
random.setstate(state)

# Вновь будет выведен тот же список второй выборки
print(«Четвертая выборка «, random.sample(number_list,k=5))

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

importrandom number_list=3,6,9,12,15,18,21,24,27,30 print(«Первая выборка «,random.sample(number_list,k=5))   # хранит текущее состояние в объекте state state=random.getstate() print(«Вторая выборка «,random.sample(number_list,k=5))   # Восстанавливает состояние state, используя setstate random.setstate(state)   #Теперь будет выведен тот же список второй выборки print(«Третья выборка «,random.sample(number_list,k=5))   # Восстанавливает текущее состояние state random.setstate(state)   # Вновь будет выведен тот же список второй выборки print(«Четвертая выборка «,random.sample(number_list,k=5))

Вывод:

Shell

Первая выборка
Вторая выборка
Третья выборка
Четвертая выборка

1 2 3 4

Перваявыборка18,15,30,9,6 Втораявыборка27,15,12,9,6 Третьявыборка27,15,12,9,6 Четвертаявыборка27,15,12,9,6

Как можно заметить в результате вывода — мы получили одинаковые наборы данных. Это произошло из-за сброса генератора случайных данных.

Случайные числа в си

На этому уроке мы научимся использовать случайные числа в программах на си. Часто в программах, например играх,  необходимо получить случайное число. В Си используется функция для определения натурального  случайного числа в диапазоне от 0 до 32767.rand();
Чтобы использовать эту функцию необходимо указать заголовочный файл в начале программы stdlib.h
Чтобы получить случайное число  в диапазоне от 0 до N-1 используется выражениеrand() % N;Пример программы 18 Программа на си для вывода последовательности случайных чисел в  заданном диапазоне#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
main()
{
int n;
int m;
int i;
int ran;
printf («Введите границу диапазона\n «);
scanf («%d», &n);
printf («Введите сколько нужно вывести чисел\n»);
scanf («%d», &m);
for (i=1; i<=m; i++)
{
   ran=rand()%n;//  задаем случайное число в диапазоне от 0 до n
   printf («%d\n», ran);
}
getch();
}

Следует заметить, что данная функция будет всегда выдавать одну и ту же последовательность, при каждом запуске программы. Это обусловлено тем, что каждое последующее число рассчитывается по формуле в зависимости от предыдущего. Иногда,  необходимо выдавать всегда разные непредсказуемые случайные числа. Для этого можно использовать системное время компьютера.
Чтобы вызвать системное время компьютера (например секунды) используется заголовочный файл time.h  Объявить его в начале программы  #include <time.h>
Использовать функцию, которую необходимо разместить в начале программы.
// функция,  выдающая системное время секундыint sec()
{
time_t t;
struct tm *t_m;
t=time(NULL);
t_m=localtime(&t);
return t_m->tm_sec;
}

Далее в программе, где нам нужно задать случайное число мы используем  выражение((rand()+sec())%NПример программы 19 Игра на си орел решка Программа имитирует подбрасывание монетки Орел Решка#include <graphics.h>
#include <conio.h>
#include <time.h>
// функция выдающая системное время секунды
int sec()
{
time_t t;
struct tm *t_m;
t=time(NULL);
t_m=localtime(&t);
return t_m->tm_sec;
}
main()
{
int r;//  выбор компьютера
int ans; // ответ на вопрос о продолжении игры
ans=1;
// игра продолжается пока ответ на продолжении игры  1

while(ans==1)
{
r=(rand()+sec()) % 2; // определяем  случайное число в диапазоне от 0 до 1
printf(«%d «, r);
if (r==0) {printf(«Орел\n»);}
if (r==1) {printf(«Решка\n»);}
printf(«Сыграть еще раз? 1 — Да 2 — Нет\n»);
scanf(«%d», &ans);
}
getch();
}

   Вернуться к содержанию         Перейти к следующему уроку Процедуры и функции в Си

Полезно почитать по теме случайные числа в си примеры программИгра на си камень ножницы бумагаСлучайный графический узор на си

Поделиться

Знакомство с новым ГПСЧ

Мы будем использовать генератор mersenne twister, а точнее mt19937. Основанный на свойствах простых чисел, он подходит для решения большинства задач. Несмотря на то, что степень его «случайности» весьма неплоха, он все-таки является ГПСЧ. Генерирует СЧ он достаточно быстро и хватить его должно с головой.

Определен он, как и все, что мы далее будем рассматривать, в хедере random и пространстве имен std. Является 32-битным генератором, имеет собрата mt19937_64, являющегося 64-битным.В конструкторе может инициализироваться величиной, от которой начинается генерация последовательности, либо специальным объектом seed_seq, являющимся зерном последовательности. Мы будем использовать первый вариант.

Пример: создание переменных std::mt19937

#include <random>  
#include <ctime>  
 int main() 
{ 
    std::mt19937 gen1, gen2(time());
} 

Пример: использование метода seed

#include <random>  
#include <ctime>  int main() 
{ 
    std::mt19937 gen; 
    gen.seed(time());
}

Пример: генерация СЧ и вывод на экран

#include <iostream>  
#include <random> 
#include <ctime>

int main() 
{ 
    std::mt19937 gen; 
    gen.seed(time()); // try to comment this string 
    std::cout << «My number: » << gen() << std::endl; 
}

Примеры

Чтобы воспользоваться возможностями генерации случайных чисел в Python 3, следует произвести импорт библиотеки random, вынеся ее в начало исполняемого файла при помощи ключевого слова import.

Вещественные числа

В модуле есть одноименная функция random. В Python она используется чаще, чем другие функции этого модуля. Функция возвращает вещественное число в промежутке от 0 до 1. В следующем примере демонстрируется создание трех разных переменных a, b и c.

import random
a = random.random()
b = random.random()
print(a)
print(b)

0.547933286519
0.456436031781

Целые числа

Для получения случайных целых чисел в определенном диапазоне используется функция randint, принимающая два аргумента: минимальное и максимальное значение. Программа, показанная ниже отображает генерацию трех разных значений в промежутке от 0 до 9.

import random
a = random.randint(0, 9)
b = random.randint(0, 9)
print(a)
print(b)

4
7

Диапазоны целых

Метод randrange позволяет генерировать целочисленные значения, благодаря работе с тремя параметрами: минимальная и максимальная величина, а также длина шага. Вызвав функцию с одним аргументом, начальная граница получит значение 0, а интервал станет равен 1. Для двух аргументов автоматически инициализируется только длина шага. Работа данного метода с трема разными наборами параметров показана в следующем примере.

import random
a = random.randrange(10)
b = random.randrange(2, 10)
c = random.randrange(2, 10, 2)
print(a)
print(b)
print(c)

9
5
2

Диапазоны вещественных

Сгенерировать вещественное число поможет метод под названием uniform. Он принимает всего два аргумента, обозначающих минимальное и максимальное значения. Демонстрация его работы располагается в следующем примере кода, где создаются переменные a, b и c.

import random
a = random.uniform(0, 10)
b = random.uniform(0, 10)
print(a)
print(b)

4.85687375091
3.66695202551

Использование в генераторах

Возможности генерации псевдослучайных чисел можно использовать и для создания последовательностей. В следующем фрагменте кода создается набор чисел при помощи генератора списка со случайным наполнением и длиной. Как можно заметить, в данном примере функция randint вызывается дважды: для каждого элемента и размера списка.

import random
a = 
print(a)

Перемешивание

Метод shuffle дает возможность перемешать содержимое уже созданного списка. Таким образом, все его элементы будут находиться в абсолютно случайном порядке. Пример, где отображается работа этой функции со списком a из 10 значений, располагается дальше.

import random
a = 
random.shuffle(a)
print(a)

Случайный элемент списка

При помощи функции choice можно извлечь случайный элемент из существующего набора данных. В следующем примере переменная b получает некое целое число из списка a.

import random
a = 
b = random.choice(a)
print(b)

7

Несколько элементов списка

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

import random
a = 
a = random.sample(a, 5)
print(a)

Генерация букв

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

import random
import string
a = random.choice(string.letters)
b = random.choice(string.letters)
c = random.choice(string.letters)
print(a)
print(b)
print(c)

J
i
L

Как можно заметить, отображаются буквы в разном регистре. Для того чтобы преобразовать их к общему виду, рекомендуется вызвать стандартные строковые методы upper или lower.

SystemRandom

Как уже говорилось ранее, SystemRandom основана на os.urandom. Она выдает так же псевдослучайные данные, но они зависят дополнительно и от операционной системы. Результаты используются в криптографии. Есть недостаток — то что функции SystemRandom отрабатывают в несколько раз дольше. Рассмотрим пример использования:

import random
sr = random.SystemRandom()
a = sr.random()
b = sr.randint(0, 9)
c = sr.randrange(2, 10, 2)
print(a)
print(b)
print(c)

0.36012464614815465
2
8

Алгоритм перемешивания

Часто возникает задача расставить уже имеющийся набор значений в произвольном порядке. С этой целью также используется генератор псевдослучайных чисел. При этом создается массив и заполняется значениями.
Сама процедура перемешивания происходит следующим образом. Генерируется два значения индексов массива случайным образом, и значения элементов с полученными индексами меняются местами. Процедура повторяется не менее N раз, где N — количество элементов массива.
В качестве примера рассмотрим перемешивание 20 значений (от 1 до 20) и повторим процедуру 20 раз.Реализация на Си

123456789101112131415161718192021222324252627282930

#include <stdio.h>#include <stdlib.h>#include <time.h>#define SIZE 20int main() {  int a;  srand(time(NULL));  // Заполняем массив последовательными значениями от 1 до 20  for (int i = 0; i < SIZE; i++)  {    a = i + 1;    printf(«%2d «, a);  }  for (int i = 0; i < SIZE; i++)  {    // Генерируем случайно два индекса элементов    int ind1 = rand() % 20;    int ind2 = rand() % 20;    // и меняем местами элементы с этими индексами    int temp = a;    a = a;    a = temp;  }  printf(«\n»);  // Выводим получившийся массив  for (int i = 0; i < SIZE; i++)    printf(«%2d «, a);  getchar();  return 0;}

Методы

	Создает экземпляр реализации по умолчанию криптографического генератора случайных чисел, позволяющего генерировать случайные данные.Creates an instance of the default implementation of a cryptographic random number generator that can be used to generate random data.
	Создает экземпляр указанной реализации криптографического генератора случайных чисел.Creates an instance of the specified implementation of a cryptographic random number generator.
	При переопределении в производном классе освобождает все ресурсы, используемые текущим объектом RandomNumberGenerator.When overridden in a derived class, releases all resources used by the current instance of the RandomNumberGenerator class.
	При переопределении в производном классе освобождает неуправляемые ресурсы, используемые объектом RandomNumberGenerator, и опционально освобождает управляемые ресурсы.When overridden in a derived class, releases the unmanaged resources used by the RandomNumberGenerator and optionally releases the managed resources.
	Определяет, равен ли указанный объект текущему объекту.Determines whether the specified object is equal to the current object. (Унаследовано от Object)
	Заполняет диапазон криптостойкими случайными байтами.Fills a span with cryptographically strong random bytes.
	При переопределении в производном классе заполняет массив байтов криптостойкой случайной последовательностью значений.When overridden in a derived class, fills an array of bytes with a cryptographically strong random sequence of values.
	Заполняет указанный массив байтов криптостойкой случайной последовательностью значений.Fills the specified byte array with a cryptographically strong random sequence of values.
	Заполняет диапазон криптостойкими случайными байтами.Fills a span with cryptographically strong random bytes.
	Служит хэш-функцией по умолчанию.Serves as the default hash function. (Унаследовано от Object)
	Создает случайное целое число от 0 (включительно) до указанного исключенного верхнего предела, используя генератор криптостойких случайных чисел.Generates a random integer between 0 (inclusive) and a specified exclusive upper bound using a cryptographically strong random number generator.
	Создает случайное целое число от указанного включенного нижнего предела до указанного исключенного верхнего предела, используя генератор криптостойких случайных чисел.Generates a random integer between a specified inclusive lower bound and a specified exclusive upper bound using a cryptographically strong random number generator.
	При переопределении в производном классе заполняет массив байтов криптостойкой случайной последовательностью ненулевых значений.When overridden in a derived class, fills an array of bytes with a cryptographically strong random sequence of nonzero values.
	Заполняет диапазон байтов криптостойкой последовательностью случайных ненулевых значений.Fills a byte span with a cryptographically strong random sequence of nonzero values.
	Возвращает объект Type для текущего экземпляра.Gets the Type of the current instance. (Унаследовано от Object)
	Создает неполную копию текущего объекта Object.Creates a shallow copy of the current Object. (Унаследовано от Object)
	Возвращает строку, представляющую текущий объект.Returns a string that represents the current object. (Унаследовано от Object)

Функция srand().

Да, каждый раз появляются одни и те же одинаковые числа. «Так себе генератор!» – скажете вы. И будете не совсем правы.
Действительно, генерируются всё время одинаковые числа. Но мы можем на это повлиять, для этого используется функция srand(), которая также определена в заголовочном файле stdlib.h. Она инициализирует генератор случайных чисел начальным числом.

Скомпилируйте и запустите несколько раз вот эту программу:

Листинг 5.

#include <stdio.h>
#include <stdlib.h>
 
int main(void) {
  srand(2);
/* генерируем пять случайных целых чисел из отрезка  */
  printf("%d\n", 80 + rand()%(100 - 80 + 1));
  printf("%d\n", 80 + rand()%(100 - 79));
  printf("%d\n", 80 + rand()%21);
  printf("%d\n", 80 + rand()%21);
  printf("%d\n", 80 + rand()%21);
}

Теперь поменяйте аргумент функции srand() на другое число (надеюсь вы ещё не забыли, что такое аргумент функции?) и снова скомпилируйте и запустите программу. Последовательность чисел должна измениться. Как только мы меняем аргумент в функции srand – меняется и последовательность. Не очень практично, не правда ли? Чтобы изменить последовательность, нужно перекомпилировать программу. Вот бы это число туда подставлялось автоматически.

И это можно сделать. Например, воспользуемся функцией time(), которая определена в заголовочном файле time.h.
Данная функция, если ей в качестве аргумента передать NULL, возвращает количество секунд, прошедших c 1 января 1970 года. Вот посмотрите, как это делается.

Листинг 6.

#include <stdio.h>
#include <stdlib.h>
#include <time.h> // чтобы использовать функцию time()
 
int main(void) {
  srand(time(NULL));
/* генерируем пять случайных целых чисел из отрезка  */
  printf("%d\n", 80 + rand()%(100 - 80 + 1));
  printf("%d\n", 80 + rand()%(100 - 79));
  printf("%d\n", 80 + rand()%21);
  printf("%d\n", 80 + rand()%21);
  printf("%d\n", 80 + rand()%21);
}

Вы спросите, а что такое NULL? Резонный вопрос. А я вам пока отвечу, что это специальное зарезервированное слово такое. Могу ещё сказать, что им обозначает нулевой указатель, но т.к. это для вас никакой информации не несёт, то на данный момент рекомендую об этом не думать. А просто запомнить как некоторый хитрый трюк. В будущих уроках мы остановимся на этой штуке поподробнее.

Генерация случайных чисел с помощью класса Math

Чтобы сгенерировать случайное число Java предоставляет класс Math, доступный в пакете java.util. Этот класс содержит статичный метод Math.random(), предназначенный для генерации случайных чисел типа double .

Метод random( ) возвращает положительное число большее или равное 0,0 и меньшее 1,0. При вызове данного метода создается объект генератора псевдослучайных чисел java.util.Random.

Math.random() можно использовать с параметрами и без. В параметрах задается диапазон чисел, в пределах которого будут генерироваться случайные значения.

Пример использования Math.random():

public static double getRandomNumber(){
    double x = Math.random();
    return x;
}

Метод getRandomNumber( ) использует Math.random() для возврата положительного числа, которое больше или равно 0,0 или меньше 1,0 .

Результат выполнения кода:

Double between 0.0 and 1.0: SimpleRandomNumber = 0.21753313144345698

Случайные числа в заданном диапазоне

Для генерации случайных чисел в заданном диапазоне необходимо указать диапазон. Синтаксис:

(Math.random() * ((max - min) + 1)) + min

Разобьем это выражение на части:

1. Сначала умножаем диапазон значений на результат, который генерирует метод random().Math.random() * (max — min)возвращает значение в диапазоне , где max не входит в заданные рамки. Например, выражение Math.random()*5 вернет значение в диапазоне , в который 5 не входит.
2. Расширяем охват до нужного диапазона. Это делается с помощью минимального значения.

(Math.random() * ( max - min )) + min

Но выражение по-прежнему не охватывает максимальное значение.

Чтобы получить максимальное значение, прибавьте 1 к параметру диапазона (max — min). Это вернет случайное число в указанном диапазоне.

double x = (Math.random()*((max-min)+1))+min;

Существуют различные способы реализации приведенного выше выражения. Рассмотрим некоторые из них.

Случайное двойное число в заданном диапазоне

По умолчанию метод Math.random() при каждом вызове возвращает случайное число типа double . Например:

public static double getRandomDoubleBetweenRange(double min, double max){
    double x = (Math.random()*((max-min)+1))+min;
    return x;
}

Вы можете вызвать предыдущий метод из метода main, передав аргументы, подобные этому.

System.out.println("Double between 5.0 and 10.00: RandomDoubleNumber = 
"+getRandomDoubleBetweenRange(5.0, 10.00));

Результат.

System.out.println("Double between 5.0 and 10.00: RandomDoubleNumber = 
"+getRandomDoubleBetweenRange(5.0, 10.00));

Случайное целое число в заданном диапазоне

Пример генерации случайного целочисленного значения в указанном диапазоне:

public static double getRandomIntegerBetweenRange(double min, double max){
    double x = (int)(Math.random()*((max-min)+1))+min;
    return x;
}

Метод getRandomIntegerBetweenRange() создает случайное целое число в указанном диапазоне. Так как Math.random() генерирует случайные числа с плавающей запятой, то нужно привести полученное значение к типу int. Этот метод можно вызвать из метода main, передав ему аргументы следующим образом:

System.out.println("Integer between 2 and 6: RandomIntegerNumber 
= "+getRandomIntegerBetweenRange(2,6));

Результат.

Integer between 2 and 6: RandomIntegerNumber = 5

Примечание. В аргументах также можно передать диапазон отрицательных значений, чтобы сгенерировать случайное отрицательное число в этом диапазоне.