¿Cómo puedo obtener un número aleatorio en Kotlin?

Mi sugerencia sería un la extensión de función en IntRange para crear randoms como este: (0..10).random()

TL;DR Kotlin >= 1.3, uno Aleatorio para todas las plataformas

Como de 1.3, Kotlin viene con su propio multi-plataforma generador de números Aleatorios. Se describe en este MANTENER. La extensión se describe a continuación es ahora parte de la Kotlin de la biblioteca estándar, simplemente lo utilizan como este:

val rnds = (0..10).random()

Kotlin < 1.3

Antes de 1.3, en la JVM utilizamos Random o incluso ThreadLocalRandom si estamos en el JDK > 1.6.

fun IntRange.random() = 
       Random().nextInt((endInclusive + 1) - start) + start

Utilizado como esta:

//will return an `Int` between 0 and 10 (incl.)
(0..10).random()

Si quería que la función sólo para volver a 1, 2, ..., 9 (10 no incluido), un intervalo construido con hasta:

(0 until 10).random()

Si estás trabajando con JDK > 1.6, uso ThreadLocalRandom.actual() en lugar de Random().

KotlinJs y otras variaciones

Para kotlinjs y otros casos de uso que no se permite el uso de java.util.Random, ver esta alternativa.

También ver este respuesta para las variaciones de mi sugerencia. También incluye una función de extensión en el que el azar Chars.

Genera un entero aleatorio entre from(inclusive) y to(exclusivo)

import java.util.Random

val random = Random()

fun rand(from: Int, to: Int) : Int {
    return random.nextInt(to - from) + from
}

Como de kotlin 1.2, usted podría escribir:

(1..3).shuffled().last()

Acaba de ser conscientes de que es grande O(n), pero para una pequeña lista (especialmente de valores únicos) está bien, está bien 😀

Puede crear un función de extensión similar a java.util.Azar.nextInt(int) pero que requiere un IntRange en lugar de un Int para su límite:

fun Random.nextInt(range: IntRange): Int {
    return range.start + nextInt(range.last - range.start)
}

Usted ahora puede utilizar con cualquier al Azar ejemplo:

val random = Random()
println(random.nextInt(5..9)) //prints 5, 6, 7, or 8

Si usted no quiere tener que gestionar su propio Random instancia, a continuación, puede definir una comodidad método que utiliza, por ejemplo, ThreadLocalRandom.actual():

fun rand(range: IntRange): Int {
    return ThreadLocalRandom.current().nextInt(range)
}

Ahora usted puede obtener un entero aleatorio como en Ruby sin necesidad de declarar un Random instancia:

rand(5..9) //returns 5, 6, 7, or 8

Posible Variación a mi otra respuesta aleatoria de caracteres

Con el fin de obtener al azar Chars, se puede definir una función de extensión como esta

fun ClosedRange<Char>.random(): Char = 
       (Random().nextInt(endInclusive.toInt() + 1 - start.toInt()) + start.toInt()).toChar()

//will return a `Char` between A and Z (incl.)
('A'..'Z').random()

Si estás trabajando con JDK > 1.6, uso ThreadLocalRandom.actual() en lugar de Random().

Para kotlinjs y otros casos de uso que no se permite el uso de java.util.Random, esta respuesta ayudará.

Kotlin >= 1.3 soporte multiplataforma para el Azar

Como de 1.3, Kotlin viene con su propio multiplataforma generador de números Aleatorios. Se describe en este MANTENER. Ahora puede utilizar directamente la extensión como parte de la Kotlin de la biblioteca estándar, sin definir:

('a'..'b').random()

Edificio de @s1m0nw1 excelente respuesta que he hecho los siguientes cambios.

1. (0..n) implica incluido en Kotlin
2. (0 hasta n) implica exclusiva en Kotlin
3. El uso de un objeto singleton para el Azar instancia (opcional)

Código:

private object RandomRangeSingleton : Random()

fun ClosedRange<Int>.random() = RandomRangeSingleton.nextInt((endInclusive + 1) - start) + start

Caso De Prueba:

fun testRandom() {
        Assert.assertTrue(
                (0..1000).all {
                    (0..5).contains((0..5).random())
                }
        )
        Assert.assertTrue(
                (0..1000).all {
                    (0..4).contains((0 until 5).random())
                }
        )
        Assert.assertFalse(
                (0..1000).all {
                    (0..4).contains((0..5).random())
                }
        )
    }

Ejemplos al azar en el intervalo [1, 10]

val random1 = (0..10).shuffled().last()

o la utilización de Java Azar

val random2 = Random().nextInt(10) + 1

Kotlin >= 1.3, soporte multiplataforma para el Azar

Como de 1.3, la biblioteca estándar proporciona soporte multi-plataforma para randoms, ver este respuesta.

Kotlin < 1.3 en JavaScript

Si usted está trabajando con Kotlin JavaScript y no tienen acceso a java.util.Random, los siguientes:

fun IntRange.random() = (Math.random() * ((endInclusive + 1) - start) + start).toInt()

Utilizado como esta:

//will return an `Int` between 0 and 10 (incl.)
(0..10).random()

