Un método genérico que puede devolver un entero aleatorio entre 2 parámetros como ruby hace con rand(0..n).

Alguna sugerencia?

InformationsquelleAutor Yago Azedias | 2017-08-15

19 Comentarios

  1. 307

    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.

    • Supongo que esto también utiliza Java java.util.Random?
    • De hecho. He añadido otra respuesta que no hacen uso de él: stackoverflow.com/a/49507413/8073652
    • También hay una propuesta de aquí para agregar un Criptográficamente Segura Pseudo-Random Number Generator (CSPRNG) aquí: github.com/Kotlin/KEEP/issues/184
    • usando hasta, 0 es la inclusión de la derecha?
  2. 39

    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
    }
  3. 27

    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 😀

    • esto es útil para kotlin nativos
  4. 10

    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
  5. 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()
  6. 7

    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())
                    }
            )
        }
  7. 5

    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
    • Su primera respuesta que más me gusta. Es un perfecto recubrimiento que no requre a escribir las funciones de extensión
  8. 4

    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()
  9. 4

    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
  10. 2

    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]
  11. 2

    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.

  12. 2

    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
  13. 1

    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).

  14. 1

    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.

    • Prefiero confiar en la plataforma de código específico de hacer mi propio algoritmo aleatorio. Esto me recuerda un poco sobre el código de java.util.Al azar, pero no completamente de acuerdo.
  15. 0

    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.

  16. 0

    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

  17. -1

    a ser super duper ))

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

Dejar respuesta

Please enter your comment!
Please enter your name here