Общий метод, который может возвращать случайное целое число между двумя параметрами, как ruby ​​с rand (0..n).

Есть предложения?

Yago Azedias

Ответов: 22

Ответы (22)

Я предлагаю использовать extension функцию на IntRange для создания таких случайных чисел: (0..10) .random ()

TL; DR Kotlin> = 1.3, один случайный для всех платформ

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

val rnds = (0..10).random() // generated random from 0 to 10 included

Котлин <1,3

До версии 1.3 в JVM мы использовали Random или даже ThreadLocalRandom, если мы используем JDK> 1.6.

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

Используется так:

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

Если вы хотите, чтобы функция возвращала только 1, 2, ..., 9 (10 не входит), используйте диапазон, построенный с помощью до тех пор, пока:

(0 until 10).random()

Если вы работаете с JDK> 1.6, используйте ThreadLocalRandom.current () вместо Random ().

KotlinJs и другие варианты

Для kotlinjs и других вариантов использования, которые не позволяют использовать java.util.Random, см. эту альтернативу.

Также см. Этот ответ для вариантов моего предложения. Он также включает функцию расширения для случайных Chars.

Вы можете создать функцию расширения , похожую на java.util.Random.nextInt (int), но такую, которая принимает IntRange вместо Int для его границы:

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

Теперь вы можете использовать это с любым Случайным экземпляром:

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

Если вы не хотите управлять своим собственным экземпляром Random, вы можете определить удобный метод, используя, например, ThreadLocalRandom.current ():

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

Теперь вы можете получить случайное целое число, как в Ruby, без необходимости сначала самостоятельно объявлять экземпляр Random:

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

Возможное изменение моего другого ответа для случайных символов

Чтобы получить случайный Chars, вы можете определить функцию расширения, подобную этой

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

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

Если вы работаете с JDK> 1.6, используйте ThreadLocalRandom.current () вместо Random ().

Для kotlinjs и других случаев использования, которые не позволяют использовать java.util.Random, , этот ответ поможет.

Kotlin> = 1.3 мультиплатформенная поддержка для Random

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

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

Всякий раз, когда возникает ситуация, когда вы хотите сгенерировать ключ или MAC-адрес, который представляет собой шестнадцатеричное число с цифрами на основе запроса пользователя, и это тоже с использованием android и kotlin, тогда вам поможет мой приведенный ниже код:

private fun getRandomHexString(random: SecureRandom, numOfCharsToBePresentInTheHexString: Int): String {
    val sb = StringBuilder()
    while (sb.length < numOfCharsToBePresentInTheHexString) {
        val randomNumber = random.nextInt()
        val number = String.format("%08X", randomNumber)
        sb.append(number)
    }
    return sb.toString()
} 

Ниже в Котлине у меня хорошо сработало:

(fromNumber.rangeTo(toNumber)).random()

Диапазон чисел начинается с переменной fromNumber и заканчивается переменной toNumber.fromNumber и toNumber также будут включены в случайные числа, сгенерированные из этого.

Вы можете создать функцию расширения:

infix fun ClosedRange.step(step: Float): Iterable {
    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()
}

Round Float value:

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

Использование метода:

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

Вывод:

значение: 0,0 значение: 0,1 значение: 0,2 значение: 0,3 значение: 0,4 значение: 0,5 значение: 0,6 значение: 0,7 значение: 0,8 значение: 0,9 значение: 1,0

В Kotlin SDK> = 1.3 это можно сделать как

import kotlin.random.Random

val number = Random.nextInt(limit)

Полный исходный код. Может контролировать, разрешены ли дубликаты.

import kotlin.math.min

abstract class Random {

    companion object {
        fun string(length: Int, isUnique: Boolean = false): String {
            if (0 == length) return ""
            val alphabet: List = ('a'..'z') + ('A'..'Z') + ('0'..'9') // Add your set here.

            if (isUnique) {
                val limit = min(length, alphabet.count())
                val set = mutableSetOf()
                do { set.add(alphabet.random()) } while (set.count() != limit)
                return set.joinToString("")
            }
            return List(length) { alphabet.random() }.joinToString("")
        }

        fun alphabet(length: Int, isUnique: Boolean = false): String {
            if (0 == length) return ""
            val alphabet = ('A'..'Z')
            if (isUnique) {
                val limit = min(length, alphabet.count())
                val set = mutableSetOf()
                do { set.add(alphabet.random()) } while (set.count() != limit)
                return set.joinToString("")
            }

            return List(length) { alphabet.random() }.joinToString("")
        }
    }
}

Создает случайное целое число от от(включительно) до до(исключая)

import java.util.Random

val random = Random()

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

супер пупер))

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

Во-первых, вам нужен ГСЧ. В Kotlin в настоящее время вам нужно использовать платформы, специфичные для платформы (в нем нет встроенного Kotlin). Для JVM это java.util.Random. Вам нужно будет создать его экземпляр, а затем вызвать random.nextInt (n).

Используя функцию верхнего уровня, вы можете добиться того же синтаксиса вызова, что и в Ruby (по вашему желанию):

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

Использование:

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

Не существует стандартного метода для этого, но вы можете легко создать свой собственный, используя Math.random () или класс java.util.Random. Вот пример использования метода Math.random ():

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

fun main(args: Array) {
    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) })
}

Это пример вывода:

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

Чтобы получить случайное число Int в Kotlin, используйте следующий метод:

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

Надеюсь, это поможет.

Примеры случайны в диапазоне [1, 10]

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

или с использованием Java Random

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

Если числа, которые вы хотите выбрать, не являются последовательными, вы можете использовать random ().

Использование:

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

Возвращает одно из чисел, находящихся в списке.

No need to use custom extension functions anymore. IntRange has a random() extension function out-of-the-box now.

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

Начиная с kotlin 1.2, вы могли писать:

(1..3) .shuffled (). Last ()

Просто имейте в виду, что это большой O (n), но для небольшого списка (особенно уникальных значений) все в порядке: D

Another way of implementing s1m0nw1's answer would be to access it through a variable. Not that its any more efficient but it saves you from having to type ().

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

И теперь к нему можно обращаться как к

(1..10).random

Kotlin> = 1.3, мультиплатформенная поддержка Random

Начиная с версии 1.3, стандартная библиотека обеспечивала мультиплатформенную поддержку случайных чисел, см. этот ответ.

Kotlin <1.3 на JavaScript

Если вы работаете с Kotlin JavaScript и не имеете доступа к java.util.Random, будет работать следующее:

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

Используется так:

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

Построение @ s1m0nw1 отличный ответ Я внес следующие изменения.

  1. (0..n) подразумевает включительно в Котлине
  2. (от 0 до n) подразумевает исключение в Котлине
  3. Используйте одноэлементный объект для экземпляра Random (необязательно)

Код:

private object RandomRangeSingleton : Random()

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

Тестовый пример:

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

Стандартная библиотека Kotlin не предоставляет API генератора случайных чисел. Если вы не участвуете в многоплатформенном проекте, лучше использовать платформу api (все остальные ответы на вопрос говорят об этом решении).

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

Чтобы решить эту проблему в моем личном проекте, я использую чистый Kotlin Linear Congruential Generator. LCG - это алгоритм, используемый java.util.Random. Перейдите по этой ссылке, если хотите ее использовать: https://gist.github.com/11e5ddb567786af0ed1ae4d7f57441d4

Цель моей реализации nextInt (range: IntRange) для вас;).

Позаботьтесь о моей цели, LCG подходит для большинства случаев использования (моделирование, игры и т. Д.), но не подходит для криптографического использования из-за предсказуемости этого метода.

2022 WebDevInsider