Java
Cuidado, esta é uma pergunta complicada .....
A maioria das pessoas em Java usará math.random () para ajudar a gerar essa sequência, mas ficará confusa porque obterá apenas resultados positivos! random()
retorna um valor decimal de 0 a 1 (excluindo 1 em si). Portanto, você deve executar alguns truques para garantir uma boa distribuição de valores aleatórios em todo o intervalo inteiro (positivo e negativo).
Além disso, você não pode simplesmente se multiplicar Math.random()
e Integer.MAX_VALUE
porque isso nunca se incluirá Integer.MAX_VALUE
como parte do resultado! Além disso, seria lógico fazer math.rand() * (Integer.MAX_VALUE + 1)
isso para obter uma distribuição completa, mas, é claro, isso não funciona porque Integer.MAX_VALUE + 1
transbordará e se tornará Integer.MIN_VALUE
! Portanto, infelizmente, a melhor solução é recorrer à manipulação bit a bit dos dados ...
Portanto, aqui está uma sequência completa para gerar valores aleatórios 'n' no intervalo Integer.MIN_VALUE
de Integer.MAX_VALUE
(Inclusive dos dois extremos (que é a parte mais difícil) !!!!):
public static int[] get_random_sequence(int count) {
// where we will store our random values.
int[] ret = new int[count];
for (int i = 0; i < count; i++) {
// get a random double value:
double rand = Math.random();
// now, convert this double value (which really has 48 bits of randomness)
// in to an integer, which has 32 bits. Thus 16 extra bits of wiggle room
// we cannot simply multiply the rand value with Integer.MAX_VALUE
// because we will never actually get Integer.MAX_VALUE
// (since the rand will never exactly == 1.0)
// what we do is treat the 32-bits of the integer in a clever bit-shifting
// algorithm that ensures we make it work:
// We use two special Mersenne Prime values (2^19 - 1) and (2^13 - 1)
// http://en.wikipedia.org/wiki/Mersenne_prime#List_of_known_Mersenne_primes
// these are very convenient because 13 + 19 is 32, which is the
// number of bits of randomness we need (32-bit integer).
// Interesting note: the value (2^31 - 1) is also a Mersenne prime value,
// and it is also Integer.MAX_VALUE. Also, it is a double marsenne prime
// since 31 is also a marsenne prime... (2^(2^5 - 1) - 1). Math is Cool!!!
// 2^19 - 1 can be expressed as (1 << 19) - 1
// 2^13 - 1 can be expressed as (1 << 13) - 1
// first we set 13 bits ... multiply a 13-bit prime by the random number.
ret[i] = (int)(rand * (1 << 13) - 1);
// now shift those 13 random bits 19 bits left:
ret[i] <<= 19;
// now add in the 19 random bits:
ret[i] ^= (int)(rand * (1 << 19) - 1);
}
return ret;
}
Isso produz resultados como:
[-368095066, -1128405482, 1537924507, -1864071334, -130039258, 2020328364, -2028717867, 1796954379, 276857934, -1378521391]
Obviamente, o acima é uma resposta completa da BS. Ele não produz uma boa descrição e 'oculta' um bug grave ( ^=
deveria ser |=
). também oculta um bug menos grave (a ordem-pf-precedence significa que na verdade não multiplicamos por um valor primordial!) Usar palavras sofisticadas, números primos e muitos comentários não é motivo para confiar no código ... Obviamente, se você quiser fazer o acima, você deve apenas usarjava.util.Random.nextInt()