Otra forma de aplicación de s1m0nw1 la respuesta sería acceder a él a través de una variable. No es que sus más eficiente, pero le ahorra de tener que escribir ().

val ClosedRange<Int>.random: Int
    get() = Random().nextInt((endInclusive + 1) - start) +  start 

Y ahora se puede acceder como tal

(1..10).random

No existe un método estándar que hace esto, pero usted puede crear fácilmente su propio uso de cualquiera de Math.random() o la clase java.util.Random. Aquí hay un ejemplo de uso de la Math.random() método:

fun random(n: Int) = (Math.random() * n).toInt()
fun random(from: Int, to: Int) = (Math.random() * (to - from) + from).toInt()
fun random(pair: Pair<Int, Int>) = random(pair.first, pair.second)

fun main(args: Array<String>) {
    val n = 10

    val rand1 = random(n)
    val rand2 = random(5, n)
    val rand3 = random(5 to n)

    println(List(10) { random(n) })
    println(List(10) { random(5 to n) })
}

Este es un ejemplo de salida:

[9, 8, 1, 7, 5, 6, 9, 8, 1, 9]
[5, 8, 9, 7, 6, 6, 8, 6, 7, 9]

Si los números que desea elegir no son consecutivos, puede utilizar random().

Uso:

val list = listOf(3, 1, 4, 5)
val number = list.random()

Devuelve uno de los números que están en la lista.

El uso de una función de nivel superior, usted puede lograr exactamente la misma sintaxis de la llamada como en Ruby (como se quiera):

fun rand(s: Int, e: Int) = Random.nextInt(s, e + 1)

Uso:

rand(1, 3) //returns either 1, 2 or 3

Primero, usted necesita un generador de números aleatorios. En Kotlin usted necesita actualmente el uso de la plataforma específicas (no hay un Kotlin construido en uno). Para la JVM es java.util.Al azar. Usted tendrá que crear una instancia de ella y, a continuación, llamar a random.nextInt(n).

Kotlin estándar lib no ofrecen un Generador de números Aleatorios de la API. Si usted no está en un proyecto multiplataforma, es mejor usar la api de plataforma (todas las demás respuestas de la pregunta que hablar de esta solución).

Pero si usted está en una multiplataforma contexto, la mejor solución es implementar el azar por sí mismo en el más puro kotlin para compartir el mismo generador de números aleatorios entre plataformas. Es más sencillo para dev y pruebas.

Para responder a este problema en mi proyecto personal, puedo implementar un puro Kotlin Lineal Congruential Generador. LCG es el algoritmo utilizado por java.util.Random. Siga este enlace si desea utilizar :
https://gist.github.com/11e5ddb567786af0ed1ae4d7f57441d4

Mi implementación propósito nextInt(range: IntRange) para ti ;).

Tener cuidado acerca de mi propósito, LCG es bueno para la mayoría de los casos de uso (simulación, juegos, etc…) pero no es adecuado para el uso de criptografía debido a la previsibilidad de este método.

De Kotlin 1.3 se puede hacer como

val number = Random.nextInt(limit)

No hay necesidad de usar el perfil de la extensión de las funciones más. IntRange tiene un random() función de extensión de out-of-the-box ahora.

val randomNumber = (0..10).random()

Para obtener un aleatorio Int número de Kotlin utilice el método siguiente:

import java.util.concurrent.ThreadLocalRandom

fun randomInt(rangeFirstNum:Int, rangeLastNum:Int) {
    val randomInteger = ThreadLocalRandom.current().nextInt(rangeFirstNum,rangeLastNum)
    println(randomInteger)
}
fun main() {    
    randomInt(1,10)
}


//Result – random Int numbers from 1 to 9

Espero que esto ayude.

Puede crear una función de extensión:

infix fun ClosedRange<Float>.step(step: Float): Iterable<Float> {
    require(start.isFinite())
    require(endInclusive.isFinite())
    require(step.round() > 0.0) { "Step must be positive, was: $step." }
    require(start != endInclusive) { "Start and endInclusive must not be the same"}

    if (endInclusive > start) {
        return generateSequence(start) { previous ->
            if (previous == Float.POSITIVE_INFINITY) return@generateSequence null
            val next = previous + step.round()
            if (next > endInclusive) null else next.round()
        }.asIterable()
    }

    return generateSequence(start) { previous ->
        if (previous == Float.NEGATIVE_INFINITY) return@generateSequence null
        val next = previous - step.round()
        if (next < endInclusive) null else next.round()
    }.asIterable()
}

Ronda valor Float:

fun Float.round(decimals: Int = DIGITS): Float {
    var multiplier = 1.0f
    repeat(decimals) { multiplier *= 10 }
    return round(this * multiplier) / multiplier
}

Método de uso:

(0.0f .. 1.0f).step(.1f).forEach { System.out.println("value: $it") }

De salida:

valor: 0.0 valor: 0.1 valor: 0.2 valor: 0.3 valor: 0.4 valor: 0.5
valor: 0.6 valor: 0.7 valor: 0.8 valor: 0.9 valor: 1.0

a ser super duper ))

 fun rnd_int(min: Int, max: Int): Int {
        var max = max
        max -= min
        return (Math.random() * ++max).toInt() + min
    }